inflecto 0.0.2

data/lib/inflecto/defaults.rb

@@ -0,0 +1,58 @@
+Inflecto.inflections do |inflect|
+  inflect.plural(/\z/, 's')
+  inflect.plural(/s\z/i, 's')
+  inflect.plural(/(ax|test)is\z/i, '\1es')
+  inflect.plural(/(octop|vir)us\z/i, '\1i')
+  inflect.plural(/(octop|vir)i\z/i, '\1i')
+  inflect.plural(/(alias|status)\z/i, '\1es')
+  inflect.plural(/(bu)s\z/i, '\1ses')
+  inflect.plural(/(buffal|tomat)o\z/i, '\1oes')
+  inflect.plural(/([ti])um\z/i, '\1a')
+  inflect.plural(/([ti])a\z/i, '\1a')
+  inflect.plural(/sis\z/i, 'ses')
+  inflect.plural(/(?:([^f])fe|([lr])f)\z/i, '\1\2ves')
+  inflect.plural(/(hive)\z/i, '\1s')
+  inflect.plural(/([^aeiouy]|qu)y\z/i, '\1ies')
+  inflect.plural(/(x|ch|ss|sh)\z/i, '\1es')
+  inflect.plural(/(matr|vert|ind)(?:ix|ex)\z/i, '\1ices')
+  inflect.plural(/([m|l])ouse\z/i, '\1ice')
+  inflect.plural(/([m|l])ice\z/i, '\1ice')
+  inflect.plural(/^(ox)\z/i, '\1en')
+  inflect.plural(/^(oxen)\z/i, '\1')
+  inflect.plural(/(quiz)\z/i, '\1zes')
+
+  inflect.singular(/s\z/i, '')
+  inflect.singular(/(n)ews\z/i, '\1ews')
+  inflect.singular(/([ti])a\z/i, '\1um')
+  inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses\z/i, '\1\2sis')
+  inflect.singular(/(^analy)ses\z/i, '\1sis')
+  inflect.singular(/([^f])ves\z/i, '\1fe')
+  inflect.singular(/(hive)s\z/i, '\1')
+  inflect.singular(/(tive)s\z/i, '\1')
+  inflect.singular(/([lr])ves\z/i, '\1f')
+  inflect.singular(/([^aeiouy]|qu)ies\z/i, '\1y')
+  inflect.singular(/(s)eries\z/i, '\1eries')
+  inflect.singular(/(m)ovies\z/i, '\1ovie')
+  inflect.singular(/(x|ch|ss|sh)es\z/i, '\1')
+  inflect.singular(/([m|l])ice\z/i, '\1ouse')
+  inflect.singular(/(bus)es\z/i, '\1')
+  inflect.singular(/(o)es\z/i, '\1')
+  inflect.singular(/(shoe)s\z/i, '\1')
+  inflect.singular(/(cris|ax|test)es\z/i, '\1is')
+  inflect.singular(/(octop|vir)i\z/i, '\1us')
+  inflect.singular(/(alias|status)es\z/i, '\1')
+  inflect.singular(/^(ox)en/i, '\1')
+  inflect.singular(/(vert|ind)ices\z/i, '\1ex')
+  inflect.singular(/(matr)ices\z/i, '\1ix')
+  inflect.singular(/(quiz)zes\z/i, '\1')
+  inflect.singular(/(database)s\z/i, '\1')
+
+  inflect.irregular('person', 'people')
+  inflect.irregular('man', 'men')
+  inflect.irregular('child', 'children')
+  inflect.irregular('sex', 'sexes')
+  inflect.irregular('move', 'moves')
+  inflect.irregular('cow', 'kine')
+
+  inflect.uncountable(%w(hovercraft moose milk rain Swiss grass equipment information rice money species series fish sheep jeans))
+end

data/lib/inflecto/inflections.rb

