gorillib 0.1.11 → 0.4.0pre

data/lib/gorillib/hash/indifferent_access.rb

@@ -1,207 +0,0 @@
-require 'gorillib/hash/keys'
-
-# This class has dubious semantics and we only have it so that
-# people can write <tt>params[:key]</tt> instead of <tt>params['key']</tt>
-# and they get the same value for both keys.
-
-module Gorillib
-  class HashWithIndifferentAccess < Hash
-    def extractable_options?
-      true
-    end
-
-    def with_indifferent_access
-      dup
-    end
-
-    def initialize(constructor = {})
-      if constructor.is_a?(Hash)
-        super()
-        update(constructor)
-      else
-        super(constructor)
-      end
-    end
-
-    def default(key = nil)
-      if include?(converted = convert_key(key))
-        self[converted]
-      else
-        super
-      end
-    end
-
-    def self.new_from_hash_copying_default(hash)
-      new(hash).tap do |new_hash|
-        new_hash.default = hash.default
-      end
-    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 = HashWithIndifferentAccess.new
-    #   hash[:key] = "value"
-    #
-    def []=(key, value)
-      regular_writer(convert_key(key), convert_value(value))
-    end
-
-    alias_method :store, :[]=
-
-    # Updates the instantized hash with values from the second:
-    #
-    #   hash_1 = HashWithIndifferentAccess.new
-    #   hash_1[:key] = "value"
-    #
-    #   hash_2 = HashWithIndifferentAccess.new
-    #   hash_2[:key] = "New Value!"
-    #
-    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
-    #
-    def update(other_hash)
-      raise TypeError, "can't convert #{other_hash.nil? ? 'nil' : other_hash.class} into Hash" unless other_hash.respond_to?(:each_pair)
-      if other_hash.is_a? HashWithIndifferentAccess
-        super(other_hash)
-      else
-        other_hash.each_pair{|key, value| regular_writer(convert_key(key), convert_value(value)) }
-        self
-      end
-    end
-
-    alias_method :merge!, :update
-
-    # Checks the hash for a key matching the argument passed in:
-    #
-    #   hash = 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?
-
-    # Fetches the value for the specified key, same as doing hash[key]
-    def fetch(key, *extras)
-      super(convert_key(key), *extras)
-    end
-
-    # Returns an array of the values at the specified indices:
-    #
-    #   hash = 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 an exact copy of the hash.
-    def dup
-      self.class.new(self).tap do |new_hash|
-        new_hash.default = default
-      end
-    end
-
-    # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
-    # Does not overwrite the existing hash.
-    def merge(hash)
-      self.dup.update(hash)
-    end
-
-    # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
-    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a <tt>HashWithDifferentAccess</tt>.
-    def reverse_merge(other_hash)
-      super self.class.new_from_hash_copying_default(other_hash)
-    end
-
-    def reverse_merge!(other_hash)
-      replace(reverse_merge( other_hash ))
-    end
-
-    # Removes a specified key from the hash.
-    def delete(key)
-      super(convert_key(key))
-    end
-
-    def stringify_keys!; self end
-    def stringify_keys; dup end
-    undef_method :symbolize_keys! if method_defined?(:symbolize_keys!)
-    def symbolize_keys; to_hash.symbolize_keys end
-    def to_options!; self end
-
-    # Convert to a Hash with String keys.
-    def to_hash
-      Hash.new(default).merge!(self)
-    end
-
-    def assoc key
-      key = convert_key(key)
-      return unless has_key?(key)
-      [key, self[key]]
-    end
-
-    def rassoc val
-      key = key(val) or return
-      [key, self[key]]
-    end
-
-  protected
-    def convert_key(key)
-      key.kind_of?(Symbol) ? key.to_s : key
-    end
-
-    def convert_value(value)
-      if value.is_a? Hash
-        value.nested_under_indifferent_access
-      elsif value.is_a?(Array)
-        value.dup.replace(value.map{|e| convert_value(e) })
-      else
-        value
-      end
-    end
-  end
-
-end
-
-module Gorillib
-  class HashWithIndifferentSymbolKeys < Gorillib::HashWithIndifferentAccess
-
-    def convert_key key
-      return key if key.is_a?(Fixnum)
-      key.respond_to?(:to_sym) ? key.to_sym : key
-    end
-  end
-end
-
-class Hash
-
-  # Returns an +ActiveSupport::HashWithIndifferentAccess+ out of its receiver:
-  #
-  #   {:a => 1}.with_indifferent_access["a"] # => 1
-  #
-  def with_indifferent_access
-    Gorillib::HashWithIndifferentAccess.new_from_hash_copying_default(self)
-  end
-
-  # Called when object is nested under an object that receives
-  # #with_indifferent_access. This method with be called on the current object
-  # by the enclosing object and is aliased to #with_indifferent_access by
-  # default. Subclasses of Hash may overwrite this method to return +self+ if
-  # converting to an +ActiveSupport::HashWithIndifferentAccess+ would not be
-  # desirable.
-  #
-  #   b = {:b => 1}
-  #   {:a => b}.with_indifferent_access["a"] # calls b.nested_under_indifferent_access
-  #
-  alias nested_under_indifferent_access with_indifferent_access
-end
-

