hoodie 0.4.8 → 0.4.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1f16efde92464c0832fb890b697a3007c16784d3
-  data.tar.gz: d8d2bc0a70a455136578a6591f43ef2fb9e85048
+  metadata.gz: 78f652d3c64f70002f3a3b39648d94b5552e8802
+  data.tar.gz: 8639bdbefbb53ecae2be41440b6b3e2ed741e746
 SHA512:
-  metadata.gz: 5c2659275f2f71db6e9d027dab73ad0b0c37492704af0bdad685a3bbb1b7d1930a10735ef5ba4ee5a62fe3227908bc8dd39e6a9773dbb389ce7ce39b5d29fc0f
-  data.tar.gz: 83d310871a6f4800775f9910ec2e95f6c13f5e400274fd99f7d3643ed43c974667e1c18e387c32ba986c54810d6ffdd02a5cca4725fe068297a47077703df1c0
+  metadata.gz: 7a665927fecac4819fddbf2e848f4cbd07742f3a02dcff18dd3f2a6c82ff66e550bfafa6b8cb345386925f8a903be3417c3bd7d5dd76a412a10b472afee77a45
+  data.tar.gz: d5d5c2293c27aadefceffdfde01ad1bb5e6a327150b2998fbd11965d182edb3b599303ab3f5403293183ed782490442bdb6aaae463d00b912746eb33f2bfd9bd

data/lib/hoodie/inflections/defaults.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-Inflections.inflections do |inflect|
+Hoodie::Inflections.inflections do |inflect|
   inflect.plural(/$/, 's')
   inflect.plural(/s$/i, 's')
   inflect.plural(/^(ax|test)is$/i, '\1es')

data/lib/hoodie/inflections/inflections.rb

@@ -1,161 +1,165 @@
 # encoding: UTF-8
 
-module Inflections
-  # A singleton instance of this class is yielded by Inflections.inflections,
-  # which can then be used to specify additional inflection rules. Examples:
-  #
-  #   Inflections.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
+module Hoodie
+  module Inflections
+    # A singleton instance of this class is yielded by Inflections.inflections,
+    # which can then be used to specify additional inflection rules. Examples:
     #
-    # @return [Inflections]
-    # @api private
-    def self.instance
-      @__instance__ ||= new
-    end
-
-    # @return [Array] plurals
-    # @api private
-    attr_reader :plurals
-
-    # @return [Array] singulars
-    # @api private
-    attr_reader :singulars
-
-    # @return [Array] uncountables
-    # @api private
-    attr_reader :uncountables
-
-    # @return [Array] humans
-    # @api private
-    attr_reader :humans
-
-    # Initialize object
-    #
-    # @return [undefined]
-    # @api private
-    def initialize
-      @plurals      = RulesCollection.new
-      @singulars    = RulesCollection.new
-      @humans       = RulesCollection.new
-      @uncountables = Set[]
-    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.
-    #
-    # @param [String, Regexp] rule
-    # @param [String, Regexp] replacement
-    # @return [self]
-    # @api private
-    def plural(rule, replacement)
-      rule(rule, replacement, @plurals)
-      self
-    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.
-    #
-    # @param [String, Regexp] rule
-    # @param [String, Regexp] replacement
-    # @return [self]
-    # @api private
-    def singular(rule, replacement)
-      rule(rule, replacement, @singulars)
-      self
-    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.
-    #
-    # @param [String] singular
-    # @param [String] plural
-    # @return [self]
-    # @api private
-    def irregular(singular, plural)
-      @uncountables.delete(singular)
-      @uncountables.delete(plural)
-      add_irregular(singular, plural, @plurals)
-      add_irregular(plural, singular, @singulars)
-      self
-    end
-
-    # Uncountable will not be inflected
-    #
-    # @param [Enumerable<String>] words
-    # @return [self]
-    # @api private
-    def uncountable(*words)
-      @uncountables.merge(words.flatten)
-      self
-    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')
+    #   Inflections.inflections do |inflect|
+    #     inflect.plural /^(ox)$/i, '\1\2en'
+    #     inflect.singular /^(ox)en/i, '\1'
     #
-    # @param [String, Regexp] rule
-    # @param [String, Regexp] replacement
-    # @return [self]
-    # @api private
-    def human(rule, replacement)
-      @humans.insert(0, [rule, replacement])
-      self
-    end
-
-    # Clear all inflection rules
+    #     inflect.irregular 'octopus', 'octopi'
     #
