fusu 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 02840c743ee74ef741e4749a7911024e50d51c31
-  data.tar.gz: ac5e6df141ade292c79d4049af983b2d122882e5
+  metadata.gz: 5b0df9b35cbcd397ff4eaa1702330e0e0255f84a
+  data.tar.gz: 40b28b9e12efa5cf79f00171311c62e3616e0a37
 SHA512:
-  metadata.gz: ff735f1620feaa755d65180b8ed80be474e9d4286d208e968998599929f12fa4da68515d409ff5a6bc0ceb1af1cc4a99ab11d0d1e2f226b531ffb13b8b748378
-  data.tar.gz: 12b3e8a8cb293cb76eec71586bcc5c8e1dd0e64f4870e6f09762a7e304aea00d64f13d09fcc9c184bc501d740cdeee7c52e0c97e31255a012dceaa1b23743b51
+  metadata.gz: 028aaafaf603c46939c503d0f4b422fc4649503968d620b950e647f1b0ae4f33dce8d0dd5b7839e58d48bbc5cc6df1e79038c6b9d8478619a5ad5b4b81e34ad1
+  data.tar.gz: 28e4994d51bcdb01fd825e0382f5e4c312006a649872443a5ccb31f8ba3a5ff2bf222d86d0e53f40bf846926a644d1b35cb2558cd8f074a24c6d3eb809cec4b2

data/lib/fusu.rb

@@ -1,6 +1,12 @@
 require "fusu/version"
 require "fusu/blank"
+require "fusu/try"
 module Fusu
   extend Blank
+  extend Try
 end
 require "fusu/array"
+require "fusu/hash"
+require "fusu/string"
+require "fusu/regexp"
+require "fusu/hash_with_indifferent_access"

data/lib/fusu/concern.rb

@@ -0,0 +1,142 @@
+module Fusu
+  # A typical module looks like this:
+  #
+  #   module M
+  #     def self.included(base)
+  #       base.extend ClassMethods
+  #       base.class_eval do
+  #         scope :disabled, -> { where(disabled: true) }
+  #       end
+  #     end
+  #
+  #     module ClassMethods
+  #       ...
+  #     end
+  #   end
+  #
+  # By using <tt>Fusu::Concern</tt> the above module could instead be
+  # written as:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module M
+  #     extend Fusu::Concern
+  #
+  #     included do
+  #       scope :disabled, -> { where(disabled: true) }
+  #     end
+  #
+  #     class_methods do
+  #       ...
+  #     end
+  #   end
+  #
+  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module
+  # and a +Bar+ module which depends on the former, we would typically write the
+  # following:
+  #
+  #   module Foo
+  #     def self.included(base)
+  #       base.class_eval do
+  #         def self.method_injected_by_foo
+  #           ...
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Foo # We need to include this dependency for Bar
+  #     include Bar # Bar is the module that Host really needs
+  #   end
+  #
+  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We
+  # could try to hide these from +Host+ directly including +Foo+ in +Bar+:
+  #
+  #   module Bar
+  #     include Foo
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar
+  #   end
+  #
+  # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt>
+  # is the +Bar+ module, not the +Host+ class. With <tt>Fusu::Concern</tt>,
+  # module dependencies are properly resolved:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module Foo
+  #     extend Fusu::Concern
+  #     included do
+  #       def self.method_injected_by_foo
+  #         ...
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     extend Fusu::Concern
+  #     include Foo
+  #
+  #     included do
+  #       self.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar # It works, now Bar takes care of its dependencies
+  #   end
+  module Concern
+    class MultipleIncludedBlocks < StandardError #:nodoc:
+      def initialize
+        super "Cannot define multiple 'included' blocks for a Concern"
+      end
+    end
+
+    def self.extended(base) #:nodoc:
+      base.instance_variable_set(:@_dependencies, [])
+    end
+
+    def append_features(base)
+      if base.instance_variable_defined?(:@_dependencies)
+        base.instance_variable_get(:@_dependencies) << self
+        return false
+      else
+        return false if base < self
+        @_dependencies.each { |dep| base.send(:include, dep) }
+        super
+        base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
+        base.class_eval(&@_included_block) if instance_variable_defined?(:@_included_block)
+      end
+    end
+
+    def included(base = nil, &block)
+      if base.nil?
+        raise MultipleIncludedBlocks if instance_variable_defined?(:@_included_block)
+
+        @_included_block = block
+      else
+        super
+      end
+    end
+
+    def class_methods(&class_methods_module_definition)
+      mod = const_defined?(:ClassMethods, false) ?
+        const_get(:ClassMethods) :
+        const_set(:ClassMethods, Module.new)
+
+      mod.module_eval(&class_methods_module_definition)
+    end
+  end
+end