data/lib/gorillib/hash/tree_merge.rb

@@ -1,4 +0,0 @@
-require 'gorillib/hashlike/tree_merge'
-class Hash
-  include Gorillib::Hashlike::TreeMerge
-end

data/lib/gorillib/hashlike/tree_merge.rb

@@ -1,49 +0,0 @@
-module Gorillib
-  module Hashlike
-    module TreeMerge
-
-      # Recursively merges hashlike objects
-      #
-      # For each key in keys,
-      # * if block_given? and yield(key,self_val,other_val) returns non-nil, set that
-      # * if self is missing value for key, receive the attribute.
-      # * if self's attribute is an Array, append to it.
-      # * if self's value responds to tree_merge!, deep merge it.
-      # * if self's value responds_to merge!, merge! it.
-      # * otherwise, receive the value from other_hash
-      #
-      def tree_merge!(other_hash)
-        return self if other_hash.blank?
-        [self.keys, other_hash.keys].flatten.uniq.each do |key|
-          # get other's val if any
-          if    other_hash.has_key?(key.to_sym) then other_val = other_hash[key.to_sym]
-          elsif other_hash.has_key?(key.to_s)   then other_val = other_hash[key.to_s]
-          else  next ; end
-          # get self val if any
-          self_val  = self[key]
-          # get block resolved result if any
-          if block_given? && yield(key, self_val, other_val)
-            next
-          end
-          # p ['hash tree_merge', key, self_val.respond_to?(:tree_merge!), self_val, '***************', other_val]
-          #
-          case
-          when other_val.nil?                     then next
-          when (not has_key?(key))                then self[key] = other_val
-          when self_val.is_a?(Array)              then self[key] += other_val
-          when self_val.respond_to?(:tree_merge!) then self[key] = self_val.tree_merge!(other_val)
-          when self_val.respond_to?(:merge!)      then self[key] = self_val.merge!(other_val)
-          else                                         self[key] = other_val
-          end
-        end
-        self
-      end
-
-    end
-  end
-end
-
-
-class Hash
-  include Gorillib::Hashlike::TreeMerge
-end

data/lib/gorillib/metaprogramming/cattr_accessor.rb

