A critical incompatibility with Elixir 1.6 is addressed by an open pull request. Without this change, Inflex.camelize(:lower) remains broken in Elixir 1.6.

Actual:

 iex> Inflex.singularize("reserves")
"reserf" # should be "reserve"

Convert string to UpperCamelCase or have a :lower flag to convert string to lowerCamelCase.

"UpperCamelCase" = Inflex.camelize("upper_camel_case")

"lowerCamelCase" = Inflex.camelize("lower_camel_case", :lower)

Hi,

Could you please add a tag for 1.4.0 to the repo? It would simplify building packages a bit :)

inflex is promoting the anti-pattern of defining functions in my code with use. In Elixir, we usually avoid those unless the module is implementing a well defined behaviour (think GenServer). We have also documented this anti-pattern: https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3559-L3600

I would just move all the functions to the Inflex module which would then be imported as:

import Inflex

This is the simplest way because, if I don't want camelize, I can do:

import Inflex, except: [camelize: 1]

Most Elixir developers know how to use import well. The current inflex implementation puts aside import into its own scheme which generates code into my own module and relies on function indirection with __using__. To drive the point home, imagine every time I wanted to use Enum, it defined all Enum functions in my modules.

I don't believe there is a need for a single __using__ callback in Inflex. They are just functions.

Hi, thanks for this library.

I received a dependabot automated PR to bump inflex to version 2.1.0, but when I looked at the changes here I don't see a version bump to 2.1.0.

In fact, I see several changes in hexdiff that aren't reflected here. This doesn't look like a security issue, but I'm curious what's happened.

Needing pluralize/1 to work for words specifically ending in an "s". Currently it doesn't. Example attached

Hi,

I'm interested to contribute in order to offer some sort of localization of the inflexions.
Before going to add a particular language.
I wanted to discuss for the "architecture" of handling the configuration of the locale setting.

I see three ways to do it internally with both a global default and an option to do it per function.
But in any case, this needs to have all the inflexions mechanisms (I mean all the string manipulation and matching functions) separated from all the language related rules and data.