@@ -0,0 +1,206 @@
+module Inflecto
+  # A singleton instance of this class is yielded by Inflecto.inflections, which can then be used to specify additional
+  # inflection rules. Examples:
+  #
+  #   Inflecto.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
+
+    # Return instance
+    #
+    # @return [Inflections]
+    #
+    # @api private
+    #
+    def self.instance
+      @__instance__ ||= new
+    end
+
+    # Return plurals
+    #
+    # @return [Array]
+    #
+    # @api private
+    #
+    attr_reader :plurals
+    
+    # Return singulars
+    #
+    # @return [Array]
+    #
+    # @api private
+    #
+    attr_reader :singulars
+    
+    # Return uncountables
+    #
+    # @return [Array]
+    #
+    # @api private
+    #
+    attr_reader :uncountables
+    
+    # Return humans
+    #
+    # @return [Array]
+    #
+    # @api private
+    #
+    #
+    attr_reader :humans
+
+    # Initialize object
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize
+      @plurals, @singulars, @uncountables, @humans = [], [], [], []
+    end
+
+    # Add a new plural role
+    #
+    # 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.
+    #
+    # @param [String, Regexp] rule
+    # @param [String, Regexp] replacement
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def plural(rule, replacement)
+      @uncountables.delete(rule) if rule.is_a?(String)
+      @uncountables.delete(replacement)
+      @plurals.insert(0, [rule, replacement])
+      self
+    end
+
+    # Add a new singular rule
+    #
+    # 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.
+    #
+    # @param [String, Regexp] rule
+    # @param [String, Regexp] replacement
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def singular(rule, replacement)
+      @uncountables.delete(rule) if rule.is_a?(String)
+      @uncountables.delete(replacement)
+      @singulars.insert(0, [rule, replacement])
+      self
+    end
+
+    # Add a new irregular pluralization
+    #
+    # 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.
+    #
+    # @example
+    #
+    #   Inflecto.irregular('octopus', 'octopi')
+    #   Inflecto.irregular('person', 'people')
+    #
+    # @param [String] singular
+    # @param [String] plural
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    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
+      self
+    end
+
+    # Add uncountable words 
+    #
+    # Uncountable will not be inflected
+    #
+    # @example
+    #
+    #   Inflecto.uncountable "money"
+    #   Inflecto.uncountable "money", "information"
+    #   Inflecto.uncountable %w( money information rice )
+    #
+    # @param [Enumerable<String>] words
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def uncountable(words)
+      @uncountables.concat(words)
+      self
+    end
+
+    # Add humanize rule
+    #
+    # 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')
+    #
+    # @example
+    #   Inflecto.human(/_cnt$/i, '\1_count')
+    #   Inflecto.human("legacy_col_person_name", "Name")
+    #
+    # @param [String, Regexp] rule
+    # @param [String, Regexp] replacement
+    #
+    # @api private
+    #
+    # @return [self]
+    #
+    def human(rule, replacement)
+      @humans.insert(0, [rule, replacement])
+      self
+    end
+
+    # Clear all inflection rules
+    #
+    # @example
+    #
+    #   Inflecto.clear
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def clear
+      initialize
+      self
+    end
+
+  end
+end

data/spec/integration/inflector_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Inflecto, 'underscore' do
+  specify 'allows to create snake_case from CamelCase' do
+    Inflecto.underscore('CamelCase').should eql('camel_case')
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1,7 @@
+--exclude-only "spec/,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary
+--failure-threshold 100

data/spec/shared/command_method_behavior.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+shared_examples_for 'a command method' do
+  it 'returns self' do
+    should equal(object)
+  end
+end

data/spec/shared/each_method_behaviour.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+shared_examples_for 'an #each method' do
+  it_should_behave_like 'a command method'
+
+  context 'with no block' do
+    subject { object.each }
+
+    it { should be_instance_of(to_enum.class) }
+
+    it 'yields the expected values' do
+      subject.to_a.should eql(object.to_a)
+    end
+  end
+end