data/lib/fusu/hash.rb

@@ -0,0 +1,12 @@
+require 'fusu/hash/except'
+require 'fusu/hash/keys'
+require 'fusu/hash/reverse_merge'
+require 'fusu/hash/deep_merge'
+module Fusu
+  module Hash
+    extend Except
+    extend Keys
+    extend ReverseMerge
+    extend DeepMerge
+  end
+end

data/lib/fusu/hash/deep_merge.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module Fusu
+  module Hash
+    module DeepMerge
+      # Returns a new hash with +self+ and +other_hash+ merged recursively.
+      #
+      #   h1 = { a: true, b: { c: [1, 2, 3] } }
+      #   h2 = { a: false, b: { x: [3, 4, 5] } }
+      #
+      #   Fusu::Hash.deep_merge(h1, h2) # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
+      #
+      # Like with Hash#merge in the standard library, a block can be provided
+      # to merge values:
+      #
+      #   h1 = { a: 100, b: 200, c: { c1: 100 } }
+      #   h2 = { b: 250, c: { c1: 200 } }
+      #   Fusu::Hash.deep_merge(h1, h2) { |key, this_val, other_val| this_val + other_val }
+      #   # => { a: 100, b: 450, c: { c1: 300 } }
+      def deep_merge(hash, other_hash, &block)
+        deep_merge!(hash.dup, other_hash, &block)
+      end
+
+      # Same as +deep_merge+, but modifies +self+.
+      def deep_merge!(hash, other_hash, &block)
+        hash.merge!(other_hash) do |key, this_val, other_val|
+          if this_val.class <= ::Hash && other_val.class <= ::Hash
+            deep_merge(this_val, other_val, &block)
+          elsif block_given?
+            block.call(key, this_val, other_val)
+          else
+            other_val
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fusu/hash/except.rb

@@ -0,0 +1,25 @@
+module Fusu
+  module Hash
+    module Except
+      # Returns a hash that includes everything but the given keys.
+      #   hash = { a: true, b: false, c: nil}
+      #   Fusu::Hash.except(hash, :c) # => { a: true, b: false}
+      #   hash # => { a: true, b: false, c: nil}
+      #
+      # This is useful for limiting a set of parameters to everything but a few known toggles:
+      #   @person.update(Fusu::Hash.except(params[:person], :admin))
+      def except(hash, *keys)
+        except!(hash.dup, *keys)
+      end
+
+      # Replaces the hash without the given keys.
+      #   hash = { a: true, b: false, c: nil}
+      #   Fusu::Hash.except!(hash, :c) # => { a: true, b: false}
+      #   hash # => { a: true, b: false }
+      def except!(hash, *keys)
+        keys.each { |key| hash.delete(key) }
+        hash
+      end
+    end
+  end
+end

data/lib/fusu/hash/keys.rb