1. Using the Elixir Config module and setting a locale config value (eg. "en", "fr", etc.)
2. Using an optional key-value parameter (eg. locale: "fr") in each function
3. Using a dedicated function that can be invoked at any time to set the locale from that moment on (not fan of that, but it's a possibility)

Another option could be to handle the localization setting itself outside with for example ex_cldr. This needs an extra dependency, but it's possible to add it for those already using a package already using it (like ex_money).
But in this case all the language related rules and data should still be done internally.

Again it's necessary in any case to separate the string manipulation mechanisms with the language data rules themselves.
In this situation, it can be even possible to separate all the data as a separate package (or not).

What do you think?

Inflex 1.8.1, Elixir 1.6.1

iex(5)> Inflex.camelize("pascal-case", :lower)
"PascalCase"

Should be:

"pascalCase"

I think the problem is the Regex in camelize.ex

iex(6)> Regex.split(~r/(?:^|[-_])|(?=[A-Z])/, to_string("two_words"))
["", "two", "words"]

I suspect the initial empty string is breaking the camelize_list function. This seems to be a change between Elixir 1.5.3 and Elixir 1.6.1 (the two versions I can easily swap between):

❯ asdf local elixir 1.5.3

~/test/test
❯ iex -S mix
Erlang/OTP 20 [erts-9.2] [source] [64-bit] [smp:12:12] [ds:12:12:10] [async-threads:10] [hipe] [kernel-poll:false]

iex(1)> Inflex.camelize("pascal-case", :lower)
"pascalCase"
iex(2)> Regex.split(~r/(?:^|[-_])|(?=[A-Z])/, to_string("two_words"))
["two", "words"]


^C
~/test/test
❯ asdf local elixir 1.6.0-otp-20

~/test/test
❯ iex -S mix
Erlang/OTP 20 [erts-9.2] [source] [64-bit] [smp:12:12] [ds:12:12:10] [async-threads:10] [hipe] [kernel-poll:false]

iex(1)> Inflex.camelize("pascal-case", :lower)
"PascalCase"
iex(2)> Regex.split(~r/(?:^|[-_])|(?=[A-Z])/, to_string("two_words"))
["", "two", "words"]
^C

The plural of canvas is canvases, but Inflex.plurarlize returns canvas (and it's likely Inflex.singularize will return canva I haven't verified it yet)

Should be "heroes" in the majority of cases

Thanks for the library, I really appreciate it!

iex(3)> Inflex.singularize("Menus")
"Menu"

Works but the opposite
iex(2)> Inflex.pluralize("Menu")
"Menu"
doesn't work

I forked this project mid Dec '15 and turned it into full stack Text Mining / Natural Language Processing library for the Elixir Programming language which is reaching a good place (i think). I built an ordinalizer into it because it simply didn't exist in inflex.

I am going to make the repo public and push to hex in the coming months but I have decided to now remove the inflector completely in favor of this library. Would you consider / be interested if I submitted a PR to incorporate an ordinalizer into inflex?

ordinalize.ex

defmodule Inflector.Ordinalize do
  @moduledoc false

  def ordinalize(number) when is_number(number) do
    cond do
      number in [11, 12, 13, 14] ->
        Integer.to_string(number) <> "th"
      rem(number, 10) == 1 ->
        Integer.to_string(number) <> "st"
      rem(number, 10) == 2 ->
        Integer.to_string(number) <> "nd"
      rem(number, 10) == 3 ->
        Integer.to_string(number) <> "rd"
      true ->
        Integer.to_string(number) <> "th"
    end
  end
end

iex(3)> Inflex.parameterize("Secrétaire, sténo dactylographe ")
"secrétaire,-sténo-dactylographe-"

while the expected is:

iex(3)> Inflex.parameterize("Secrétaire, sténo dactylographe ")
"secretaire-steno-dactylographe"

at least if the objective is to mimic rails' parameterize's behavior

I'm seeing this when pointing at Hex

error: module Inflex is not loaded and could not be found

But not when ref'ing this github repo.

First of all really cool library.
This is a super nitpick, but when I was reading the code I couldn't stop to notice that it seems there is some code duplications in https://github.com/nurugger07/inflex/blob/master/lib/inflex/pluralize.ex#L102

The pluralization of the word personal is wrong:

iex(10)> Inflex.pluralize "personal"
"peopleal"

Here, I expected the output to be personals.

In my use case, I wanted to translate personal trainer, but it finds people in the middle and pluralizes that.

iex(11)> Inflex.pluralize "personal_trainer"
"peopleal_trainer"

I expected the output to be personal_trainers.

The same happens when the words are separated by a space:

iex(6)> Inflex.pluralize "personal trainer"
"peopleal trainer"

Hello!

There's a bunch of good stuff that's not on hex.pm yet. Could you release this please? :)

Cheers,
Louis

So when I fetch and try to run mix test with elixir v0.13, this happens. I've not yet run into this, wanted to report it. Looking into it now. :)

This is something that is common and maybe best added here.

iex(1)> Inflex.parameterize("First Name")
"first-name"

iex(2)> Inflex.parameterize("First Name", "_")
"first_name"

I would assume that the pluralized word would start with an uppercase letter if the singular word does.

iex(1)> Inflex.pluralize "Dog"
"Dogs"
iex(2)> Inflex.pluralize "Person"
"people"

Pluralize:

iex> Inflex.pluralize("life")
"liives" # should be "lives"
iex> Inflex.pluralize("elf")
"eves" # should be "elves"
iex> Inflex.pluralize("wolf")
"woves" # should be "wolves"
iex> Inflex.pluralize("hoof")
"hoofs" # should be "hooves"
iex> Inflex.pluralize("knife")
"kniives" # should be "knives"

Singularize:

iex> Inflex.singularize("elves")
"elfe" # should be "elf"
iex> Inflex.singularize("wolves")
"wolfe" # should be "wolf"
iex> Inflex.singularize("hooves")
"hoofe" # should be "hoof"

I expect both of the following to return the same output, but they don't:

iex(6)> Inflex.camelize("THIS_IS_IT")  
"THISISIT"
iex(7)> Inflex.camelize("this_is_it")
"ThisIsIt"

There is no changelog for this project, so I don't know what changed from 1.x to 2.0. Is this upgrade safe? Are there breaking changes? I tried glancing through the commits, but can't really glean enough from them.

https://keepachangelog.com/en/1.0.0/

Looks like Hex & Github disagree:

• https://hex.pm/packages/inflex/1.10.0
• https://github.com/nurugger07/inflex/releases/tag/v1.4.1