@@ -1,79 +0,0 @@
-require 'gorillib/array/extract_options'
-
-# Extends the class object with class and instance accessors for class attributes,
-# just like the native attr* accessors for instance attributes.
-#
-# Note that unlike +class_attribute+, if a subclass changes the value then that would
-# also change the value for parent class. Similarly if parent class changes the value
-# then that would change the value of subclasses too.
-#
-#  class Person
-#    cattr_accessor :hair_colors
-#  end
-#
-#  Person.hair_colors = [:brown, :black, :blonde, :red]
-#  Person.hair_colors     # => [:brown, :black, :blonde, :red]
-#  Person.new.hair_colors # => [:brown, :black, :blonde, :red]
-#
-# To opt out of the instance writer method, pass :instance_writer => false.
-# To opt out of the instance reader method, pass :instance_reader => false.
-#
-#   class Person
-#     cattr_accessor :hair_colors, :instance_writer => false, :instance_reader => false
-#   end
-#
-#   Person.new.hair_colors = [:brown]  # => NoMethodError
-#   Person.new.hair_colors             # => NoMethodError
-class Class
-  def cattr_reader(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
-        def self.#{sym}
-          @@#{sym}
-        end
-      EOS
-
-      unless options[:instance_reader] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}
-            @@#{sym}
-          end
-        EOS
-      end
-    end
-  end unless method_defined?(:cattr_reader)
-
-  def cattr_writer(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
-        def self.#{sym}=(obj)
-          @@#{sym} = obj
-        end
-      EOS
-
-      unless options[:instance_writer] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}=(obj)
-            @@#{sym} = obj
-          end
-        EOS
-      end
-      self.send("#{sym}=", yield) if block_given?
-    end
-  end unless method_defined?(:cattr_writer)
-
-  def cattr_accessor(*syms, &blk)
-    cattr_reader(*syms)
-    cattr_writer(*syms, &blk)
-  end unless method_defined?(:cattr_accessor)
-end

data/lib/gorillib/metaprogramming/mattr_accessor.rb

@@ -1,61 +0,0 @@
-require 'gorillib/array/extract_options'
-
-class Module
-  def mattr_reader(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        @@#{sym} = nil unless defined? @@#{sym}
-
-        def self.#{sym}
-          @@#{sym}
-        end
-      EOS
-
-      unless options[:instance_reader] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}
-            @@#{sym}
-          end
-        EOS
-      end
-    end
-  end unless method_defined?(:mattr_reader)
-
-  def mattr_writer(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def self.#{sym}=(obj)
-          @@#{sym} = obj
-        end
-      EOS
-
-      unless options[:instance_writer] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}=(obj)
-            @@#{sym} = obj
-          end
-        EOS
-      end
-    end
-  end unless method_defined?(:mattr_writer)
-
-  # Extends the module object with module and instance accessors for class attributes,
-  # just like the native attr* accessors for instance attributes.
-  #
-  #  module AppConfiguration
-  #    mattr_accessor :google_api_key
-  #    self.google_api_key = "123456789"
-  #
-  #    mattr_accessor :paypal_url
-  #    self.paypal_url = "www.sandbox.paypal.com"
-  #  end
-  #
-  #  AppConfiguration.google_api_key = "overriding the api key!"
-  def mattr_accessor(*syms)
-    mattr_reader(*syms)
-    mattr_writer(*syms)
-  end unless method_defined?(:mattr_accessor)
-
-end

data/lib/gorillib/receiver/active_model_shim.rb

@@ -1,32 +0,0 @@
-# require 'active_model'
-
-require 'active_model/deprecated_error_methods'
-require 'active_model/errors'
-require 'active_model/naming'
-require 'active_model/validator'
-require 'active_model/translation'
-require 'active_model/validations'
-require 'active_support/i18n'
-I18n.load_path << File.join(File.expand_path(File.dirname(__FILE__)), 'locale/en.yml')
-
-module Receiver
-  module ActiveModelShim
-
-    def to_model
-      self
-    end
-
-    def new_record?() true  end
-    def destroyed?()  false end
-    def errors
-      @_errors ||= ActiveModel::Errors.new(self)
-    end
-
-    def self.included(base)
-      base.class_eval do
-        extend  ActiveModel::Naming
-        include ActiveModel::Validations
-      end
-    end
-  end
-end

data/lib/gorillib/receiver/acts_as_hash.rb