@@ -0,0 +1,150 @@
+module Fusu
+  module Hash
+    module Keys
+      # Returns a new hash with all keys converted using the block operation.
+      #
+      #  hash = { name: 'Rob', age: '28' }
+      #
+      #  Fusu::Hash.transform_keys(hash){ |key| key.to_s.upcase }
+      #  # => {"NAME"=>"Rob", "AGE"=>"28"}
+      def transform_keys(hash)
+        return enum_for(:transform_keys, hash) unless block_given?
+        result = ::Hash.new
+        hash.each_key do |key|
+          result[yield(key)] = hash[key]
+        end
+        result
+      end
+
+      # Destructively convert all keys using the block operations.
+      # Same as transform_keys but modifies +self+.
+      def transform_keys!(hash)
+        return enum_for(:transform_keys!, hash) unless block_given?
+        hash.keys.each do |key|
+          hash[yield(key)] = hash.delete(key)
+        end
+        hash
+      end
+
+      # Returns a new hash with all keys converted to strings.
+      #
+      #   hash = { name: 'Rob', age: '28' }
+      #
+      #   Fusu::Hash.stringify_keys(hash)
+      #   # => {"name"=>"Rob", "age"=>"28"}
+      def stringify_keys(hash)
+        transform_keys(hash){ |key| key.to_s }
+      end
+
+      # Destructively convert all keys to strings. Same as
+      # +stringify_keys+, but modifies +self+.
+      def stringify_keys!(hash)
+        transform_keys!(hash){ |key| key.to_s }
+      end
+
+      # Returns a new hash with all keys converted to symbols, as long as
+      # they respond to +to_sym+.
+      #
+      #   hash = { 'name' => 'Rob', 'age' => '28' }
+      #
+      #   Fusu::Hash.symbolize_keys(hash)
+      #   # => {:name=>"Rob", :age=>"28"}
+      def symbolize_keys(hash)
+        transform_keys(hash){ |key| key.to_sym rescue key }
+      end
+      alias_method :to_options,  :symbolize_keys
+
+      # Destructively convert all keys to symbols, as long as they respond
+      # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
+      def symbolize_keys!(hash)
+        transform_keys!(hash){ |key| key.to_sym rescue key }
+      end
+      alias_method :to_options!, :symbolize_keys!
+
+      # Returns a new hash with all keys converted by the block operation.
+      # This includes the keys from the root hash and from all
+      # nested hashes and arrays.
+      #
+      #  hash = { person: { name: 'Rob', age: '28' } }
+      #
+      #  Fusu::Hash.deep_transform_keys(hash){ |key| key.to_s.upcase }
+      #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
+      def deep_transform_keys(hash, &block)
+        _deep_transform_keys_in_object(hash, &block)
+      end
+
+      # Destructively convert all keys by using the block operation.
+      # This includes the keys from the root hash and from all
+      # nested hashes and arrays.
+      def deep_transform_keys!(hash, &block)
+        _deep_transform_keys_in_object!(hash, &block)
+      end
+
+      # Returns a new hash with all keys converted to strings.
+      # This includes the keys from the root hash and from all
+      # nested hashes and arrays.
+      #
+      #   hash = { person: { name: 'Rob', age: '28' } }
+      #
+      #   Fusu::Hash.deep_stringify_keys(hash)
+      #   # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
+      def deep_stringify_keys(hash)
+        deep_transform_keys(hash){ |key| key.to_s }
+      end
+
+      # Destructively convert all keys to strings.
+      # This includes the keys from the root hash and from all
+      # nested hashes and arrays.
+      def deep_stringify_keys!(hash)
+        deep_transform_keys!(hash){ |key| key.to_s }
+      end
+
+      # Returns a new hash with all keys converted to symbols, as long as
+      # they respond to +to_sym+. This includes the keys from the root hash
+      # and from all nested hashes and arrays.
+      #
+      #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
+      #
+      #   Fusu::Hash.deep_symbolize_keys(hash)
+      #   # => {:person=>{:name=>"Rob", :age=>"28"}}
+      def deep_symbolize_keys(hash)
+        deep_transform_keys(hash){ |key| key.to_sym rescue key }
+      end
+
+      # Destructively convert all keys to symbols, as long as they respond
+      # to +to_sym+. This includes the keys from the root hash and from all
+      # nested hashes and arrays.
+      def deep_symbolize_keys!(hash)
+        deep_transform_keys!(hash){ |key| key.to_sym rescue key }
+      end
+
+      private
+        # support methods for deep transforming nested hashes and arrays
+        def _deep_transform_keys_in_object(object, &block)
+          if object.class <= ::Hash
+            object.each_with_object({}) do |(key, value), result|
+              result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+            end
+          elsif object.class <= ::Array
+            object.map {|e| _deep_transform_keys_in_object(e, &block) }
+          else
+            object
+          end
+        end
+
+        def _deep_transform_keys_in_object!(object, &block)
+          if object.class <= ::Hash
+            object.keys.each do |key|
+              value = object.delete(key)
+              object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
+            end
+            object
+          elsif object.class <= ::Array
+            object.map! {|e| _deep_transform_keys_in_object!(e, &block)}
+          else
+            object
+          end
+        end
+    end
+  end
+end

data/lib/fusu/hash/reverse_merge.rb

@@ -0,0 +1,26 @@
+module Fusu
+  module Hash
+    module ReverseMerge
+      # Merges the caller into +other_hash+. For example,
+      #
+      #   options = Fusu::Hash.reverse_merge(options, {size: 25, velocity: 10})
+      #
+      # is equivalent to
+      #
+      #   options = { size: 25, velocity: 10 }.merge(options)
+      #
+      # This is particularly useful for initializing an options hash
+      # with default values.
+      def reverse_merge(hash, other_hash)
+        other_hash.merge(hash)
+      end
+
+      # Destructive +reverse_merge+.
+      def reverse_merge!(hash, other_hash)
+        # right wins if there is no left
+        hash.merge!( other_hash ){|key,left,right| left }
+      end
+      alias_method :reverse_update, :reverse_merge!
+    end
+  end
+end

data/lib/fusu/hash_with_indifferent_access.rb

