rads.inflections — io.github.rads/inflections 0.14.2

A fork of inflections-clj with compatibility for Cherry.

*acronyms* clj/s

*irregular-words* clj/s

*plural-rules* clj/s

*singular-rules* clj/s

*uncountable-words* clj/s

->rule clj/s

(->rule pattern replacement)

acronym clj/s

(acronym s)

Returns the the acronym for s if it is one, otherwise nil.

add-acronym! clj/s

(add-acronym! word)

Adds word to the set of *acronyms*.

add-irregular! clj/s

(add-irregular! singular plural)

Add singular and plural to the set of *irregular-words*.

add-rule! clj/s

(add-rule! rules rule)

add-uncountable! clj/s

(add-uncountable! word)

Adds word to the set of *uncountable-words*.

camel-case clj/s

(camel-case word & [mode])

Convert word to camel case. By default, camel-case converts to UpperCamelCase. If the argument to camel-case is set to :lower then camel-case produces lowerCamelCase.

Examples:

(camel-case "active_record") ;=> "ActiveRecord"

(camel-case "active_record" :lower) ;=> "activeRecord"

(camel-case "active_record/errors") ;=> "ActiveRecord/Errors"

(camel-case "active_record/errors" :lower) ;=> "activeRecord/Errors"

camel-case-keys clj/s

(camel-case-keys m & [mode])

Recursively apply camel-case on all keys of m.

capitalize clj/s

(capitalize word)

Convert the first letter in word to upper case.

Examples:

(capitalize "hello") ;=> "Hello"

(capitalize "HELLO") ;=> "Hello"

(capitalize "abc123") ;=> "Abc123"

coerce clj/s

(coerce obj s)

Coerce the string s to the type of obj.

countable? clj/s

(countable? s)

Returns true if s is countable, otherwise false.

dasherize clj/s

(dasherize s)

Replaces all underscores in s with dashes.

Examples:

(dasherize "puni_puni") ;=> "puni-puni"

delete-acronym! clj/s

(delete-acronym! word)

Delete word from the set of *acronyms*.

delete-irregular! clj/s

(delete-irregular! singular plural)

Delete singular and plural from the set of irregular-words.

delete-uncountable! clj/s

(delete-uncountable! word)

Delete word from the set of *uncountable-words*.

demodulize clj/s

(demodulize x)

Removes the module part from x.

Examples:

(demodulize "inflections.MyRecord") ;=> "MyRecord"

(demodulize "ActiveRecord::CoreExtensions::String::Inflections") ;=> "Inflections"

(demodulize "Inflections") ;=> "Inflections"

foreign-key clj/s

(foreign-key x & [sep])

Converts x into a foreign key. The default separator "_" is placed between the name and "id".

Examples:

(foreign-key "Message") ;=> "message_id"

(foreign-key "Message" false) ;=> "messageid"

(foreign-key "Admin::Post") ;=> "post_id"

hyphenate clj/s

(hyphenate x)

Hyphenate x, which is the same as threading x through the str, underscore and dasherize fns.

Examples:

(hyphenate 'Continent) ; => "continent"

(hyphenate "CountryFlag") ; => "country-flag"

hyphenate-keys clj/s

(hyphenate-keys m)

Recursively apply hyphenate on all keys of m.

hyphenate-values clj/s

(hyphenate-values m)

Recursively apply hyphenate on all values of m.

init-inflections! clj/s

(init-inflections!)

Initialize the Inflections library with defaults.

init-irregular-words! clj/s

(init-irregular-words!)

init-plural-rules! clj/s

(init-plural-rules!)

init-singular-rules! clj/s

(init-singular-rules!)

irregular? clj/s

(irregular? word)

Returns true if word is an irregular word, otherwise false.

ordinalize clj/s

(ordinalize x)

Turns x into an ordinal string used to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th, etc.

Examples:

(ordinalize "1") ;=> "1st"

(ordinalize "23") ;=> "23rd"

parameterize clj/s

(parameterize x & [sep])

Replaces special characters in x with the default separator "-". so that it may be used as part of a pretty URL.

Examples:

(parameterize "Donald E. Knuth") ; => "donald-e-knuth"

(parameterize "Donald E. Knuth" "_") ; => "donald_e_knuth"

plural clj/s

(plural s)

Returns the plural of s.

plural! clj/s

(plural! & patterns-and-replacements)

Define rule(s) to map words from singular to plural.

Examples: (plural! #"$(?i)" "s") (plural! #"(ax|test)is$(?i)" "$1es" #"(octop|vir)us$(?i)" "$1i")

pluralize clj/s

(pluralize count singular & [plural])

Attempts to pluralize the word unless count is 1. If plural is supplied, it will use that when count is > 1, otherwise it will use the inflector to determine the plural form.

reset-rules! clj/s

(reset-rules! rules)

Resets the list of plural rules.

resolve-rule clj/s

(resolve-rule rule word)

resolve-rules clj/s

(resolve-rules rules word)

singular clj/s

(singular s)

Returns the singular of s.

singular! clj/s

(singular! & patterns-and-replacements)

Define rule(s) to map words from singular to plural.

Examples: (singular! #"(n)ews$(?i)" "$1ews") (singular! #"(m)ovies$(?i)" "$1ovie" #"([m|l])ice$(?i)" "$1ouse")

slurp-rules clj/s

(slurp-rules & patterns-and-replacements)

Returns a seq of rules, where the pattern and replacement must be given in pairs of two elements.

str-name clj/s

(str-name x)

Same as clojure.core/name, but keeps the namespace for keywords and symbols.

stringify-keys clj/s

(stringify-keys m)

Recursively transform all keys of m into strings.

stringify-values clj/s

(stringify-values m)

Recursively transform all values of m into strings.

titleize clj/s

(titleize s)

Convert s into a title.

transform-keys clj/s

(transform-keys m f)

Recursively transform all keys in the map m by applying f on them.

transform-values clj/s

(transform-values m f)

Recursively transform all map values of m by applying f on them.

uncountable? clj/s

(uncountable? x)

Returns true if x is uncountable, otherwise false.

underscore clj/s

(underscore x)

The reverse of camel-case. Makes an underscored, lowercase form from the expression in the string.

Examples:

(underscore "ActiveRecord") ;=> "active_record"

(underscore "ActiveRecord::Errors") ;=> "active_record::errors"

underscore-keys clj/s

(underscore-keys m)

Recursively apply underscore on all keys of m.