@@ -1,195 +0,0 @@
-require 'gorillib/hashlike'
-
-module Receiver
-  #
-  # Makes a Receiver thingie behave mostly like a hash.
-  #
-  # By default, the hashlike methods iterate over the receiver attributes:
-  # instance #keys delegates to self.class.keys which calls
-  # receiver_attr_names. If you want to filter our add to the keys list, you
-  # can just override the class-level keys method (and call super, or not):
-  #
-  #     def self.keys
-  #       super + [:firstname, :lastname] - [:fullname]
-  #     end
-  #
-  # All methods are defined naturally on [], []= and has_key? -- if you enjoy
-  #
-  #
-  # in addition to the below, by including Enumerable, this also adds
-  #
-  #     :each_cons, :each_entry, :each_slice, :each_with_index, :each_with_object,
-  #     :map, :collect, :collect_concat, :entries, :to_a, :flat_map, :inject, :reduce,
-  #     :group_by, :chunk, :cycle, :partition, :reverse_each, :slice_before, :drop,
-  #     :drop_while, :take, :take_while, :detect, :find, :find_all, :find_index, :grep,
-  #     :all?, :any?, :none?, :one?, :first, :count, :zip :max, :max_by, :min, :min_by,
-  #     :minmax, :minmax_by, :sort, :sort_by
-  #
-  # As opposed to hash, does *not* define
-  #
-  #   default, default=, default_proc, default_proc=, shift, flatten, compare_by_identity
-  #   compare_by_identity? rehash
-  #
-  module ActsAsHash
-
-    module InstanceMethods
-
-      # Hashlike#[]
-      #
-      # Element Reference -- Retrieves the value stored for +key+.
-      #
-      # In a normal hash, a default value can be set; none is provided here.
-      #
-      # Delegates to self.send(key)
-      #
-      # @example
-      #     hsh = { :a => 100, :b => 200 }
-      #     hsh[:a] # => 100
-      #     hsh[:c] # => nil
-      #
-      # @param  key [Object] key to retrieve
-      # @return [Object] the value stored for key, nil if missing
-      #
-      def [](key)
-        key = convert_key(key)
-        self.send(key)
-      end
-
-      # Hashlike#[]=
-      # Hashlike#store
-      #
-      # Element Assignment -- Associates the value given by +val+ with the key
-      # given by +key+.
-      #
-      # key should not have its value changed while it is in use as a key. In a
-      # normal hash, a String passed as a key will be duplicated and frozen. No such
-      # guarantee is provided here
-      #
-      # Delegates to self.send("key=", val)
-      #
-      # @example
-      #     hsh = { :a => 100, :b => 200 }
-      #     hsh[:a] = 9
-      #     hsh[:c] = 4
-      #     hsh    # => { :a => 9, :b => 200, :c => 4 }
-      #
-      #     hsh[key] = val                         -> val
-      #     hsh.store(key, val)                    -> val
-      #
-      # @param  key [Object] key to associate
-      # @param  val [Object] value to associate it with
-      # @return [Object]
-      #
-      def []=(key, val)
-        key = convert_key(key)
-        self.send("#{key}=", val)
-      end
-
-      # Hashlike#delete
-      #
-      # Deletes and returns the value from +hsh+ whose key is equal to +key+. If the
-      # optional code block is given and the key is not found, pass in the key and
-      # return the result of +block+.
-      #
-      # In a normal hash, a default value can be set; none is provided here.
-      #
-      # @example
-      #     hsh = { :a => 100, :b => 200 }
-      #     hsh.delete(:a)                            # => 100
-      #     hsh.delete(:z)                            # => nil
-      #     hsh.delete(:z){|el| "#{el} not found" }   # => "z not found"
-      #
-      # @overload hsh.delete(key)                  -> val
-      #   @param  key [Object] key to remove
-      #   @return [Object, Nil] the removed object, nil if missing
-      #
-      # @overload hsh.delete(key){|key| block }    -> val
-      #   @param  key [Object] key to remove
-      #   @yield  [Object] called (with key) if key is missing
-      #   @yieldparam key
-      #   @return [Object, Nil] the removed object, or if missing, the return value
-      #     of the block
-      #
-      def delete(key, &block)
-        key = convert_key(key)
-        if has_key?(key)
-          val = self[key]
-          self.send(:remove_instance_variable, "@#{key}")
-          val
-        elsif block_given?
-          block.call(key)
-        else
-          nil
-        end
-      end
-
-      # Hashlike#keys
-      #
-      # Returns a new array populated with the keys from this hashlike.
-      #
-      # @see Hashlike#values.
-      #
-      # @example
-      #     hsh = { :a => 100, :b => 200, :c => 300, :d => 400 }
-      #     hsh.keys   # => [:a, :b, :c, :d]
-      #
-      # @return [Array] list of keys
-      #
-      def keys
-        members & instance_variables.map{|s| convert_key(s[1..-1]) }
-      end
-
-      def members
-        self.class.members
-      end
-
-      #
-      # Returns a hash with each key set to its associated value.
-      #
-      # @example
-      #    my_hshlike = MyHashlike.new
-      #    my_hshlike[:a] = 100; my_hshlike[:b] = 200
-      #    my_hshlike.to_hash # => { :a => 100, :b => 200 }
-      #
-      # @return [Hash] a new Hash instance, with each key set to its associated value.
-      #
-      def to_hash
-        {}.tap do |hsh|
-          each_pair do |key, val|
-            hsh[key] = val.respond_to?(:to_hash) ? val.to_hash : val
-          end
-        end
-      end
-
-    end
-
-    module ClassMethods
-      # By default, the hashlike methods iterate over the receiver attributes.
-      # If you want to filter our add to the keys list, override this method
-      #
-      # @example
-      #     def self.keys
-      #       super + [:firstname, :lastname] - [:fullname]
-      #     end
-      #
-      def keys
-        receiver_attr_names
-      end
-    end
-
-    protected
-
-    def convert_key(key)
-      raise ArgumentError, "Keys for #{self.class} must be symbols, strings or respond to #to_sym" unless key.respond_to?(:to_sym)
-      key.to_sym
-    end
-
-    def self.included base
-      base.class_eval do
-        include Gorillib::Hashlike
-        extend  ClassMethods
-        include InstanceMethods
-      end
-    end
-  end
-end