@@ -0,0 +1,288 @@
+require 'fusu/hash/keys'
+require 'fusu/hash/reverse_merge'
+
+module Fusu
+  # Implements a hash where keys <tt>:foo</tt> and <tt>"foo"</tt> are considered
+  # to be the same.
+  #
+  #   rgb = Fusu::HashWithIndifferentAccess.new
+  #
+  #   rgb[:black] = '#000000'
+  #   rgb[:black]  # => '#000000'
+  #   rgb['black'] # => '#000000'
+  #
+  #   rgb['white'] = '#FFFFFF'
+  #   rgb[:white]  # => '#FFFFFF'
+  #   rgb['white'] # => '#FFFFFF'
+  #
+  # Internally symbols are mapped to strings when used as keys in the entire
+  # writing interface (calling <tt>[]=</tt>, <tt>merge</tt>, etc). This
+  # mapping belongs to the public interface. For example, given:
+  #
+  #   hash = Fusu::HashWithIndifferentAccess.new(a: 1)
+  #
+  # You are guaranteed that the key is returned as a string:
+  #
+  #   hash.keys # => ["a"]
+  #
+  # Technically other types of keys are accepted:
+  #
+  #   hash = Fusu::HashWithIndifferentAccess.new(a: 1)
+  #   hash[0] = 0
+  #   hash # => {"a"=>1, 0=>0}
+  #
+  # but this class is intended for use cases where strings or symbols are the
+  # expected keys and it is convenient to understand both as the same. For
+  # example the +params+ hash in Ruby on Rails.
+  #
+  # Note that core extensions define <tt>Hash#with_indifferent_access</tt>:
+  #
+  #   rgb = { black: '#000000', white: '#FFFFFF' }.with_indifferent_access
+  #
+  # which may be handy.
+  class HashWithIndifferentAccess < ::Hash
+    # Returns +true+ so that <tt>Array#extract_options!</tt> finds members of
+    # this class.
+    def extractable_options?
+      true
+    end
+
+    def with_indifferent_access
+      dup
+    end
+
+    def nested_under_indifferent_access
+      self
+    end
+
+    def initialize(constructor = {})
+
+      if constructor.respond_to?(:to_hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def default(key = nil)
+      if key.is_a?(Symbol) && include?(key = key.to_s)
+        self[key]
+      else
+        super
+      end
+    end
+
+    def self.new_from_hash_copying_default(hash)
+      hash = hash.to_hash
+      new(hash).tap do |new_hash|
+        new_hash.default = hash.default
+        new_hash.default_proc = hash.default_proc if hash.default_proc
+      end
+    end
+
+    def self.[](*args)
+      new.merge!(::Hash[*args])
+    end
+
+    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+    # Assigns a new value to the hash:
+    #
+    #   hash = Fusu::HashWithIndifferentAccess.new
+    #   hash[:key] = 'value'
+    #
+    # This value can be later fetched using either +:key+ or +'key'+.
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value, for: :assignment))
+    end
+
+    alias_method :store, :[]=
+
+    # Updates the receiver in-place, merging in the hash passed as argument:
+    #
+    #   hash_1 = Fusu::HashWithIndifferentAccess.new
+    #   hash_1[:key] = 'value'
+    #
+    #   hash_2 = Fusu::HashWithIndifferentAccess.new
+    #   hash_2[:key] = 'New Value!'
+    #
+    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+    #
+    # The argument can be either an
+    # <tt>Fusu::HashWithIndifferentAccess</tt> or a regular +Hash+.
+    # In either case the merge respects the semantics of indifferent access.
+    #
+    # If the argument is a regular hash with keys +:key+ and +"key"+ only one
+    # of the values end up in the receiver, but which one is unspecified.
+    #
+    # When given a block, the value for duplicated keys will be determined
+    # by the result of invoking the block with the duplicated key, the value
+    # in the receiver, and the value in +other_hash+. The rules for duplicated
+    # keys follow the semantics of indifferent access:
+    #
+    #   hash_1[:key] = 10
+    #   hash_2['key'] = 12
+    #   hash_1.update(hash_2) { |key, old, new| old + new } # => {"key"=>22}
+    def update(other_hash)
+      if other_hash.is_a? HashWithIndifferentAccess
+        super(other_hash)
+      else
+        other_hash.to_hash.each_pair do |key, value|
+          if block_given? && key?(key)
+            value = yield(convert_key(key), self[key], value)
+          end
+          regular_writer(convert_key(key), convert_value(value))
+        end
+        self
+      end
+    end
+
+    alias_method :merge!, :update
+
+    # Checks the hash for a key matching the argument passed in:
+    #
+    #   hash = Fusu::HashWithIndifferentAccess.new
+    #   hash['key'] = 'value'
+    #   hash.key?(:key)  # => true
+    #   hash.key?('key') # => true
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    # Same as <tt>Hash#fetch</tt> where the key passed as argument can be
+    # either a string or a symbol:
+    #
+    #   counters = Fusu::HashWithIndifferentAccess.new
+    #   counters[:foo] = 1
+    #
+    #   counters.fetch('foo')          # => 1
+    #   counters.fetch(:bar, 0)        # => 0
+    #   counters.fetch(:bar) { |key| 0 } # => 0
+    #   counters.fetch(:zoo)           # => KeyError: key not found: "zoo"
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    # Returns an array of the values at the specified indices:
+    #
+    #   hash = Fusu::HashWithIndifferentAccess.new
+    #   hash[:a] = 'x'
+    #   hash[:b] = 'y'
+    #   hash.values_at('a', 'b') # => ["x", "y"]
+    def values_at(*indices)
+      indices.collect { |key| self[convert_key(key)] }
+    end
+
+    # Returns a shallow copy of the hash.
+    #
+    #   hash = Fusu::HashWithIndifferentAccess.new({ a: { b: 'b' } })
+    #   dup  = hash.dup
+    #   dup[:a][:c] = 'c'
+    #
+    #   hash[:a][:c] # => nil
+    #   dup[:a][:c]  # => "c"
+    def dup
+      self.class.new(self).tap do |new_hash|
+        set_defaults(new_hash)
+      end
+    end
+
+    # This method has the same semantics of +update+, except it does not
+    # modify the receiver but rather returns a new hash with indifferent
+    # access with the result of the merge.
+    def merge(hash, &block)
+      self.dup.update(hash, &block)
+    end
+
+    # Like +merge+ but the other way around: Merges the receiver into the
+    # argument and returns a new hash with indifferent access as result:
+    #
+    #   hash = Fusu::HashWithIndifferentAccess.new
+    #   hash['a'] = nil
+    #   hash.reverse_merge(a: 0, b: 1) # => {"a"=>nil, "b"=>1}
+    def reverse_merge(other_hash)
+      super(self.class.new_from_hash_copying_default(other_hash))
+    end
+
+    # Same semantics as +reverse_merge+ but modifies the receiver in-place.
+    def reverse_merge!(other_hash)
+      replace(Fusu::Hash.reverse_merge(self, other_hash ))
+    end
+
+    # Replaces the contents of this hash with other_hash.
+    #
+    #   h = { "a" => 100, "b" => 200 }
+    #   h.replace({ "c" => 300, "d" => 400 }) # => {"c"=>300, "d"=>400}
+    def replace(other_hash)
+      super(self.class.new_from_hash_copying_default(other_hash))
+    end
+
+    # Removes the specified key from the hash.
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def stringify_keys!; self end
+    def deep_stringify_keys!; self end
+    def stringify_keys; dup end
+    def deep_stringify_keys; dup end
+    def symbolize_keys; Fusu::Hash.symbolize_keys!(to_hash) end
+    def deep_symbolize_keys; Fusu::Hash.deep_symbolize_keys!(to_hash) end
+    def to_options!; self end
+
+    def select(*args, &block)
+      dup.tap { |hash| hash.select!(*args, &block) }
+    end
+
+    def reject(*args, &block)
+      dup.tap { |hash| hash.reject!(*args, &block) }
+    end
+
+    # Convert to a regular hash with string keys.
+    def to_hash
+      _new_hash = ::Hash.new
+      set_defaults(_new_hash)
+
+      each do |key, value|
+        _new_hash[key] = convert_value(value, for: :to_hash)
+      end
+      _new_hash
+    end
+
+    protected
+      def convert_key(key)
+        key.kind_of?(Symbol) ? key.to_s : key
+      end
+
+      def convert_value(value, options = {})
+        if value.is_a? ::Hash
+          if options[:for] == :to_hash
+            value.to_hash
+          else
+            self.class.new(value)
+          end
+        elsif value.is_a?(::Array)
+          if options[:for] != :assignment || value.frozen?
+            value = value.dup
+          end
+          value.map! { |e| convert_value(e, options) }
+        else
+          value
+        end
+      end
+
+      def set_defaults(target)
+        if default_proc
+          target.default_proc = default_proc.dup
+        else
+          target.default = default
+        end
+      end
+  end
+end