-    # @return [self]
-    # @api private
-    def clear
-      initialize
-      self
-    end
-
-    private
-
-    # Add irregular inflection
+    #     inflect.uncountable "equipment"
+    #   end
     #
-    # @param [String] rule
-    # @param [String] replacement
-    # @return [undefined]
-    # @api private
-    def add_irregular(rule, replacement, target)
-      head, *tail = rule.chars.to_a
-      rule(/(#{head})#{tail.join}\z/i, '\1' + replacement[1..-1], target)
-    end
-
-    # Add a new rule
+    # 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.
     #
-    # @param [String, Regexp] rule
-    # @param [String, Regexp] replacement
-    # @param [Array] target
-    # @return [undefined]
-    # @api private
-    def rule(rule, replacement, target)
-      @uncountables.delete(rule)
-      @uncountables.delete(replacement)
-      target.insert(0, [rule, replacement])
+    class Inflections
+
+      # Return instance
+      #
+      # @return [Inflections]
+      # @api private
+      def self.instance
+        @__instance__ ||= new
+      end
+
+      # @return [Array] plurals
+      # @api private
+      attr_reader :plurals
+
+      # @return [Array] singulars
+      # @api private
+      attr_reader :singulars
+
+      # @return [Array] uncountables
+      # @api private
+      attr_reader :uncountables
+
+      # @return [Array] humans
+      # @api private
+      attr_reader :humans
+
+      # Initialize object
+      #
+      # @return [undefined]
+      # @api private
+      def initialize
+        @plurals      = RulesCollection.new
+        @singulars    = RulesCollection.new
+        @humans       = RulesCollection.new
+        @uncountables = Set[]
+      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.
+      #
+      # @param [String, Regexp] rule
+      # @param [String, Regexp] replacement
+      # @return [self]
+      # @api private
+      def plural(rule, replacement)
+        rule(rule, replacement, @plurals)
+        self
+      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.
+      #
+      # @param [String, Regexp] rule
+      # @param [String, Regexp] replacement
+      # @return [self]
+      # @api private
+      def singular(rule, replacement)
+        rule(rule, replacement, @singulars)
+        self
+      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.
+      #
+      # @param [String] singular
+      # @param [String] plural
+      # @return [self]
+      # @api private
+      def irregular(singular, plural)
+        @uncountables.delete(singular)
+        @uncountables.delete(plural)
+        add_irregular(singular, plural, @plurals)
+        add_irregular(plural, singular, @singulars)
+        self
+      end
+
+      # Uncountable will not be inflected
+      #
+      # @param [Enumerable<String>] words
+      # @return [self]
+      # @api private
+      def uncountable(*words)
+        @uncountables.merge(words.flatten)
+        self
+      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')
+      #
+      # @param [String, Regexp] rule
+      # @param [String, Regexp] replacement
+      # @return [self]
+      # @api private
+      def human(rule, replacement)
+        @humans.insert(0, [rule, replacement])
+        self
+      end
+
+      # Clear all inflection rules
+      #
+      # @return [self]
+      # @api private
+      def clear
+        initialize
+        self
+      end
+
+      private
+
+      # Add irregular inflection
+      #
+      # @param [String] rule
+      # @param [String] replacement
+      # @return [undefined]
+      # @api private
+      def add_irregular(rule, replacement, target)
+        head, *tail = rule.chars.to_a
+        rule(/(#{head})#{tail.join}\z/i, '\1' + replacement[1..-1], target)
+      end
+
+      # Add a new rule
+      #
+      # @param [String, Regexp] rule
+      # @param [String, Regexp] replacement
+      # @param [Array] target
+      # @return [undefined]
+      # @api private
+      def rule(rule, replacement, target)
+        @uncountables.delete(rule)
+        @uncountables.delete(replacement)
+        target.insert(0, [rule, replacement])
+      end
     end
   end
 end

data/lib/hoodie/inflections/rules_collection.rb

@@ -1,18 +1,20 @@
 # encoding: UTF-8
 
-module Inflections
-  # Wraps inflections array
-  #
-  class RulesCollection < Array
-    # Applies first found rule to given word
+module Hoodie
+  module Inflections
+    # Wraps inflections array
     #
-    # @param [String] word
-    # @return [String] modified word
-    # @api private
-    def apply_to(word)
-      result = word.dup
-      each { |rule, replacement| break if result.gsub!(rule, replacement) }
-      result
+    class RulesCollection < Array
+      # Applies first found rule to given word
+      #
+      # @param [String] word
+      # @return [String] modified word
+      # @api private
+      def apply_to(word)
+        result = word.dup
+        each { |rule, replacement| break if result.gsub!(rule, replacement) }
+        result
+      end
     end
   end
 end

data/lib/hoodie/inflections.rb

@@ -1,169 +1,171 @@
 
 require 'set'
 
-# The Inflections 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.
-#
-module Inflections
-
-  # Convert input to UpperCamelCase. Will also convert '/' to '::' which is
-  # useful for converting paths to namespaces.
+module Hoodie
+  # The Inflections 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.
   #
-  # @param [String] input
-  # @return [String]
-  def self.camelize(input)
-    input.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:\A|_)(.)/) { $1.upcase }
-  end
+  module Inflections
+
+    # Convert input to UpperCamelCase. Will also convert '/' to '::' which is
+    # useful for converting paths to namespaces.
+    #
+    # @param [String] input
+    # @return [String]
+    def self.camelize(input)
+      input.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:\A|_)(.)/) { $1.upcase }
+    end
 