data/spec/shared/hash_method_behavior.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+shared_examples_for 'a hash method' do
+  it_should_behave_like 'an idempotent method'
+
+  specification = proc do
+    should be_instance_of(Fixnum)
+  end
+
+  it 'is a fixnum' do
+    instance_eval(&specification)
+  end
+
+  it 'memoizes the hash code' do
+    subject.should eql(object.memoized(:hash))
+  end
+end

data/spec/shared/idempotent_method_behavior.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+shared_examples_for 'an idempotent method' do
+  it 'is idempotent' do
+    should equal(instance_eval(&self.class.subject))
+  end
+end

data/spec/shared/invertible_method_behaviour.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+shared_examples_for 'an invertible method' do
+  it_should_behave_like 'an idempotent method'
+
+  it 'is invertible' do
+    subject.inverse.should equal(object)
+  end
+end

data/spec/shared/mutator_behavior.rb

@@ -0,0 +1,44 @@
+shared_examples_for 'a mutator' do
+  subject { object.each(node) { |item| yields << item } }
+
+  let(:yields)        { []              }
+  let(:object)        { described_class }
+
+  unless instance_methods.map(&:to_s).include?('node')
+    let(:node)          { source.to_ast   }
+  end
+
+  it_should_behave_like 'a command method'
+
+  context 'with no block' do
+    subject { object.each(node) }
+
+    it { should be_instance_of(to_enum.class) }
+
+    let(:expected_mutations)  do
+      mutations.map do |mutation|
+        if mutation.respond_to?(:to_ast)
+          mutation.to_ast.to_sexp
+        else
+          mutation
+        end
+      end.to_set
+    end
+
+    it 'generates the expected mutations' do
+      subject = self.subject.map(&:to_sexp).to_set
+
+      unless subject == expected_mutations
+        message = "Missing mutations: %s\nUnexpected mutations: %s" %
+         [expected_mutations - subject, subject - expected_mutations ].map(&:to_a).map(&:inspect)
+        fail message
+      end
+    end
+  end
+end
+
+shared_examples_for 'a noop mutator' do
+  let(:mutations) { [] }
+
+  it_should_behave_like 'a mutator'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require 'rspec'
+require 'inflecto'
+
+# require spec support files and shared behavior
+Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each { |f| require(f) }
+
+RSpec.configure do |config|
+end

data/spec/unit/inflector/class_methods/camelize_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Inflecto do
+  describe '.camelize' do
+    it 'camelizes data_mapper as DataMapper' do
+      Inflecto.camelize('data_mapper').should == 'DataMapper'
+    end
+
+    it 'camelizes merb as Merb' do
+      Inflecto.camelize('merb').should == 'Merb'
+    end
+
+    it 'camelizes data_mapper/resource as DataMapper::Resource' do
+      Inflecto.camelize('data_mapper/resource').should == 'DataMapper::Resource'
+    end
+
+    it 'camelizes data_mapper/associations/one_to_many as DataMapper::Associations::OneToMany' do
+      Inflecto.camelize('data_mapper/associations/one_to_many').should == 'DataMapper::Associations::OneToMany'
+    end
+  end
+end

data/spec/unit/inflector/class_methods/classify_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Inflecto, '.classify' do
+  it 'classifies data_mapper as DataMapper' do
+    Inflecto.classify('data_mapper').should == 'DataMapper'
+  end
+
+  it 'classifies enlarged_testes as EnlargedTestis' do
+    Inflecto.classify('enlarged_testes').should == 'EnlargedTestis'
+  end
+
+  it 'singularizes string first: classifies data_mappers as egg_and_hams as EggAndHam' do
+    Inflecto.classify('egg_and_hams').should == 'EggAndHam'
+  end
+end

data/spec/unit/inflector/class_methods/demodulize_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Inflecto do
+  describe '.demodulize' do
+    it 'demodulizes module name: DataMapper::Inflecto => Inflecto' do
+      Inflecto.demodulize('DataMapper::Inflecto').should == 'Inflecto'
+    end
+
+    it 'demodulizes module name: A::B::C::D::E => E' do
+      Inflecto.demodulize('A::B::C::D::E').should == 'E'
+    end
+  end
+end