From b257a377f98e04b16e61d6160be5a5bf8b1e5ec6 Mon Sep 17 00:00:00 2001 From: Markus Schirp Date: Wed, 12 Dec 2012 18:24:10 +0100 Subject: [PATCH] Correctly vendor inflector --- Changelog.md | 4 + lib/inflector.rb | 7 - lib/inflector/defaults.rb | 62 -------- lib/inflector/inflections.rb | 209 --------------------------- lib/inflector/methods.rb | 149 -------------------- lib/inflector/version.rb | 3 - lib/mutant.rb | 2 +- lib/mutant/inflector.rb | 10 ++ lib/mutant/inflector/defaults.rb | 64 +++++++++ lib/mutant/inflector/inflections.rb | 211 ++++++++++++++++++++++++++++ lib/mutant/inflector/methods.rb | 151 ++++++++++++++++++++ lib/mutant/inflector/version.rb | 5 + 12 files changed, 446 insertions(+), 431 deletions(-) delete mode 100644 lib/inflector.rb delete mode 100644 lib/inflector/defaults.rb delete mode 100644 lib/inflector/inflections.rb delete mode 100644 lib/inflector/methods.rb delete mode 100644 lib/inflector/version.rb create mode 100644 lib/mutant/inflector.rb create mode 100644 lib/mutant/inflector/defaults.rb create mode 100644 lib/mutant/inflector/inflections.rb create mode 100644 lib/mutant/inflector/methods.rb create mode 100644 lib/mutant/inflector/version.rb diff --git a/Changelog.md b/Changelog.md index b3a89a04..defbf770 100644 --- a/Changelog.md +++ b/Changelog.md @@ -1,3 +1,7 @@ +# v0.2.4 2012-12-12 + +* [fixed] Correctly vendor inflector + # v0.2.3 2012-12-08 * [fixed] Prepend extra elements to hash and array instead of append. This fixes unkillable mutators in parallel assignments! diff --git a/lib/inflector.rb b/lib/inflector.rb deleted file mode 100644 index 652aaaca..00000000 --- a/lib/inflector.rb +++ /dev/null @@ -1,7 +0,0 @@ -# Library namespace -module Inflector -end - -require 'inflector/inflections' -require 'inflector/defaults' -require 'inflector/methods' diff --git a/lib/inflector/defaults.rb b/lib/inflector/defaults.rb deleted file mode 100644 index fb8d56dd..00000000 --- a/lib/inflector/defaults.rb +++ /dev/null @@ -1,62 +0,0 @@ -module Inflector - Inflector::Inflections.instance.instance_eval do - plural(/$/, 's') - plural(/s$/i, 's') - plural(/us$/i, 'i') - plural(/(ax|test)is$/i, '\1es') - plural(/(octop|vir)us$/i, '\1i') - plural(/(octop|vir)i$/i, '\1i') - plural(/(alias|status)$/i, '\1es') - plural(/(bu)s$/i, '\1ses') - plural(/(buffal|tomat)o$/i, '\1oes') - plural(/([ti])um$/i, '\1a') - plural(/([ti])a$/i, '\1a') - plural(/sis$/i, 'ses') - plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves') - plural(/(hive)$/i, '\1s') - plural(/([^aeiouy]|qu)y$/i, '\1ies') - plural(/(x|ch|ss|sh)$/i, '\1es') - plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices') - plural(/([m|l])ouse$/i, '\1ice') - plural(/([m|l])ice$/i, '\1ice') - plural(/^(ox)$/i, '\1en') - plural(/^(oxen)$/i, '\1') - plural(/(quiz)$/i, '\1zes') - - singular(/s$/i, '') - singular(/i$/i, 'us') - singular(/(n)ews$/i, '\1ews') - singular(/([ti])a$/i, '\1um') - singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis') - singular(/(^analy)ses$/i, '\1sis') - singular(/([^f])ves$/i, '\1fe') - singular(/(hive)s$/i, '\1') - singular(/(tive)s$/i, '\1') - singular(/([lr])ves$/i, '\1f') - singular(/([^aeiouy]|qu)ies$/i, '\1y') - singular(/(s)eries$/i, '\1eries') - singular(/(m)ovies$/i, '\1ovie') - singular(/(x|ch|ss|sh)es$/i, '\1') - singular(/([m|l])ice$/i, '\1ouse') - singular(/(bus)es$/i, '\1') - singular(/(o)es$/i, '\1') - singular(/(shoe)s$/i, '\1') - singular(/(cris|ax|test)es$/i, '\1is') - singular(/(octop|vir)i$/i, '\1us') - singular(/(alias|status)es$/i, '\1') - singular(/^(ox)en/i, '\1') - singular(/(vert|ind)ices$/i, '\1ex') - singular(/(matr)ices$/i, '\1ix') - singular(/(quiz)zes$/i, '\1') - singular(/(database)s$/i, '\1') - - irregular('person', 'people') - irregular('man', 'men') - irregular('child', 'children') - irregular('sex', 'sexes') - irregular('move', 'moves') - irregular('cow', 'kine') - - uncountable(%w(grass equipment information rice money species series fish sheep jeans)) - end -end diff --git a/lib/inflector/inflections.rb b/lib/inflector/inflections.rb deleted file mode 100644 index 01f3cd82..00000000 --- a/lib/inflector/inflections.rb +++ /dev/null @@ -1,209 +0,0 @@ -module Inflector - # A singleton instance of this class is yielded by Inflector.inflections, which can then be used to specify additional - # inflection rules. Examples: - # - # Inflector.inflections do |inflect| - # inflect.plural /^(ox)$/i, '\1\2en' - # inflect.singular /^(ox)en/i, '\1' - # - # inflect.irregular 'octopus', 'octopi' - # - # inflect.uncountable "equipment" - # end - # - # New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the - # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may - # already have been loaded. - class Inflections - def self.instance - @__instance__ ||= new - end - - attr_reader :plurals, :singulars, :uncountables, :humans - - def initialize - @plurals, @singulars, @uncountables, @humans = [], [], [], [] - end - - # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression. - # The replacement should always be a string that may include references to the matched data from the rule. - def plural(rule, replacement) - @uncountables.delete(rule) if rule.is_a?(String) - @uncountables.delete(replacement) - @plurals.insert(0, [rule, replacement]) - end - - # Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression. - # The replacement should always be a string that may include references to the matched data from the rule. - def singular(rule, replacement) - @uncountables.delete(rule) if rule.is_a?(String) - @uncountables.delete(replacement) - @singulars.insert(0, [rule, replacement]) - end - - # Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used - # for strings, not regular expressions. You simply pass the irregular in singular and plural form. - # - # Examples: - # irregular 'octopus', 'octopi' - # irregular 'person', 'people' - def irregular(singular, plural) - @uncountables.delete(singular) - @uncountables.delete(plural) - if singular[0,1].upcase == plural[0,1].upcase - plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1]) - plural(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + plural[1..-1]) - singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1]) - else - plural(Regexp.new("#{singular[0,1].upcase}(?i)#{singular[1..-1]}$"), plural[0,1].upcase + plural[1..-1]) - plural(Regexp.new("#{singular[0,1].downcase}(?i)#{singular[1..-1]}$"), plural[0,1].downcase + plural[1..-1]) - plural(Regexp.new("#{plural[0,1].upcase}(?i)#{plural[1..-1]}$"), plural[0,1].upcase + plural[1..-1]) - plural(Regexp.new("#{plural[0,1].downcase}(?i)#{plural[1..-1]}$"), plural[0,1].downcase + plural[1..-1]) - singular(Regexp.new("#{plural[0,1].upcase}(?i)#{plural[1..-1]}$"), singular[0,1].upcase + singular[1..-1]) - singular(Regexp.new("#{plural[0,1].downcase}(?i)#{plural[1..-1]}$"), singular[0,1].downcase + singular[1..-1]) - end - end - - # Add uncountable words that shouldn't be attempted inflected. - # - # Examples: - # uncountable "money" - # uncountable "money", "information" - # uncountable %w( money information rice ) - def uncountable(*words) - (@uncountables << words).flatten! - end - - # Specifies a humanized form of a string by a regular expression rule or by a string mapping. - # When using a regular expression based replacement, the normal humanize formatting is called after the replacement. - # When a string is used, the human form should be specified as desired (example: 'The name', not 'the_name') - # - # Examples: - # human /_cnt$/i, '\1_count' - # human "legacy_col_person_name", "Name" - def human(rule, replacement) - @humans.insert(0, [rule, replacement]) - end - - # Clears the loaded inflections within a given scope (default is :all). - # Give the scope as a symbol of the inflection type, the options are: :plurals, - # :singulars, :uncountables, :humans. - # - # Examples: - # clear :all - # clear :plurals - def clear(scope = :all) - case scope - when :all - @plurals, @singulars, @uncountables = [], [], [] - else - instance_variable_set "@#{scope}", [] - end - end - end - - # Yields a singleton instance of Inflector::Inflections so you can specify additional - # inflector rules. - # - # Example: - # Inflector.inflections do |inflect| - # inflect.uncountable "rails" - # end - def inflections - if block_given? - yield Inflections.instance - else - Inflections.instance - end - end - - # Returns the plural form of the word in the string. - # - # Examples: - # "post".pluralize # => "posts" - # "octopus".pluralize # => "octopi" - # "sheep".pluralize # => "sheep" - # "words".pluralize # => "words" - # "CamelOctopus".pluralize # => "CamelOctopi" - def pluralize(word) - result = word.to_s.dup - - if word.empty? || inflections.uncountables.include?(result.downcase) - result - else - inflections.plurals.each { |(rule, replacement)| break if result.gsub!(rule, replacement) } - result - end - end - - # The reverse of +pluralize+, returns the singular form of a word in a string. - # - # Examples: - # "posts".singularize # => "post" - # "octopi".singularize # => "octopus" - # "sheep".singularize # => "sheep" - # "word".singularize # => "word" - # "CamelOctopi".singularize # => "CamelOctopus" - def singularize(word) - result = word.to_s.dup - - if inflections.uncountables.any? { |inflection| result =~ /\b(#{inflection})\Z/i } - result - else - inflections.singulars.each { |(rule, replacement)| break if result.gsub!(rule, replacement) } - result - end - end - - # Capitalizes the first word and turns underscores into spaces and strips a - # trailing "_id", if any. Like +titleize+, this is meant for creating pretty output. - # - # Examples: - # "employee_salary" # => "Employee salary" - # "author_id" # => "Author" - def humanize(lower_case_and_underscored_word) - result = lower_case_and_underscored_word.to_s.dup - - inflections.humans.each { |(rule, replacement)| break if result.gsub!(rule, replacement) } - result.gsub(/_id$/, "").gsub(/_/, " ").capitalize - end - - # Capitalizes all the words and replaces some characters in the string to create - # a nicer looking title. +titleize+ is meant for creating pretty output. It is not - # used in the Rails internals. - # - # +titleize+ is also aliased as as +titlecase+. - # - # Examples: - # "man from the boondocks".titleize # => "Man From The Boondocks" - # "x-men: the last stand".titleize # => "X Men: The Last Stand" - def titleize(word) - humanize(underscore(word)).gsub(/\b('?[a-z])/) { $1.capitalize } - end - - # Create the name of a table like Rails does for models to table names. This method - # uses the +pluralize+ method on the last word in the string. - # - # Examples - # "RawScaledScorer".tableize # => "raw_scaled_scorers" - # "egg_and_ham".tableize # => "egg_and_hams" - # "fancyCategory".tableize # => "fancy_categories" - def tableize(class_name) - pluralize(underscore(class_name)) - end - - # Create a class name from a plural table name like Rails does for table names to models. - # Note that this returns a string and not a Class. (To convert to an actual class - # follow +classify+ with +constantize+.) - # - # Examples: - # "egg_and_hams".classify # => "EggAndHam" - # "posts".classify # => "Post" - # - # Singular names are not handled correctly: - # "business".classify # => "Busines" - def classify(table_name) - # strip out any leading schema name - camelize(singularize(table_name.to_s.sub(/.*\./, ''))) - end -end diff --git a/lib/inflector/methods.rb b/lib/inflector/methods.rb deleted file mode 100644 index 17d3c7c7..00000000 --- a/lib/inflector/methods.rb +++ /dev/null @@ -1,149 +0,0 @@ -# The Inflector transforms words from singular to plural, class names to table names, modularized class names to ones without, -# and class names to foreign keys. The default inflections for pluralization, singularization, and uncountable words are kept -# in inflections.rb. -# -# The Rails core team has stated patches for the inflections library will not be accepted -# in order to avoid breaking legacy applications which may be relying on errant inflections. -# If you discover an incorrect inflection and require it for your application, you'll need -# to correct it yourself (explained below). -module Inflector - extend self - - # By default, +camelize+ converts strings to UpperCamelCase. If the argument to +camelize+ - # is set to :lower then +camelize+ produces lowerCamelCase. - # - # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces. - # - # Examples: - # "active_record".camelize # => "ActiveRecord" - # "active_record".camelize(:lower) # => "activeRecord" - # "active_record/errors".camelize # => "ActiveRecord::Errors" - # "active_record/errors".camelize(:lower) # => "activeRecord::Errors" - # - # As a rule of thumb you can think of +camelize+ as the inverse of +underscore+, - # though there are cases where that does not hold: - # - # "SSLError".underscore.camelize # => "SslError" - def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true) - if first_letter_in_uppercase - lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase } - else - lower_case_and_underscored_word.to_s[0].chr.downcase + camelize(lower_case_and_underscored_word)[1..-1] - end - end - - # Makes an underscored, lowercase form from the expression in the string. - # - # Changes '::' to '/' to convert namespaces to paths. - # - # Examples: - # "ActiveRecord".underscore # => "active_record" - # "ActiveRecord::Errors".underscore # => active_record/errors - # - # As a rule of thumb you can think of +underscore+ as the inverse of +camelize+, - # though there are cases where that does not hold: - # - # "SSLError".underscore.camelize # => "SslError" - def underscore(camel_cased_word) - word = camel_cased_word.to_s.dup - word.gsub!(/::/, '/') - word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2') - word.gsub!(/([a-z\d])([A-Z])/,'\1_\2') - word.tr!("-", "_") - word.downcase! - word - end - - # Replaces underscores with dashes in the string. - # - # Example: - # "puni_puni" # => "puni-puni" - def dasherize(underscored_word) - underscored_word.gsub(/_/, '-') - end - - # Removes the module part from the expression in the string. - # - # Examples: - # "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections" - # "Inflections".demodulize # => "Inflections" - def demodulize(class_name_in_module) - class_name_in_module.to_s.gsub(/^.*::/, '') - end - - # Creates a foreign key name from a class name. - # +separate_class_name_and_id_with_underscore+ sets whether - # the method should put '_' between the name and 'id'. - # - # Examples: - # "Message".foreign_key # => "message_id" - # "Message".foreign_key(false) # => "messageid" - # "Admin::Post".foreign_key # => "post_id" - def foreign_key(class_name, separate_class_name_and_id_with_underscore = true) - underscore(demodulize(class_name)) + (separate_class_name_and_id_with_underscore ? "_id" : "id") - end - - # Ruby 1.9 introduces an inherit argument for Module#const_get and - # #const_defined? and changes their default behavior. - if Module.method(:const_get).arity == 1 - # Tries to find a constant with the name specified in the argument string: - # - # "Module".constantize # => Module - # "Test::Unit".constantize # => Test::Unit - # - # The name is assumed to be the one of a top-level constant, no matter whether - # it starts with "::" or not. No lexical context is taken into account: - # - # C = 'outside' - # module M - # C = 'inside' - # C # => 'inside' - # "C".constantize # => 'outside', same as ::C - # end - # - # NameError is raised when the name is not in CamelCase or the constant is - # unknown. - def constantize(camel_cased_word) - names = camel_cased_word.split('::') - names.shift if names.empty? || names.first.empty? - - constant = Object - names.each do |name| - constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name) - end - constant - end - else - def constantize(camel_cased_word) #:nodoc: - names = camel_cased_word.split('::') - names.shift if names.empty? || names.first.empty? - - constant = Object - names.each do |name| - constant = constant.const_defined?(name, false) ? constant.const_get(name) : constant.const_missing(name) - end - constant - end - end - - # Turns a number into an ordinal string used to denote the position in an - # ordered sequence such as 1st, 2nd, 3rd, 4th. - # - # Examples: - # ordinalize(1) # => "1st" - # ordinalize(2) # => "2nd" - # ordinalize(1002) # => "1002nd" - # ordinalize(1003) # => "1003rd" - def ordinalize(number) - if (11..13).include?(number.to_i % 100) - "#{number}th" - else - case number.to_i % 10 - when 1; "#{number}st" - when 2; "#{number}nd" - when 3; "#{number}rd" - else "#{number}th" - end - end - end -end diff --git a/lib/inflector/version.rb b/lib/inflector/version.rb deleted file mode 100644 index 2c3844f5..00000000 --- a/lib/inflector/version.rb +++ /dev/null @@ -1,3 +0,0 @@ -module Inflector - VERSION = '0.0.1'.freeze -end diff --git a/lib/mutant.rb b/lib/mutant.rb index 4cadb4c0..1ec44c14 100644 --- a/lib/mutant.rb +++ b/lib/mutant.rb @@ -7,7 +7,6 @@ require 'securerandom' require 'equalizer' require 'digest/sha1' require 'to_source' -require 'inflector' require 'ice_nine' require 'ice_nine/core_ext/object' require 'diff/lcs' @@ -103,3 +102,4 @@ require 'mutant/reporter' require 'mutant/reporter/stats' require 'mutant/reporter/null' require 'mutant/reporter/cli' +require 'mutant/inflector' diff --git a/lib/mutant/inflector.rb b/lib/mutant/inflector.rb new file mode 100644 index 00000000..d808a4d3 --- /dev/null +++ b/lib/mutant/inflector.rb @@ -0,0 +1,10 @@ +module Mutant + # Library namespace of vendored inflector + module Inflector + end +end + +require 'mutant/inflector/inflections' +require 'mutant/inflector/defaults' +require 'mutant/inflector/methods' + diff --git a/lib/mutant/inflector/defaults.rb b/lib/mutant/inflector/defaults.rb new file mode 100644 index 00000000..e396ac01 --- /dev/null +++ b/lib/mutant/inflector/defaults.rb @@ -0,0 +1,64 @@ +module Mutant + module Inflector + Inflector::Inflections.instance.instance_eval do + plural(/$/, 's') + plural(/s$/i, 's') + plural(/us$/i, 'i') + plural(/(ax|test)is$/i, '\1es') + plural(/(octop|vir)us$/i, '\1i') + plural(/(octop|vir)i$/i, '\1i') + plural(/(alias|status)$/i, '\1es') + plural(/(bu)s$/i, '\1ses') + plural(/(buffal|tomat)o$/i, '\1oes') + plural(/([ti])um$/i, '\1a') + plural(/([ti])a$/i, '\1a') + plural(/sis$/i, 'ses') + plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves') + plural(/(hive)$/i, '\1s') + plural(/([^aeiouy]|qu)y$/i, '\1ies') + plural(/(x|ch|ss|sh)$/i, '\1es') + plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices') + plural(/([m|l])ouse$/i, '\1ice') + plural(/([m|l])ice$/i, '\1ice') + plural(/^(ox)$/i, '\1en') + plural(/^(oxen)$/i, '\1') + plural(/(quiz)$/i, '\1zes') + + singular(/s$/i, '') + singular(/i$/i, 'us') + singular(/(n)ews$/i, '\1ews') + singular(/([ti])a$/i, '\1um') + singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis') + singular(/(^analy)ses$/i, '\1sis') + singular(/([^f])ves$/i, '\1fe') + singular(/(hive)s$/i, '\1') + singular(/(tive)s$/i, '\1') + singular(/([lr])ves$/i, '\1f') + singular(/([^aeiouy]|qu)ies$/i, '\1y') + singular(/(s)eries$/i, '\1eries') + singular(/(m)ovies$/i, '\1ovie') + singular(/(x|ch|ss|sh)es$/i, '\1') + singular(/([m|l])ice$/i, '\1ouse') + singular(/(bus)es$/i, '\1') + singular(/(o)es$/i, '\1') + singular(/(shoe)s$/i, '\1') + singular(/(cris|ax|test)es$/i, '\1is') + singular(/(octop|vir)i$/i, '\1us') + singular(/(alias|status)es$/i, '\1') + singular(/^(ox)en/i, '\1') + singular(/(vert|ind)ices$/i, '\1ex') + singular(/(matr)ices$/i, '\1ix') + singular(/(quiz)zes$/i, '\1') + singular(/(database)s$/i, '\1') + + irregular('person', 'people') + irregular('man', 'men') + irregular('child', 'children') + irregular('sex', 'sexes') + irregular('move', 'moves') + irregular('cow', 'kine') + + uncountable(%w(grass equipment information rice money species series fish sheep jeans)) + end + end +end diff --git a/lib/mutant/inflector/inflections.rb b/lib/mutant/inflector/inflections.rb new file mode 100644 index 00000000..bef5021b --- /dev/null +++ b/lib/mutant/inflector/inflections.rb @@ -0,0 +1,211 @@ +module Mutant + module Inflector + # A singleton instance of this class is yielded by Inflector.inflections, which can then be used to specify additional + # inflection rules. Examples: + # + # Inflector.inflections do |inflect| + # inflect.plural /^(ox)$/i, '\1\2en' + # inflect.singular /^(ox)en/i, '\1' + # + # inflect.irregular 'octopus', 'octopi' + # + # inflect.uncountable "equipment" + # end + # + # New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the + # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may + # already have been loaded. + class Inflections + def self.instance + @__instance__ ||= new + end + + attr_reader :plurals, :singulars, :uncountables, :humans + + def initialize + @plurals, @singulars, @uncountables, @humans = [], [], [], [] + end + + # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression. + # The replacement should always be a string that may include references to the matched data from the rule. + def plural(rule, replacement) + @uncountables.delete(rule) if rule.is_a?(String) + @uncountables.delete(replacement) + @plurals.insert(0, [rule, replacement]) + end + + # Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression. + # The replacement should always be a string that may include references to the matched data from the rule. + def singular(rule, replacement) + @uncountables.delete(rule) if rule.is_a?(String) + @uncountables.delete(replacement) + @singulars.insert(0, [rule, replacement]) + end + + # Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used + # for strings, not regular expressions. You simply pass the irregular in singular and plural form. + # + # Examples: + # irregular 'octopus', 'octopi' + # irregular 'person', 'people' + def irregular(singular, plural) + @uncountables.delete(singular) + @uncountables.delete(plural) + if singular[0,1].upcase == plural[0,1].upcase + plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1]) + plural(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + plural[1..-1]) + singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1]) + else + plural(Regexp.new("#{singular[0,1].upcase}(?i)#{singular[1..-1]}$"), plural[0,1].upcase + plural[1..-1]) + plural(Regexp.new("#{singular[0,1].downcase}(?i)#{singular[1..-1]}$"), plural[0,1].downcase + plural[1..-1]) + plural(Regexp.new("#{plural[0,1].upcase}(?i)#{plural[1..-1]}$"), plural[0,1].upcase + plural[1..-1]) + plural(Regexp.new("#{plural[0,1].downcase}(?i)#{plural[1..-1]}$"), plural[0,1].downcase + plural[1..-1]) + singular(Regexp.new("#{plural[0,1].upcase}(?i)#{plural[1..-1]}$"), singular[0,1].upcase + singular[1..-1]) + singular(Regexp.new("#{plural[0,1].downcase}(?i)#{plural[1..-1]}$"), singular[0,1].downcase + singular[1..-1]) + end + end + + # Add uncountable words that shouldn't be attempted inflected. + # + # Examples: + # uncountable "money" + # uncountable "money", "information" + # uncountable %w( money information rice ) + def uncountable(*words) + (@uncountables << words).flatten! + end + + # Specifies a humanized form of a string by a regular expression rule or by a string mapping. + # When using a regular expression based replacement, the normal humanize formatting is called after the replacement. + # When a string is used, the human form should be specified as desired (example: 'The name', not 'the_name') + # + # Examples: + # human /_cnt$/i, '\1_count' + # human "legacy_col_person_name", "Name" + def human(rule, replacement) + @humans.insert(0, [rule, replacement]) + end + + # Clears the loaded inflections within a given scope (default is :all). + # Give the scope as a symbol of the inflection type, the options are: :plurals, + # :singulars, :uncountables, :humans. + # + # Examples: + # clear :all + # clear :plurals + def clear(scope = :all) + case scope + when :all + @plurals, @singulars, @uncountables = [], [], [] + else + instance_variable_set "@#{scope}", [] + end + end + end + + # Yields a singleton instance of Inflector::Inflections so you can specify additional + # inflector rules. + # + # Example: + # Inflector.inflections do |inflect| + # inflect.uncountable "rails" + # end + def inflections + if block_given? + yield Inflections.instance + else + Inflections.instance + end + end + + # Returns the plural form of the word in the string. + # + # Examples: + # "post".pluralize # => "posts" + # "octopus".pluralize # => "octopi" + # "sheep".pluralize # => "sheep" + # "words".pluralize # => "words" + # "CamelOctopus".pluralize # => "CamelOctopi" + def pluralize(word) + result = word.to_s.dup + + if word.empty? || inflections.uncountables.include?(result.downcase) + result + else + inflections.plurals.each { |(rule, replacement)| break if result.gsub!(rule, replacement) } + result + end + end + + # The reverse of +pluralize+, returns the singular form of a word in a string. + # + # Examples: + # "posts".singularize # => "post" + # "octopi".singularize # => "octopus" + # "sheep".singularize # => "sheep" + # "word".singularize # => "word" + # "CamelOctopi".singularize # => "CamelOctopus" + def singularize(word) + result = word.to_s.dup + + if inflections.uncountables.any? { |inflection| result =~ /\b(#{inflection})\Z/i } + result + else + inflections.singulars.each { |(rule, replacement)| break if result.gsub!(rule, replacement) } + result + end + end + + # Capitalizes the first word and turns underscores into spaces and strips a + # trailing "_id", if any. Like +titleize+, this is meant for creating pretty output. + # + # Examples: + # "employee_salary" # => "Employee salary" + # "author_id" # => "Author" + def humanize(lower_case_and_underscored_word) + result = lower_case_and_underscored_word.to_s.dup + + inflections.humans.each { |(rule, replacement)| break if result.gsub!(rule, replacement) } + result.gsub(/_id$/, "").gsub(/_/, " ").capitalize + end + + # Capitalizes all the words and replaces some characters in the string to create + # a nicer looking title. +titleize+ is meant for creating pretty output. It is not + # used in the Rails internals. + # + # +titleize+ is also aliased as as +titlecase+. + # + # Examples: + # "man from the boondocks".titleize # => "Man From The Boondocks" + # "x-men: the last stand".titleize # => "X Men: The Last Stand" + def titleize(word) + humanize(underscore(word)).gsub(/\b('?[a-z])/) { $1.capitalize } + end + + # Create the name of a table like Rails does for models to table names. This method + # uses the +pluralize+ method on the last word in the string. + # + # Examples + # "RawScaledScorer".tableize # => "raw_scaled_scorers" + # "egg_and_ham".tableize # => "egg_and_hams" + # "fancyCategory".tableize # => "fancy_categories" + def tableize(class_name) + pluralize(underscore(class_name)) + end + + # Create a class name from a plural table name like Rails does for table names to models. + # Note that this returns a string and not a Class. (To convert to an actual class + # follow +classify+ with +constantize+.) + # + # Examples: + # "egg_and_hams".classify # => "EggAndHam" + # "posts".classify # => "Post" + # + # Singular names are not handled correctly: + # "business".classify # => "Busines" + def classify(table_name) + # strip out any leading schema name + camelize(singularize(table_name.to_s.sub(/.*\./, ''))) + end + end +end diff --git a/lib/mutant/inflector/methods.rb b/lib/mutant/inflector/methods.rb new file mode 100644 index 00000000..f13f34bb --- /dev/null +++ b/lib/mutant/inflector/methods.rb @@ -0,0 +1,151 @@ +module Mutant + # The Inflector transforms words from singular to plural, class names to table names, modularized class names to ones without, + # and class names to foreign keys. The default inflections for pluralization, singularization, and uncountable words are kept + # in inflections.rb. + # + # The Rails core team has stated patches for the inflections library will not be accepted + # in order to avoid breaking legacy applications which may be relying on errant inflections. + # If you discover an incorrect inflection and require it for your application, you'll need + # to correct it yourself (explained below). + module Inflector + extend self + + # By default, +camelize+ converts strings to UpperCamelCase. If the argument to +camelize+ + # is set to :lower then +camelize+ produces lowerCamelCase. + # + # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces. + # + # Examples: + # "active_record".camelize # => "ActiveRecord" + # "active_record".camelize(:lower) # => "activeRecord" + # "active_record/errors".camelize # => "ActiveRecord::Errors" + # "active_record/errors".camelize(:lower) # => "activeRecord::Errors" + # + # As a rule of thumb you can think of +camelize+ as the inverse of +underscore+, + # though there are cases where that does not hold: + # + # "SSLError".underscore.camelize # => "SslError" + def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true) + if first_letter_in_uppercase + lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase } + else + lower_case_and_underscored_word.to_s[0].chr.downcase + camelize(lower_case_and_underscored_word)[1..-1] + end + end + + # Makes an underscored, lowercase form from the expression in the string. + # + # Changes '::' to '/' to convert namespaces to paths. + # + # Examples: + # "ActiveRecord".underscore # => "active_record" + # "ActiveRecord::Errors".underscore # => active_record/errors + # + # As a rule of thumb you can think of +underscore+ as the inverse of +camelize+, + # though there are cases where that does not hold: + # + # "SSLError".underscore.camelize # => "SslError" + def underscore(camel_cased_word) + word = camel_cased_word.to_s.dup + word.gsub!(/::/, '/') + word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2') + word.gsub!(/([a-z\d])([A-Z])/,'\1_\2') + word.tr!("-", "_") + word.downcase! + word + end + + # Replaces underscores with dashes in the string. + # + # Example: + # "puni_puni" # => "puni-puni" + def dasherize(underscored_word) + underscored_word.gsub(/_/, '-') + end + + # Removes the module part from the expression in the string. + # + # Examples: + # "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections" + # "Inflections".demodulize # => "Inflections" + def demodulize(class_name_in_module) + class_name_in_module.to_s.gsub(/^.*::/, '') + end + + # Creates a foreign key name from a class name. + # +separate_class_name_and_id_with_underscore+ sets whether + # the method should put '_' between the name and 'id'. + # + # Examples: + # "Message".foreign_key # => "message_id" + # "Message".foreign_key(false) # => "messageid" + # "Admin::Post".foreign_key # => "post_id" + def foreign_key(class_name, separate_class_name_and_id_with_underscore = true) + underscore(demodulize(class_name)) + (separate_class_name_and_id_with_underscore ? "_id" : "id") + end + + # Ruby 1.9 introduces an inherit argument for Module#const_get and + # #const_defined? and changes their default behavior. + if Module.method(:const_get).arity == 1 + # Tries to find a constant with the name specified in the argument string: + # + # "Module".constantize # => Module + # "Test::Unit".constantize # => Test::Unit + # + # The name is assumed to be the one of a top-level constant, no matter whether + # it starts with "::" or not. No lexical context is taken into account: + # + # C = 'outside' + # module M + # C = 'inside' + # C # => 'inside' + # "C".constantize # => 'outside', same as ::C + # end + # + # NameError is raised when the name is not in CamelCase or the constant is + # unknown. + def constantize(camel_cased_word) + names = camel_cased_word.split('::') + names.shift if names.empty? || names.first.empty? + + constant = Object + names.each do |name| + constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name) + end + constant + end + else + def constantize(camel_cased_word) #:nodoc: + names = camel_cased_word.split('::') + names.shift if names.empty? || names.first.empty? + + constant = Object + names.each do |name| + constant = constant.const_defined?(name, false) ? constant.const_get(name) : constant.const_missing(name) + end + constant + end + end + + # Turns a number into an ordinal string used to denote the position in an + # ordered sequence such as 1st, 2nd, 3rd, 4th. + # + # Examples: + # ordinalize(1) # => "1st" + # ordinalize(2) # => "2nd" + # ordinalize(1002) # => "1002nd" + # ordinalize(1003) # => "1003rd" + def ordinalize(number) + if (11..13).include?(number.to_i % 100) + "#{number}th" + else + case number.to_i % 10 + when 1; "#{number}st" + when 2; "#{number}nd" + when 3; "#{number}rd" + else "#{number}th" + end + end + end + end +end diff --git a/lib/mutant/inflector/version.rb b/lib/mutant/inflector/version.rb new file mode 100644 index 00000000..bcdafaf1 --- /dev/null +++ b/lib/mutant/inflector/version.rb @@ -0,0 +1,5 @@ +module Mutant + module Inflector + VERSION = '0.0.1'.freeze + end +end