-  # Convert input to underscored, lowercase string. Changes '::' to '/' to
-  # convert namespaces to paths.
-  #
-  # @param [String] input
-  # @return [String]
-  def self.underscore(input)
-    word = input.gsub(/::/, '/')
-    underscorize(word)
-  end
+    # Convert input to underscored, lowercase string. Changes '::' to '/' to
+    # convert namespaces to paths.
+    #
+    # @param [String] input
+    # @return [String]
+    def self.underscore(input)
+      word = input.gsub(/::/, '/')
+      underscorize(word)
+    end
 
-  # Convert input underscores to dashes.
-  #
-  # @param [String] input
-  # @return [String]
-  def self.dasherize(input)
-    input.tr('_', '-')
-  end
+    # Convert input underscores to dashes.
+    #
+    # @param [String] input
+    # @return [String]
+    def self.dasherize(input)
+      input.tr('_', '-')
+    end
 
-  # Return unscoped constant name.
-  #
-  # @param [String] input
-  # @return [String]
-  def self.demodulize(input)
-    input.split('::').last
-  end
+    # Return unscoped constant name.
+    #
+    # @param [String] input
+    # @return [String]
+    def self.demodulize(input)
+      input.split('::').last
+    end
 
-  # Creates a foreign key name
-  #
-  # @param [String] input
-  # @return [String]
-  def self.foreign_key(input)
-    "#{underscorize(demodulize(input))}_id"
-  end
+    # Creates a foreign key name
+    #
+    # @param [String] input
+    # @return [String]
+    def self.foreign_key(input)
+      "#{underscorize(demodulize(input))}_id"
+    end
 
-  # Find a constant with the name specified in the argument string. The name is
-  # assumed to be the one of a top-level constant, constant scope of caller is
-  # igored.
-  #
-  # @param [String] input
-  # @return [Class, Module]
-  def self.constantize(input)
-    names = input.split('::')
-    names.shift if names.first.empty?
-
-    names.inject(Object) do |constant, name|
-      if constant.const_defined?(name)
-        constant.const_get(name)
-      else
-        constant.const_missing(name)
+    # Find a constant with the name specified in the argument string. The name
+    # is assumed to be the one of a top-level constant, constant scope of
+    # caller is igored.
+    #
+    # @param [String] input
+    # @return [Class, Module]
+    def self.constantize(input)
+      names = input.split('::')
+      names.shift if names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        if constant.const_defined?(name)
+          constant.const_get(name)
+        else
+          constant.const_missing(name)
+        end
       end
     end
-  end
 
-  ORDINALIZE_TH = (4..16).to_set.freeze
+    ORDINALIZE_TH = (4..16).to_set.freeze
 
-  # Convert a number into an ordinal string.
-  #
-  # @param [Fixnum] number
-  # @return [String]
-  def self.ordinalize(number)
-    abs_value = number.abs
-
-    if ORDINALIZE_TH.include?(abs_value % 100)
-      "#{number}th"
-    else
-      case abs_value % 10
-        when 1; "#{number}st"
-        when 2; "#{number}nd"
-        when 3; "#{number}rd"
+    # Convert a number into an ordinal string.
+    #
+    # @param [Fixnum] number
+    # @return [String]
+    def self.ordinalize(number)
+      abs_value = number.abs
+
+      if ORDINALIZE_TH.include?(abs_value % 100)
+        "#{number}th"
+      else
+        case abs_value % 10
+          when 1; "#{number}st"
+          when 2; "#{number}nd"
+          when 3; "#{number}rd"
+        end
       end
     end
