gorillib 0.5.0 → 0.5.2

data/old/lib/gorillib/receiver/active_model_shim.rb

@@ -0,0 +1,32 @@
+# 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/old/lib/gorillib/receiver/acts_as_hash.rb

@@ -0,0 +1,195 @@
+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/old/lib/gorillib/receiver/acts_as_loadable.rb

@@ -0,0 +1,42 @@
+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/old/lib/gorillib/receiver/locale/en.yml

@@ -0,0 +1,27 @@
+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"

data/old/lib/gorillib/receiver/tree_diff.rb

@@ -0,0 +1,74 @@
+module Receiver
+  def tree_diff(other)
+    diff_hsh = {}
+    other = other.symbolize_keys if other.respond_to?(:symbolize_keys)
+    each do |k, v|
+      case
+      when v.is_a?(Array) && other[k].is_a?(Array)
+        val = v.tree_diff(other[k])
+        diff_hsh[k] = val unless val.blank?
+      when v.respond_to?(:tree_diff) && other[k].respond_to?(:to_hash)
+        val = v.tree_diff(other[k])
+        diff_hsh[k] = val unless val.blank?
+      else
+        diff_hsh[k] = v unless v == other[k]
+      end
+    end
+    other_hsh = other.dup.delete_if{|k, v| has_key?(k) }
+    diff_hsh.merge!(other_hsh)
+  end
+
+  module ActsAsHash
+    def <=>(other)
+      return 1 if other.blank?
+      each_key do |k|
+        if has_key?(k) && other.has_key?(k)
+          cmp = self[k] <=> other[k]
+          return cmp unless cmp == 0
+        end
+      end
+      0
+    end
+  end
+end
+
+class Array
+  def tree_diff(other)
+    arr = dup
+    if other.length > arr.length then arr = arr + ([nil] * (other.length - arr.length)) end
+    diff_ary = arr.zip(other).map do |arr_el, other_el|
+      if arr_el.respond_to?(:tree_diff)  && other_el.respond_to?(:to_hash)
+        arr_el.tree_diff(other_el)
+      else
+        (arr_el == other_el) ? nil : [arr_el, other_el]
+      end
+    end.reject(&:blank?)
+  end
+end
+
+class Hash
+  # Returns a hash that represents the difference between two hashes.
+  #
+  # Examples:
+  #
+  #   {1 => 2}.tree_diff(1 => 2)         # => {}
+  #   {1 => 2}.tree_diff(1 => 3)         # => {1 => 2}
+  #   {}.tree_diff(1 => 2)               # => {1 => 2}
+  #   {1 => 2, 3 => 4}.tree_diff(1 => 2) # => {3 => 4}
+  def tree_diff(other)
+    diff_hsh = self.dup
+    each do |k, v|
+      case
+      when v.is_a?(Array) && other[k].is_a?(Array)
+        diff_hsh[k] = v.tree_diff(other[k])
+        diff_hsh.delete(k) if diff_hsh[k].blank?
+      when v.respond_to?(:tree_diff)  && other[k].respond_to?(:to_hash)
+        diff_hsh[k] = v.tree_diff(other[k])
+        diff_hsh.delete(k) if diff_hsh[k].blank?
+      else diff_hsh.delete(k) if v == other[k]
+      end
+    end
+    other_hsh = other.dup.delete_if{|k, v| has_key?(k) || has_key?(k.to_s) }
+    diff_hsh.merge!(other_hsh)
+  end
+end

data/old/lib/gorillib/receiver/validations.rb

@@ -0,0 +1,30 @@
+module Receiver
+
+  # An array of strings describing any ways this fails validation
+  def validation_errors
+    errors = []
+    if (ma = missing_attrs).present?
+      errors << "Missing values for {#{ma.join(",")}}"
+    end
+    errors
+  end
+
+  # returns a list of required but missing attributes
+  def missing_attrs
+    missing = []
+    self.class.required_rcvrs.each do |name, info|
+      missing << name if (not attr_set?(name))
+    end
+    missing
+  end
+
+  # methods become class-level
+  module ClassMethods
+
+    # class method gives info for all receiver attributes with required => true
+    def required_rcvrs
+      receiver_attrs.select{|name, info|  info[:required] }
+    end
+  end
+
+end

data/old/lib/gorillib/receiver_model.rb

@@ -0,0 +1,21 @@
+require 'gorillib/hashlike'
+require 'gorillib/hashlike/tree_merge'
+require 'gorillib/receiver'
+require 'gorillib/receiver/acts_as_hash'
+require 'gorillib/receiver/acts_as_loadable'
+require 'gorillib/receiver/active_model_shim'
+
+module Gorillib
+  module ReceiverModel
+    def self.included base
+      base.class_eval do
+        include Receiver
+        include Receiver::ActsAsHash
+        include Receiver::ActsAsLoadable
+        include Gorillib::Hashlike
+        include Gorillib::Hashlike::TreeMerge
+        include Receiver::ActiveModelShim
+      end
+    end
+  end
+end

data/old/lib/gorillib/struct/acts_as_hash.rb

@@ -0,0 +1,108 @@
+module Gorillib
+  module Struct
+    #
+    # Make a Struct 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
+    #
+    # 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
+    #
+    # @example
+    #   StructUsingHashlike = Struct.new(:a, :b, :c, :z) do
+    #     include Gorillib::Struct::ActsAsHash
+    #     include Gorillib::Hashlike
+    #   end
+    #   foo = StructUsingHashlike.new(1,2,3)
+    #   foo.to_hash  # => { :a => 1, :b => 2, :c => 3, :z => nil }
+    #
+    module ActsAsHash
+
+      # 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)
+        if has_key?(key)
+          val = self[key]
+          self[key] = nil
+          self.send(:remove_instance_variable, "@#{key}") if instance_variables.include?("@#{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
+        @keys ||= members.map{|key| convert_key(key) }
+      end
+
+      def empty?
+        keys.select{|key| not self[key].nil? }.empty?
+      end
+
+      def convert_key(key)
+        return key if key.is_a?(Fixnum)
+        key.respond_to?(:to_sym) ? key.to_sym : key
+      end
+
+      def size
+        length
+      end
+
+    end
+  end
+end