data/lib/gorillib/receiver/acts_as_loadable.rb

@@ -1,42 +0,0 @@
-module Receiver
-  #
-  # adds methods to load and store from json, yaml or magic
-  #
-  # This will require 'json' UNLESS you have already included something (so if
-  # you want to say require 'yajl' then do that first).
-  #
-  module ActsAsLoadable
-
-    module ClassMethods
-      def receive_json stream
-        receive(JSON.load(stream))
-      end
-
-      def receive_yaml stream
-        receive(YAML.load(stream))
-      end
-
-      #
-      # The file is loaded with
-      # * YAML if the filename ends in .yaml or .yml
-      # * JSON otherwise
-      #
-      def receive_from_file filename
-        stream = File.open(filename)
-        (filename =~ /.ya?ml$/) ? receive_yaml(stream) : receive_json(stream)
-      end
-    end
-
-    def merge_from_file! filename
-      other_obj = self.class.receive_from_file(filename)
-      tree_merge! other_obj
-    end
-
-    # put all the things in ClassMethods at class level
-    def self.included base
-      require 'yaml'
-      require 'json' unless defined?(JSON)
-      base.extend ClassMethods
-    end
-  end
-end

data/lib/gorillib/receiver/locale/en.yml

@@ -1,27 +0,0 @@
-en:
-  errors:
-    # The default format to use in full error messages.
-    format: "%{attribute} %{message}"
-
-    # The values :model, :attribute and :value are always available for interpolation
-    # The value :count is available when applicable. Can be used for pluralization.
-    messages:
-      inclusion:                "is not included in the list"
-      exclusion:                "is reserved"
-      invalid:                  "is invalid"
-      confirmation:             "doesn't match confirmation"
-      accepted:                 "must be accepted"
-      empty:                    "can't be empty"
-      blank:                    "can't be blank"
-      too_long:                 "is too long (maximum is %{count} characters)"
-      too_short:                "is too short (minimum is %{count} characters)"
-      wrong_length:             "is the wrong length (should be %{count} characters)"
-      not_a_number:             "is not a number"
-      not_an_integer:           "must be an integer"
-      greater_than:             "must be greater than %{count}"
-      greater_than_or_equal_to: "must be greater than or equal to %{count}"
-      equal_to:                 "must be equal to %{count}"
-      less_than:                "must be less than %{count}"
-      less_than_or_equal_to:    "must be less than or equal to %{count}"
-      odd:                      "must be odd"
-      even:                     "must be even"