-  end
 
-  # Convert input word string to plural
-  #
-  # @param [String] word
-  # @return [String]
-  def self.pluralize(word)
-    return word if uncountable?(word)
-    inflections.plurals.apply_to(word)
-  end
-
-  # Convert word to singular
-  #
-  # @param [String] word
-  # @return [String]
-  def self.singularize(word)
-    return word if uncountable?(word)
-    inflections.singulars.apply_to(word)
-  end
+    # Convert input word string to plural
+    #
+    # @param [String] word
+    # @return [String]
+    def self.pluralize(word)
+      return word if uncountable?(word)
+      inflections.plurals.apply_to(word)
+    end
 
-  # Humanize string.
-  #
-  # @param [String] input
-  # @return [String]
-  def self.humanize(input)
-    result = inflections.humans.apply_to(input)
-    result.gsub!(/_id\z/, "")
-    result.tr!('_', " ")
-    result.capitalize!
-    result
-  end
+    # Convert word to singular
+    #
+    # @param [String] word
+    # @return [String]
+    def self.singularize(word)
+      return word if uncountable?(word)
+      inflections.singulars.apply_to(word)
+    end
 
-  # Tabelize input string.
-  #
-  # @param [String] input
-  # @return [String]
-  def self.tableize(input)
-    pluralize(underscore(input).gsub('/', '_'))
-  end
+    # Humanize string.
+    #
+    # @param [String] input
+    # @return [String]
+    def self.humanize(input)
+      result = inflections.humans.apply_to(input)
+      result.gsub!(/_id\z/, "")
+      result.tr!('_', " ")
+      result.capitalize!
+      result
+    end
 
-  # Create a class name from a plural table name like Rails does for table
-  # names to models.
-  #
-  # @param [String] input
-  # @return [String]
-  def self.classify(table_name)
-    camelize(singularize(table_name.sub(/.*\./, '')))
-  end
+    # Tabelize input string.
+    #
+    # @param [String] input
+    # @return [String]
+    def self.tableize(input)
+      pluralize(underscore(input).gsub('/', '_'))
+    end
 
-  # Test if word is uncountable.
-  #
-  # @param [String] word
-  # @return [Boolean] true, if word is uncountable
-  def self.uncountable?(word)
-    word.empty? || inflections.uncountables.include?(word.downcase)
-  end
+    # Create a class name from a plural table name like Rails does for table
+    # names to models.
+    #
+    # @param [String] input
+    # @return [String]
+    def self.classify(table_name)
+      camelize(singularize(table_name.sub(/.*\./, '')))
+    end
 
-  # Convert input to underscored, lowercase string
-  #
-  # @param [String] input
-  # @return [String]
-  def self.underscorize(word)
-    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
-  private_class_method :underscorize
+    # Test if word is uncountable.
+    #
+    # @param [String] word
+    # @return [Boolean] true, if word is uncountable
+    def self.uncountable?(word)
+      word.empty? || inflections.uncountables.include?(word.downcase)
+    end
 
-  # Yields a singleton instance of Inflecto::Inflections.
-  #
-  # @return [Inflections::Inflections]
-  def self.inflections
-    instance = Inflections.instance
-    block_given? ? yield(instance) : instance
+    # Convert input to underscored, lowercase string
+    #
+    # @param [String] input
+    # @return [String]
+    def self.underscorize(word)
+      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
+    private_class_method :underscorize
+
+    # Yields a singleton instance of Inflecto::Inflections.
+    #
+    # @return [Inflections::Inflections]
+    def self.inflections
+      instance = Inflections.instance
+      block_given? ? yield(instance) : instance
+    end
   end
 end
 

data/lib/hoodie/version.rb

@@ -18,5 +18,5 @@
 #
 
 module Hoodie
-  VERSION = '0.4.8'
+  VERSION = '0.4.9'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hoodie
 version: !ruby/object:Gem::Version
-  version: 0.4.8
+  version: 0.4.9
 platform: ruby
 authors:
 - Stefano Harding