hanami-utils 0.0.0 → 0.7.0

data/lib/hanami/utils/hash.rb

@@ -0,0 +1,299 @@
+require 'hanami/utils/duplicable'
+
+module Hanami
+  module Utils
+    # Hash on steroids
+    # @since 0.1.0
+    class Hash
+      # @since 0.6.0
+      # @api private
+      #
+      # @see Hanami::Utils::Hash#deep_dup
+      # @see Hanami::Utils::Duplicable
+      DUPLICATE_LOGIC = Proc.new do |value|
+        case value
+        when Hash
+          value.deep_dup
+        when ::Hash
+          Hash.new(value).deep_dup.to_h
+        end
+      end.freeze
+
+      # Initialize the hash
+      #
+      # @param hash [#to_h] the value we want to use to initialize this instance
+      # @param blk [Proc] define the default value
+      #
+      # @return [Hanami::Utils::Hash] self
+      #
+      # @since 0.1.0
+      #
+      # @see http://www.ruby-doc.org/core/Hash.html#method-c-5B-5D
+      #
+      # @example Passing a Hash
+      #   require 'hanami/utils/hash'
+      #
+      #   hash = Hanami::Utils::Hash.new('l' => 23)
+      #   hash['l'] # => 23
+      #
+      # @example Passing a block for default
+      #   require 'hanami/utils/hash'
+      #
+      #   hash = Hanami::Utils::Hash.new {|h,k| h[k] = [] }
+      #   hash['foo'].push 'bar'
+      #
+      #   hash.to_h # => { 'foo' => ['bar'] }
+      def initialize(hash = {}, &blk)
+        @hash = hash.to_h
+        @hash.default_proc = blk
+      end
+
+      # Convert in-place all the keys to Symbol instances, nested hashes are converted too.
+      #
+      # @return [Hash] self
+      #
+      # @since 0.1.0
+      #
+      # @example
+      #   require 'hanami/utils/hash'
+      #
+      #   hash = Hanami::Utils::Hash.new 'a' => 23, 'b' => { 'c' => ['x','y','z'] }
+      #   hash.symbolize!
+      #
+      #   hash.keys    # => [:a, :b]
+      #   hash.inspect # => {:a=>23, :b=>{:c=>["x", "y", "z"]}}
+      def symbolize!
+        keys.each do |k|
+          v = delete(k)
+          v = Hash.new(v).symbolize! if v.is_a?(::Hash)
+
+          self[k.to_sym] = v
+        end
+
+        self
+      end
+
+      # Convert in-place all the keys to Symbol instances, nested hashes are converted too.
+      #
+      # @return [Hash] self
+      #
+      # @since 0.3.2
+      #
+      # @example
+      #   require 'hanami/utils/hash'
+      #
+      #   hash = Hanami::Utils::Hash.new a: 23, b: { c: ['x','y','z'] }
+      #   hash.stringify!
+      #
+      #   hash.keys    # => [:a, :b]
+      #   hash.inspect # => {"a"=>23, "b"=>{"c"=>["x", "y", "z"]}}
+      def stringify!
+        keys.each do |k|
+          v = delete(k)
+          v = Hash.new(v).stringify! if v.is_a?(::Hash)
+
+          self[k.to_s] = v
+        end
+
+        self
+      end
+
+      # Return a deep copy of the current Hanami::Utils::Hash
+      #
+      # @return [Hash] a deep duplicated self
+      #
+      # @since 0.3.1
+      #
+      # @example
+      #   require 'hanami/utils/hash'
+      #
+      #   hash = Hanami::Utils::Hash.new(
+      #     'nil'        => nil,
+      #     'false'      => false,
+      #     'true'       => true,
+      #     'symbol'     => :foo,
+      #     'fixnum'     => 23,
+      #     'bignum'     => 13289301283 ** 2,
+      #     'float'      => 1.0,
+      #     'complex'    => Complex(0.3),
+      #     'bigdecimal' => BigDecimal.new('12.0001'),
+      #     'rational'   => Rational(0.3),
+      #     'string'     => 'foo bar',
+      #     'hash'       => { a: 1, b: 'two', c: :three },
+      #     'u_hash'     => Hanami::Utils::Hash.new({ a: 1, b: 'two', c: :three })
+      #   )
+      #
+      #   duped = hash.deep_dup
+      #
+      #   hash.class  # => Hanami::Utils::Hash
+      #   duped.class # => Hanami::Utils::Hash
+      #
+      #   hash.object_id  # => 70147385937100
+      #   duped.object_id # => 70147385950620
+      #
+      #   # unduplicated values
+      #   duped['nil']        # => nil
+      #   duped['false']      # => false
+      #   duped['true']       # => true
+      #   duped['symbol']     # => :foo
+      #   duped['fixnum']     # => 23
+      #   duped['bignum']     # => 176605528590345446089
+      #   duped['float']      # => 1.0
+      #   duped['complex']    # => (0.3+0i)
+      #   duped['bigdecimal'] # => #<BigDecimal:7f9ffe6e2fd0,'0.120001E2',18(18)>
+      #   duped['rational']   # => 5404319552844595/18014398509481984)
+      #
+      #   # it duplicates values
+      #   duped['string'].reverse!
+      #   duped['string'] # => "rab oof"
+      #   hash['string']  # => "foo bar"
+      #
+      #   # it deeply duplicates Hash, by preserving the class
+      #   duped['hash'].class # => Hash
+      #   duped['hash'].delete(:a)
+      #   hash['hash'][:a]    # => 1
+      #
+      #   duped['hash'][:b].upcase!
+      #   duped['hash'][:b] # => "TWO"
+      #   hash['hash'][:b]  # => "two"
+      #
+      #   # it deeply duplicates Hanami::Utils::Hash, by preserving the class
+      #   duped['u_hash'].class # => Hanami::Utils::Hash
+      def deep_dup
+        Hash.new.tap do |result|
+          @hash.each {|k, v| result[k] = Duplicable.dup(v, &DUPLICATE_LOGIC) }
+        end
+      end
+
+      # Returns a new array populated with the keys from this hash
+      #
+      # @return [Array] the keys
+      #
+      # @since 0.3.0
+      #
+      # @see http://www.ruby-doc.org/core/Hash.html#method-i-keys
+      def keys
+        @hash.keys
+      end
+
+      # Deletes the key-value pair and returns the value from hsh whose key is
+      # equal to key.
+      #
+      # @param key [Object] the key to remove
+      #
+      # @return [Object,nil] the value hold by the given key, if present
+      #
+      # @since 0.3.0
+      #
+      # @see http://www.ruby-doc.org/core/Hash.html#method-i-keys
+      def delete(key)
+        @hash.delete(key)
+      end
+
+      # Retrieves the value object corresponding to the key object.
+      #
+      # @param key [Object] the key
+      #
+      # @return [Object,nil] the correspoding value, if present
+      #
+      # @since 0.3.0
+      #
+      # @see http://www.ruby-doc.org/core/Hash.html#method-i-5B-5D
+      def [](key)
+        @hash[key]
+      end
+
+      # Associates the value given by value with the key given by key.
+      #
+      # @param key [Object] the key to assign
+      # @param value [Object] the value to assign
+      #
+      # @since 0.3.0
+      #
+      # @see http://www.ruby-doc.org/core/Hash.html#method-i-5B-5D-3D
+      def []=(key, value)
+        @hash[key] = value
+      end
+
+      # Returns a Ruby Hash as duplicated version of self
+      #
+      # @return [::Hash] the hash
+      #
+      # @since 0.3.0
+      #
+      # @see http://www.ruby-doc.org/core/Hash.html#method-i-to_h
+      def to_h
+        @hash.each_with_object({}) do |(k, v), result|
+          v = v.to_h if v.is_a?(self.class)
+          result[k] = v
+        end
+      end
+
+      alias_method :to_hash, :to_h
+
+      # Converts into a nested array of [ key, value ] arrays.
+      #
+      # @return [::Array] the array
+      #
+      # @since 0.3.0
+      #
+      # @see http://www.ruby-doc.org/core/Hash.html#method-i-to_a
+      def to_a
+        @hash.to_a
+      end
+
+      # Equality
+      #
+      # @return [TrueClass,FalseClass]
+      #
+      # @since 0.3.0
+      def ==(other)
+        @hash == other.to_h
+      end
+
+      alias_method :eql?, :==
+
+      # Returns the hash of the internal @hash
+      #
+      # @return [Fixnum]
+      #
+      # @since 0.3.0
+      def hash
+        @hash.hash
+      end
+
+      # Returns a string describing the internal @hash
+      #
+      # @return [String]
+      #
+      # @since 0.3.0
+      def inspect
+        @hash.inspect
+      end
+
+      # Override Ruby's method_missing in order to provide ::Hash interface
+      #
+      # @api private
+      # @since 0.3.0
+      #
+      # @raise [NoMethodError] If doesn't respond to the given method
+      def method_missing(m, *args, &blk)
+        if respond_to?(m)
+          h = @hash.__send__(m, *args, &blk)
+          h = self.class.new(h) if h.is_a?(::Hash)
+          h
+        else
+          raise NoMethodError.new(%(undefined method `#{ m }' for #{ @hash }:#{ self.class }))
+        end
+      end
+
+      # Override Ruby's respond_to_missing? in order to support ::Hash interface
+      #
+      # @api private
+      # @since 0.3.0
+      def respond_to_missing?(m, include_private=false)
+        @hash.respond_to?(m, include_private)
+      end
+    end
+  end
+end

data/lib/hanami/utils/inflector.rb

@@ -0,0 +1,439 @@
+require 'hanami/utils/class_attribute'
+
+module Hanami
+  module Utils
+    # String inflector
+    #
+    # @since 0.4.1
+    module Inflector
+      # Rules for irregular plurals
+      #
+      # @since 0.6.0
+      # @api private
+      class IrregularRules
+        # @since 0.6.0
+        # @api private
+        def initialize(rules)
+          @rules = rules
+        end
+
+        # @since 0.6.0
+        # @api private
+        def add(key, value)
+          @rules[key.downcase] = value.downcase
+        end
+
+        # @since 0.6.0
+        # @api private
+        def ===(other)
+          key = other.downcase
+          @rules.key?(key) || @rules.value?(key)
+        end
+
+        # @since 0.6.0
+        # @api private
+        def apply(string)
+          key    = string.downcase
+          result = @rules[key] || @rules.rassoc(key).last
+
+          string[0] + result[1..-1]
+        end
+      end
+
+      # Matcher for blank strings
+      #
+      # @since 0.4.1
+      # @api private
+      BLANK_STRING_MATCHER = /\A[[:space:]]*\z/.freeze
+
+      # @since 0.4.1
+      # @api private
+      A    = 'a'.freeze
+
+      # @since 0.4.1
+      # @api private
+      CH   = 'ch'.freeze
+
+      # @since 0.4.1
+      # @api private
+      CHES = 'ches'.freeze
+
+      # @since 0.4.1
+      # @api private
+      EAUX = 'eaux'.freeze
+
+      # @since 0.6.0
+      # @api private
+      ES   = 'es'.freeze
+
+      # @since 0.4.1
+      # @api private
+      F    = 'f'.freeze
+
+      # @since 0.4.1
+      # @api private
+      I    = 'i'.freeze
+
+      # @since 0.4.1
+      # @api private
+      ICE  = 'ice'.freeze
+
+      # @since 0.4.1
+      # @api private
+      ICES = 'ices'.freeze
+
+      # @since 0.4.1
+      # @api private
+      IDES = 'ides'.freeze
+
+      # @since 0.4.1
+      # @api private
+      IES  = 'ies'.freeze
+
+      # @since 0.4.1
+      # @api private
+      IFE  = 'ife'.freeze
+
+      # @since 0.4.1
+      # @api private
+      INA  = 'ina'.freeze
+
+      # @since 0.4.1
+      # @api private
+      IS   = 'is'.freeze
+
+      # @since 0.4.1
+      # @api private
+      IVES = 'ives'.freeze
+
+      # @since 0.4.1
+      # @api private
+      MA   = 'ma'.freeze
+
+      # @since 0.4.1
+      # @api private
+      MATA = 'mata'.freeze
+
+      # @since 0.4.1
+      # @api private
+      MEN  = 'men'.freeze
+
+      # @since 0.4.1
+      # @api private
+      MINA = 'mina'.freeze
+
+      # @since 0.6.0
+      # @api private
+      NA   = 'na'.freeze
+
+      # @since 0.6.0
+      # @api private
+      NON  = 'non'.freeze
+
+      # @since 0.4.1
+      # @api private
+      O    = 'o'.freeze
+
+      # @since 0.4.1
+      # @api private
+      OES  = 'oes'.freeze
+
+      # @since 0.4.1
+      # @api private
+      OUSE = 'ouse'.freeze
+
+      # @since 0.4.1
+      # @api private
+      S    = 's'.freeze
+
+      # @since 0.4.1
+      # @api private
+      SES  = 'ses'.freeze
+
+      # @since 0.4.1
+      # @api private
+      SSES = 'sses'.freeze
+
+      # @since 0.6.0
+      # @api private
+      TA   = 'ta'.freeze
+
+      # @since 0.4.1
+      # @api private
+      UM   = 'um'.freeze
+
+      # @since 0.4.1
+      # @api private
+      US   = 'us'.freeze
+
+      # @since 0.4.1
+      # @api private
+      USES = 'uses'.freeze
+
+      # @since 0.4.1
+      # @api private
+      VES  = 'ves'.freeze
+
+      # @since 0.4.1
+      # @api private
+      X    = 'x'.freeze
+
+      # @since 0.4.1
+      # @api private
+      XES  = 'xes'.freeze
+
+      # @since 0.4.1
+      # @api private
+      Y    = 'y'.freeze
+
+      include Utils::ClassAttribute
+
+      # Irregular rules for plurals
+      #
+      # @since 0.6.0
+      # @api private
+      class_attribute :plurals
+      self.plurals = IrregularRules.new({
+        # irregular
+        'cactus'       => 'cacti',
+        'child'        => 'children',
+        'corpus'       => 'corpora',
+        'foot'         => 'feet',
+        'genus'        => 'genera',
+        'goose'        => 'geese',
+        'man'          => 'men',
+        'ox'           => 'oxen',
+        'person'       => 'people',
+        'quiz'         => 'quizzes',
+        'sex'          => 'sexes',
+        'testis'       => 'testes',
+        'tooth'        => 'teeth',
+        'woman'        => 'women',
+        # uncountable
+        'deer'         => 'deer',
+        'equipment'    => 'equipment',
+        'fish'         => 'fish',
+        'information'  => 'information',
+        'means'        => 'means',
+        'money'        => 'money',
+        'news'         => 'news',
+        'offspring'    => 'offspring',
+        'rice'         => 'rice',
+        'series'       => 'series',
+        'sheep'        => 'sheep',
+        'species'      => 'species',
+      })
+
+      # Irregular rules for singulars
+      #
+      # @since 0.6.0
+      # @api private
+      class_attribute :singulars
+      self.singulars = IrregularRules.new({
+        # irregular
+        'cacti'   => 'cactus',
+        'children'=> 'child',
+        'corpora' => 'corpus',
+        'feet'    => 'foot',
+        'genera'  => 'genus',
+        'geese'   => 'goose',
+        'men'     => 'man',
+        'oxen'    => 'ox',
+        'people'  => 'person',
+        'quizzes' => 'quiz',
+        'sexes'   => 'sex',
+        'testes'  => 'testis',
+        'teeth'   => 'tooth',
+        'women'   => 'woman',
+        # uncountable
+        'deer'        => 'deer',
+        'equipment'   => 'equipment',
+        'fish'        => 'fish',
+        'information' => 'information',
+        'means'       => 'means',
+        'money'       => 'money',
+        'news'        => 'news',
+        'offspring'   => 'offspring',
+        'rice'        => 'rice',
+        'series'      => 'series',
+        'sheep'       => 'sheep',
+        'species'     => 'species',
+        'police'      => 'police',
+        # fallback
+        'hives'       => 'hive',
+        'horses'      => 'horse',
+      })
+
+      # Block for custom inflection rules.
+      #
+      # @param [Proc] blk custom inflections
+      #
+      # @since 0.6.0
+      #
+      # @see Hanami::Utils::Inflector.exception
+      # @see Hanami::Utils::Inflector.uncountable
+      #
+      # @example
+      #   require 'hanami/utils/inflector'
+      #
+      #   Hanami::Utils::Inflector.inflections do
+      #     exception   'analysis', 'analyses'
+      #     exception   'alga',     'algae'
+      #     uncountable 'music', 'butter'
+      #   end
+      def self.inflections(&blk)
+        class_eval(&blk)
+      end
+
+      # Add a custom inflection exception
+      #
+      # @param [String] singular form
+      # @param [String] plural form
+      #
+      # @since 0.6.0
+      #
+      # @see Hanami::Utils::Inflector.inflections
+      # @see Hanami::Utils::Inflector.uncountable
+      #
+      # @example
+      #   require 'hanami/utils/inflector'
+      #
+      #   Hanami::Utils::Inflector.inflections do
+      #     exception 'alga', 'algae'
+      #   end
+      def self.exception(singular, plural)
+        singulars.add(plural, singular)
+        plurals.add(singular, plural)
+      end
+
+      # Add an uncountable word
+      #
+      # @param [Array<String>] words
+      #
+      # @since 0.6.0
+      #
+      # @see Hanami::Utils::Inflector.inflections
+      # @see Hanami::Utils::Inflector.exception
+      #
+      # @example
+      #   require 'hanami/utils/inflector'
+      #
+      #   Hanami::Utils::Inflector.inflections do
+      #     uncountable 'music', 'art'
+      #   end
+      def self.uncountable(*words)
+        Array(words).each do |word|
+          exception(word, word)
+        end
+      end
+
+      # Pluralize the given string
+      #
+      # @param string [String] a string to pluralize
+      #
+      # @return [String,NilClass] the pluralized string, if present
+      #
+      # @api private
+      # @since 0.4.1
+      def self.pluralize(string)
+        return string if string.nil? || string.match(BLANK_STRING_MATCHER)
+
+        case string
+        when plurals
+          plurals.apply(string)
+        when /\A((.*)[^aeiou])ch\z/
+          $1 + CHES
+        when /\A((.*)[^aeiou])y\z/
+          $1 + IES
+        when /\A(.*)(ex|ix)\z/
+          $1 + ICES
+        when /\A(.*)(eau|#{ EAUX })\z/
+          $1 + EAUX
+        when /\A(.*)x\z/
+          $1 + XES
+        when /\A(.*)ma\z/
+          string + TA
+        when /\A(.*)(um|#{ A })\z/
+          $1 + A
+        when /\A(.*)(ouse|#{ ICE })\z/
+          $1 + ICE
+        when /\A(buffal|domin|ech|embarg|her|mosquit|potat|tomat)#{ O }\z/i
+          $1 + OES
+        when /\A(.*)(en|#{ INA })\z/
+          $1 + INA
+        when /\A(.*)(?:([^f]))f[e]*\z/
+          $1 + $2 + VES
+        when /\A(.*)us\z/
+          $1 + USES
+        when /\A(.*)non\z/
+          $1 + NA
+        when /\A((.*)[^aeiou])is\z/
+          $1 + ES
+        when /\A(.*)ss\z/
+          $1 + SSES
+        when /s\z/
+          string
+        else
+          string + S
+        end
+      end
+
+      # Singularize the given string
+      #
+      # @param string [String] a string to singularize
+      #
+      # @return [String,NilClass] the singularized string, if present
+      #
+      # @api private
+      # @since 0.4.1
+      def self.singularize(string)
+        return string if string.nil? || string.match(BLANK_STRING_MATCHER)
+
+        case string
+        when singulars
+          singulars.apply(string)
+        when /\A.*[^aeiou]#{CHES}\z/
+          string.sub(CHES, CH)
+        when /\A.*[^aeiou]#{IES}\z/
+          string.sub(IES, Y)
+        when /\A(.*)#{ICE}\z/
+          $1 + OUSE
+        when /\A.*#{EAUX}\z/
+          string.chop
+        when /\A(.*)#{IDES}\z/
+          $1 + IS
+        when /\A(.*)#{US}\z/
+          $1 + I
+        when /\A(.*)#{SES}\z/
+          $1 + S
+        when /\A(.*)#{OUSE}\z/
+          $1 + ICE
+        when /\A(.*)#{MATA}\z/
+          $1 + MA
+        when /\A(.*)#{OES}\z/
+          $1 + O
+        when /\A(.*)#{MINA}\z/
+          $1 + MEN
+        when /\A(.*)#{XES}\z/
+          $1 + X
+        when /\A(.*)#{IVES}\z/
+          $1 + IFE
+        when /\A(.*)#{VES}\z/
+          $1 + F
+        when /\A(.*)#{I}\z/
+          $1 + US
+        when /\A(.*)ae\z/
+          $1 + A
+        when /\A(.*)na\z/
+          $1 + NON
+        when /\A(.*)#{A}\z/
+          $1 + UM
+        when /[^s]\z/
+          string
+        else
+          string.chop
+        end
+      end
+    end
+  end
+end