data/lib/fusu/regexp.rb

@@ -0,0 +1,12 @@
+module Fusu
+  module Regexp #:nodoc:
+    extend self
+    # def multiline?(regexp)
+    #   regexp.options & MULTILINE == MULTILINE
+    # end
+
+    def match?(regexp, string, pos = 0)
+      !!regexp.match(string, pos)
+    end
+  end
+end

data/lib/fusu/string.rb

@@ -0,0 +1,6 @@
+require 'fusu/string/methods'
+module Fusu
+  module String
+    extend Methods
+  end
+end

data/lib/fusu/string/methods.rb

@@ -0,0 +1,348 @@
+# frozen_string_literal: true
+module Fusu
+  module String
+    module Methods
+      ACRONYM_REGEX = /(?=a)b/
+      # 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 or wish to define rules for languages other
+      # than English, please correct or add them yourself (explained below).
+
+      # Converts strings to UpperCamelCase.
+      # If the +uppercase_first_letter+ parameter is set to false, then produces
+      # lowerCamelCase.
+      #
+      # Also converts '/' to '::' which is useful for converting
+      # paths to namespaces.
+      #
+      #   camelize('active_model')                # => "ActiveModel"
+      #   camelize('active_model', false)         # => "activeModel"
+      #   camelize('active_model/errors')         # => "ActiveModel::Errors"
+      #   camelize('active_model/errors', false)  # => "activeModel::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:
+      #
+      #   camelize(underscore('SSLError'))        # => "SslError"
+      def camelize(term, uppercase_first_letter = true)
+        string = term.to_s
+        if uppercase_first_letter
+          string = string.sub(/^[a-z\d]*/) { |match| match.capitalize }
+        else
+          string = string.sub(/^(?:#{ACRONYM_REGEX}(?=\b|[A-Z_])|\w)/) { |match| match.downcase }
+        end
+        string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+        string.gsub!("/".freeze, "::".freeze)
+        string
+      end
+
+      # Makes an underscored, lowercase form from the expression in the string.
+      #
+      # Changes '::' to '/' to convert namespaces to paths.
+      #
+      #   underscore('ActiveModel')         # => "active_model"
+      #   underscore('ActiveModel::Errors') # => "active_model/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:
+      #
+      #   camelize(underscore('SSLError'))  # => "SslError"
+      def underscore(camel_cased_word)
+        return camel_cased_word unless Fusu::Regexp.match?(/[A-Z-]|::/, camel_cased_word)
+        word = camel_cased_word.to_s.gsub("::".freeze, "/".freeze)
+        word.gsub!(/(?:(?<=([A-Za-z\d]))|\b)(#{ACRONYM_REGEX})(?=\b|[^a-z])/) { "#{$1 && '_'.freeze }" }
+        word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
+        word.gsub!(/([a-z\d])([A-Z])/, '\1_\2'.freeze)
+        word.tr!("-".freeze, "_".freeze)
+        word.downcase!
+        word
+      end
+
+      # Converts just the first character to uppercase.
+      #
+      #   upcase_first('what a Lovely Day') # => "What a Lovely Day"
+      #   upcase_first('w')                 # => "W"
+      #   upcase_first('')                  # => ""
+      def upcase_first(string)
+        string.length > 0 ? string[0].upcase.concat(string[1..-1]) : ""
+      end
+
+      # Tweaks an attribute name for display to end users.
+      #
+      # Specifically, performs these transformations:
+      #
+      # * Applies human inflection rules to the argument.
+      # * Deletes leading underscores, if any.
+      # * Removes a "_id" suffix if present.
+      # * Replaces underscores with spaces, if any.
+      # * Downcases all words except acronyms.
+      # * Capitalizes the first word.
+      # The capitalization of the first word can be turned off by setting the
+      # +:capitalize+ option to false (default is true).
+      #
+      # The trailing '_id' can be kept and capitalized by setting the
+      # optional parameter +keep_id_suffix+ to true (default is false).
+      #
+      #   humanize('employee_salary')                  # => "Employee salary"
+      #   humanize('author_id')                        # => "Author"
+      #   humanize('author_id', capitalize: false)     # => "author"
+      #   humanize('_id')                              # => "Id"
+      #   humanize('author_id', keep_id_suffix: true)  # => "Author Id"
+      #
+      # If "SSL" was defined to be an acronym:
+      #
+      #   humanize('ssl_error') # => "SSL error"
+      #
+      def humanize(lower_case_and_underscored_word, capitalize: true, keep_id_suffix: false)
+        result = lower_case_and_underscored_word.to_s.dup
+
+        # inflections.humans.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
+
+        result.sub!(/\A_+/, "".freeze)
+        unless keep_id_suffix
+          result.sub!(/_id\z/, "".freeze)
+        end
+        result.tr!("_".freeze, " ".freeze)
+
+        result.gsub!(/([a-z\d]*)/i) do |match|
+          "#{match.downcase}"
+        end
+
+        if capitalize
+          result.sub!(/\A\w/) { |match| match.upcase }
+        end
+
+        result
+      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.
+      #
+      # The trailing '_id','Id'.. can be kept and capitalized by setting the
+      # optional parameter +keep_id_suffix+ to true.
+      # By default, this parameter is false.
+      #
+      # +titleize+ is also aliased as +titlecase+.
+      #
+      #   titleize('man from the boondocks')                       # => "Man From The Boondocks"
+      #   titleize('x-men: the last stand')                        # => "X Men: The Last Stand"
+      #   titleize('TheManWithoutAPast')                           # => "The Man Without A Past"
+      #   titleize('raiders_of_the_lost_ark')                      # => "Raiders Of The Lost Ark"
+      #   titleize('string_ending_with_id', keep_id_suffix: true)  # => "String Ending With Id"
+      def titleize(word, keep_id_suffix: false)
+        humanize(underscore(word), keep_id_suffix: keep_id_suffix).gsub(/\b(?<!\w['’`])[a-z]/) do |match|
+          match.capitalize
+        end
+      end
+
+      # Replaces underscores with dashes in the string.
+      #
+      #   dasherize('puni_puni') # => "puni-puni"
+      def dasherize(underscored_word)
+        underscored_word.tr("_".freeze, "-".freeze)
+      end
+
+      # Removes the module part from the expression in the string.
+      #
+      #   demodulize('ActiveSupport::Inflector::Inflections') # => "Inflections"
+      #   demodulize('Inflections')                           # => "Inflections"
+      #   demodulize('::Inflections')                         # => "Inflections"
+      #   demodulize('')                                      # => ""
+      #
+      # See also #deconstantize.
+      def demodulize(path)
+        path = path.to_s
+        if i = path.rindex("::")
+          path[(i + 2)..-1]
+        else
+          path
+        end
+      end
+
+      # Removes the rightmost segment from the constant expression in the string.
+      #
+      #   deconstantize('Net::HTTP')   # => "Net"
+      #   deconstantize('::Net::HTTP') # => "::Net"
+      #   deconstantize('String')      # => ""
+      #   deconstantize('::String')    # => ""
+      #   deconstantize('')            # => ""
+      #
+      # See also #demodulize.
+      def deconstantize(path)
+        path.to_s[0, path.rindex("::") || 0] # implementation based on the one in facets' Module#spacename
+      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'.
+      #
+      #   foreign_key('Message')        # => "message_id"
+      #   foreign_key('Message', false) # => "messageid"
+      #   foreign_key('Admin::Post')    # => "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
+
+      # Tries to find a constant with the name specified in the argument string.
+      #
+      #   constantize('Module')   # => Module
+      #   constantize('Foo::Bar') # => Foo::Bar
+      #
+      # 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'
+      #     constantize('C') # => '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("::".freeze)
+
+        # Trigger a built-in NameError exception including the ill-formed constant in the message.
+        Object.const_get(camel_cased_word) if names.empty?
+
+        # Remove the first blank element in case of '::ClassName' notation.
+        names.shift if names.size > 1 && names.first.empty?
+
+        names.inject(Object) do |constant, name|
+          if constant == Object
+            constant.const_get(name)
+          else
+            candidate = constant.const_get(name)
+            next candidate if constant.const_defined?(name, false)
+            next candidate unless Object.const_defined?(name)
+
+            # Go down the ancestors to check if it is owned directly. The check
+            # stops when we reach Object or the end of ancestors tree.
+            constant = constant.ancestors.inject(constant) do |const, ancestor|
+              break const    if ancestor == Object
+              break ancestor if ancestor.const_defined?(name, false)
+              const
+            end
+
+            # owner is in Object, so raise
+            constant.const_get(name, false)
+          end
+        end
+      end
+
+      # Tries to find a constant with the name specified in the argument string.
+      #
+      #   safe_constantize('Module')   # => Module
+      #   safe_constantize('Foo::Bar') # => Foo::Bar
+      #
+      # 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'
+      #     safe_constantize('C') # => 'outside', same as ::C
+      #   end
+      #
+      # +nil+ is returned when the name is not in CamelCase or the constant (or
+      # part of it) is unknown.
+      #
+      #   safe_constantize('blargle')                  # => nil
+      #   safe_constantize('UnknownModule')            # => nil
+      #   safe_constantize('UnknownModule::Foo::Bar')  # => nil
+      def safe_constantize(camel_cased_word)
+        constantize(camel_cased_word)
+      rescue NameError => e
+        raise if e.name && !(camel_cased_word.to_s.split("::").include?(e.name.to_s) ||
+          e.name.to_s == camel_cased_word.to_s)
+      rescue ArgumentError => e
+        raise unless /not missing constant #{const_regexp(camel_cased_word)}!$/.match?(e.message)
+      end
+
+      # Returns the suffix that should be added to a number to denote the position
+      # in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+      #
+      #   ordinal(1)     # => "st"
+      #   ordinal(2)     # => "nd"
+      #   ordinal(1002)  # => "nd"
+      #   ordinal(1003)  # => "rd"
+      #   ordinal(-11)   # => "th"
+      #   ordinal(-1021) # => "st"
+      def ordinal(number)
+        abs_number = number.to_i.abs
+
+        if (11..13).include?(abs_number % 100)
+          "th"
+        else
+          case abs_number % 10
+          when 1; "st"
+          when 2; "nd"
+          when 3; "rd"
+            else    "th"
+          end
+        end
+      end
+
+      # Turns a number into an ordinal string used to denote the position in an
+      # ordered sequence such as 1st, 2nd, 3rd, 4th.
+      #
+      #   ordinalize(1)     # => "1st"
+      #   ordinalize(2)     # => "2nd"
+      #   ordinalize(1002)  # => "1002nd"
+      #   ordinalize(1003)  # => "1003rd"
+      #   ordinalize(-11)   # => "-11th"
+      #   ordinalize(-1021) # => "-1021st"
+      def ordinalize(number)
+        "#{number}#{ordinal(number)}"
+      end
+
+      private
+
+        # Mounts a regular expression, returned as a string to ease interpolation,
+        # that will match part by part the given constant.
+        #
+        #   const_regexp("Foo::Bar::Baz") # => "Foo(::Bar(::Baz)?)?"
+        #   const_regexp("::")            # => "::"
+        def const_regexp(camel_cased_word)
+          parts = camel_cased_word.split("::".freeze)
+
+          return Regexp.escape(camel_cased_word) if parts.blank?
+
+          last = parts.pop
+
+          parts.reverse.inject(last) do |acc, part|
+            part.empty? ? acc : "#{part}(::#{acc})?"
+          end
+        end
+
+        # Applies inflection rules for +singularize+ and +pluralize+.
+        #
+        # If passed an optional +locale+ parameter, the uncountables will be
+        # found for that locale.
+        #
+        #  apply_inflections('post', inflections.plurals, :en)    # => "posts"
+        #  apply_inflections('posts', inflections.singulars, :en) # => "post"
+        # def apply_inflections(word, rules, locale = :en)
+        #   result = word.to_s.dup
+        #
+        #   if word.empty? || inflections(locale).uncountables.uncountable?(result)
+        #     result
+        #   else
+        #     rules.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
+        #     result
+        #   end
+        # end
+    end
+  end
+end

data/lib/fusu/try.rb

@@ -0,0 +1,20 @@
+module Fusu
+  module Try
+    def try(object, *a, &b)
+      return nil if object === nil
+      try!(object, *a, &b) if a.empty? || object.respond_to?(a.first)
+    end
+
+    def try!(object, *a, &b)
+      if a.empty? && block_given?
+        if b.arity == 0
+          object.instance_eval(&b)
+        else
+          yield object
+        end
+      else
+        object.public_send(*a, &b)
+      end
+    end
+  end
+end

data/lib/fusu/version.rb

@@ -1,3 +1,3 @@
 module Fusu
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fusu
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Artur Panyach
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-10-21 00:00:00.000000000 Z
+date: 2017-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -73,6 +73,17 @@ files:
 - lib/fusu.rb
 - lib/fusu/array.rb
 - lib/fusu/blank.rb
+- lib/fusu/concern.rb
+- lib/fusu/hash.rb
+- lib/fusu/hash/deep_merge.rb
+- lib/fusu/hash/except.rb
+- lib/fusu/hash/keys.rb
+- lib/fusu/hash/reverse_merge.rb
+- lib/fusu/hash_with_indifferent_access.rb
+- lib/fusu/regexp.rb
+- lib/fusu/string.rb
+- lib/fusu/string/methods.rb
+- lib/fusu/try.rb
 - lib/fusu/version.rb
 homepage: https://github.com/arturictus/fusu
 licenses: