gorillib 0.4.1pre → 0.4.2pre

data/lib/gorillib/hash/mash.rb

@@ -6,42 +6,9 @@ class Hash
   #
   # @return [Mash] This hash as a Mash for string or symbol key access.
   def to_mash
-    hash = Mash.new(self)
-    hash.default = default
-    hash
-  end
-
-  ##
-  # Create a hash with *only* key/value pairs in receiver and +allowed+
-  #
-  #   { :one => 1, :two => 2, :three => 3 }.only(:one)    #=> { :one => 1 }
-  #
-  # @param allowed [Array[String, Symbol]] The hash keys to include.
-  #
-  # @return [Hash] A new hash with only the selected keys.
-  #
-  # @api public
-  def only(*allowed)
-    hash = {}
-    allowed.each {|k| hash[k] = self[k] if self.has_key?(k) }
-    hash
-  end
-
-  ##
-  # Create a hash with all key/value pairs in receiver *except* +rejected+
-  #
-  #    { :one => 1, :two => 2, :three => 3 }.except(:one)
-  #     #=> { :two => 2, :three => 3 }
-  #
-  # @param rejected [Array[String, Symbol]] The hash keys to exclude.
-  #
-  # @return [Hash] A new hash without the selected keys.
-  #
-  # @api public
-  def except(*rejected)
-    hash = self.dup
-    rejected.each {|k| hash.delete(k) }
-    hash
+    hsh = Mash.new(self)
+    hsh.default = default
+    hsh
   end
 end
 
@@ -109,17 +76,17 @@ class Mash < Hash
     super(convert_key(key))
   end
 
-  # def include? def has_key? def member?
   alias_method :include?, :key?
   alias_method :has_key?, :key?
-  alias_method :member?, :key?
+  alias_method :member?,  :key?
 
   # @param <Object> key The key to fetch. This will be run through convert_key.
-  # @param <Array> extras Default value.
+  # @param <Array> args Default value.
+  # @yield              Default block
   #
   # @return [Object] The value at key or the default value.
-  def fetch(key, *extras)
-    super(convert_key(key), *extras)
+  def fetch(key, *args, &block)
+    super(convert_key(key), *args, &block)
   end
 
   # @param indices [Array]
@@ -127,7 +94,7 @@ class Mash < Hash
   #
   # @return [Array] The values at each of the provided keys
   def values_at(*indices)
-    indices.collect {|key| self[convert_key(key)]}
+    indices.map{|key| self[convert_key(key)] }
   end
 
   # @param hash<Hash> The hash to merge with the mash.
@@ -143,17 +110,6 @@ class Mash < Hash
     super(convert_key(key))
   end
 
-  # @param [Array[(String, Symbol)]] rejected The mash keys to exclude.
-  #
-  # @return [Mash] A new mash without the selected keys.
-  #
-  # @example
-  #   { :one => 1, :two => 2, :three => 3 }.except(:one)
-  #     #=> { "two" => 2, "three" => 3 }
-  def except(*rejected)
-    super(*rejected.map {|k| convert_key(k)})
-  end
-
   # Used to provide the same interface as Hash.
   #
   # @return [Mash] This mash unchanged.
@@ -161,9 +117,9 @@ class Mash < Hash
 
   # @return [Hash] The mash as a Hash with symbolized keys.
   def symbolize_keys
-    h = Hash.new(default)
-    each { |key, val| h[key.to_sym] = val }
-    h
+    hsh = Hash.new(default)
+    each{|key, val| hsh[key.to_sym] = val }
+    hsh
   end
 
   # @return [Hash] The mash as a Hash with string keys.
@@ -171,7 +127,8 @@ class Mash < Hash
     Hash.new(default).merge(self)
   end
 
-  protected
+protected
+
   # @param key [Object] The key to convert.
   #
   # @return [Object]
@@ -194,7 +151,7 @@ class Mash < Hash
     if value.class == Hash
       value.to_mash
     elsif value.is_a?(Array)
-      value.collect { |e| convert_value(e) }
+      value.map{|e| convert_value(e) }
     else
       value
     end

data/lib/gorillib/hashlike/deep_compact.rb

@@ -7,9 +7,9 @@ module Gorillib
       # deep_compact! removes all keys with 'blank?' values in the hash, in place, recursively
       #
       def deep_compact!
-        self.each do |key, val|
+        each_pair do |key, val|
           val.deep_compact! if val.respond_to?(:deep_compact!)
-          self.delete(key) if val.blank?
+          delete(key) if val.blank?
         end
         self
       end

data/lib/gorillib/hashlike/slice.rb

@@ -1,30 +1,31 @@
+require 'set'
 module Gorillib
   module Hashlike
     module Slice
-      # Slice a hash to include only the given allowed_keys.
-      #
-      # @return the sliced hash
+
+      # Returns a copy having only the given keys
       #
       # @example limit an options hash to valid keys before passing to a method:
       #   def search(criteria = {})
-      #     assert_valid_keys(:mass, :velocity, :time)
+      #     assert_valid_keys(:mass, :velocity, :time) # gorillib/hash/keys
       #   end
       #   search(options.slice(:mass, :velocity, :time))
       #
-      # If you have an array of keys you want to limit to, you should splat them:
+      # If you have an array of keys you want to limit to, splat them:
       #
       #   valid_keys = [:mass, :velocity, :time]
       #   search(options.slice(*valid_keys))
-      def slice(*allowed_keys)
-        allowed_keys = allowed_keys.map!{|key| convert_key(key) } if respond_to?(:convert_key)
+      #
+      # @return key/value pairs for keys in self and allowed
+      def slice(*allowed)
+        allowed.map!{|key| convert_key(key) } if respond_to?(:convert_key, true)
         hash = self.class.new
-        allowed_keys.each{|k| hash[k] = self[k] if has_key?(k) }
+        allowed.each{|key| hash[key] = self[key] if has_key?(key) }
         hash
-      end unless method_defined?(:slice)
+      end
 
-      # Replace the hash with only the given allowed_keys.
-      #
-      # @return a hash containing the removed key/value pairs
+      # Retains only the given keys.
+      # Returns a copy containing the removed key/value pairs.
       #
       # @example
       #   hsh = {:a => 1, :b => 2, :c => 3, :d => 4}
@@ -32,17 +33,17 @@ module Gorillib
       #   # => {:c => 3, :d =>4}
       #   hsh
       #   # => {:a => 1, :b => 2}
-      def slice!(*allowed_keys)
-        allowed_keys = allowed_keys.map!{|key| convert_key(key) } if respond_to?(:convert_key)
-        omit = slice(*self.keys - allowed_keys)
-        hash = slice(*allowed_keys)
+      #
+      # @return the removed key/value pairs
+      def slice!(*allowed)
+        allowed.map!{|key| convert_key(key) } if respond_to?(:convert_key, true)
+        omit = slice(*self.keys - allowed)
+        hash = slice(*allowed)
         replace(hash)
         omit
-      end unless method_defined?(:slice!)
+      end
 
-      # Removes the given allowed_keys from the hash
-      #
-      # @return a hash containing the removed key/value pairs
+      # Removes and returns the key/value pairs matching the given keys.
       #
       # @example
       #   hsh = {:a => 1, :b => 2, :c => 3, :d => 4}
@@ -50,50 +51,64 @@ module Gorillib
       #   # => {:a => 1, :b => 2}
       #   hsh
       #   # => {:c => 3, :d =>4}
-      def extract!(*allowed_keys)
-        slice!(*self.keys - allowed_keys)
-      end unless method_defined?(:extract!)
+      #
+      # @return a copy containing the removed key/value pairs
+      def extract!(*allowed)
+        slice!(* self.keys-allowed)
+      end
 
-      # Return a hash that includes everything but the given keys.
+    # end
+    # module ExceptOnly
+
+      # Return a copy that excludes the given keys
       #
       # @example Exclude a blacklist of parameters
       #   @person.update_attributes(params[:person].except(:admin))
       #
-      # If the receiver responds to +convert_key+, the method is called on each of the
-      # arguments. This allows +except+ to play nice with hashes with indifferent access
-      # for instance:
+      # If the receiver responds to +convert_key+, the method is called on each
+      # of the arguments. This allows +except+ to play nice with hashes with
+      # indifferent access for instance:
       #
       # @example mash, hash, it does the right thing:
       #   {:a => 1}.to_mash.except(:a)  # => {}
       #   {:a => 1}.to_mash.except('a') # => {}
       #
-      def except(*keys)
-        dup.except!(*keys)
+      def except(*rejected)
+        dup.except!(*rejected)
       end
 
-      # Replaces the hash without the given keys.
-      def except!(*keys)
-        keys.each{|key| delete(key) }
+      # Modifies the hash to exclude the given keys
+      # @see #except
+      #
+      # @return self
+      def except!(*rejected)
+        rejected.each{|key| delete(key) }
         self
       end
 
+      # Return a copy having only the given keys
+      #
+      # @example Limit a set of parameters to everything but a few known toggles:
+      #   { :one => 1, :two => 2, :three => 3 }.only(:one)    #=> { :one => 1 }
+      #
+      # @param [#include?] allowed keys to include.
+      #
+      # @return [Hash] a copy with only the selected keys.
       def only(*allowed)
         dup.only!(*allowed)
       end
 
-      # Create a hash with *only* key/value pairs in receiver and +allowed+
+      # Retain only the given keys; return self
       #
       # @example Limit a set of parameters to everything but a few known toggles:
-      #   { :one => 1, :two => 2, :three => 3 }.only(:one)    #=> { :one => 1 }
-      #
-      # @param [Array[String, Symbol]] allowed The hash keys to include.
+      #   { :one => 1, :two => 2, :three => 3 }.only!(:one)    #=> { :one => 1 }
       #
-      # @return [Hash] A new hash with only the selected keys.
+      # @param [#include?] allowed keys to include.
       #
-      # @api public
+      # @return self
       def only!(*allowed)
-        allowed = allowed.to_set
-        select!{|key, val| allowed.include?(key) }
+        allowed.map!{|key| convert_key(key) } if respond_to?(:convert_key, true)
+        keep_if{|key, val| allowed.include?(key) }
       end
 
     end

data/lib/gorillib/model.rb

@@ -11,13 +11,15 @@ require 'gorillib/exception/raisers'
 require 'gorillib/metaprogramming/concern'
 require 'gorillib/metaprogramming/class_attribute'
 #
-require 'gorillib/collection'
-require 'gorillib/type/extended'
-require 'gorillib/model/factories'
+require 'gorillib/factories'
+# require 'gorillib/type/extended'
 require 'gorillib/model/named_schema'
 require 'gorillib/model/validate'
 require 'gorillib/model/errors'
 #
 require 'gorillib/model/base'
+require 'gorillib/model/schema_magic'
 require 'gorillib/model/field'
 require 'gorillib/model/defaults'
+#
+require 'gorillib/collection'

data/lib/gorillib/model/base.rb

@@ -19,19 +19,14 @@ module Gorillib
     extend Gorillib::Concern
 
     def initialize(*args, &block)
-      attrs = args.extract_options!
-      if args.present?
-        fns = self.class.field_names
-        ArgumentError.check_arity!(args, 0..fns.length)
-        attrs = attrs.merge(Hash[ fns[0..(args.length-1)].zip(args) ])
-      end
+      attrs = self.class.attrs_hash_from_args(args)
       receive!(attrs, &block)
     end
 
     # Returns a Hash of all attributes
     #
     # @example Get attributes
-    #   person.attributes # => { :name => "Ben Poweski" }
+    #   person.attributes # => { :name => "Emmet Brown", :title => "Dr" }
     #
     # @return [{Symbol => Object}] The Hash of all attributes
     def attributes
@@ -69,12 +64,12 @@ module Gorillib
     # or some such. Use `#update_attributes` if your data is already type safe.
     #
     # @param [{Symbol => Object}] hsh The values to receive
-    # @return [Gorillib::Model] the object itself
+    # @return [nil] nothing
     def receive!(hsh={})
       if hsh.respond_to?(:attributes)
-        hsh = hsh.attributes
+        hsh = hsh.compact_attributes
       else
-        Gorillib::Model::Validate.hashlike!(hsh){ "attributes hash for #{self.inspect}" }
+        Gorillib::Model::Validate.hashlike!(hsh){ "attributes for #{self.inspect}" }
         hsh = hsh.dup
       end
       self.class.field_names.each do |field_name|
@@ -84,12 +79,12 @@ module Gorillib
         self.send("receive_#{field_name}", val)
       end
       handle_extra_attributes(hsh)
-      self
+      nil
     end
 
     def handle_extra_attributes(attrs)
-      @extra_attributes ||= Hash.new
-      @extra_attributes.merge!(attrs)
+      @_extra_attributes ||= Hash.new
+      @_extra_attributes.merge!(attrs)
     end
 
     #
@@ -102,7 +97,7 @@ module Gorillib
     # @return [Gorillib::Model] the object itself
     def update_attributes(hsh)
       if hsh.respond_to?(:attributes) then hsh = hsh.attributes ; end
-      Gorillib::Model::Validate.hashlike!(hsh){ "attributes hash for #{self.inspect}" }
+      Gorillib::Model::Validate.hashlike!(hsh){ "attributes for #{self.inspect}" }
       self.class.field_names.each do |field_name|
         if    hsh.has_key?(field_name)      then val = hsh[field_name]
         elsif hsh.has_key?(field_name.to_s) then val = hsh[field_name.to_s]
@@ -193,24 +188,27 @@ module Gorillib
       attributes == other.attributes
     end
 
-    # override inspect_helper (not this) in your descendant class
+    # override to_inspectable (not this) in your descendant class
     # @return [String] Human-readable presentation of the attributes
-    def inspect(detailed=true)
-      inspect_helper(detailed, compact_attributes)
+    def inspect
+      str = '#<' << self.class.name.to_s
+      attrs = to_inspectable
+      if attrs.present?
+        str << '(' << attrs.map{|attr, val| "#{attr}=#{val.respond_to?(:inspect_compact) ? val.inspect_compact : val.inspect}" }.join(", ") << ')'
+      end
+      str << '>'
+    end
+
+    def inspect_compact
+      str = "#<#{self.class.name.to_s}>"
     end
 
     # assembles just the given attributes into the inspect string.
     # @return [String] Human-readable presentation of the attributes
-    def inspect_helper(detailed, attrs)
-      str = "#<" << self.class.name.to_s
-      if detailed && attrs.present?
-        str << " " << attrs.map do |attr, val|
-          "#{attr}=#{val.is_a?(Gorillib::Model) || val.is_a?(Gorillib::GenericCollection) ? val.inspect(false) : val.inspect}"
-        end.join(", ")
-      end
-      str << ">"
+    def to_inspectable
+      compact_attributes
     end
-    private :inspect_helper
+    private :to_inspectable
 
   protected
 
@@ -229,7 +227,7 @@ module Gorillib
       # @return [Gorillib::Model] the new object
       def receive(attrs={}, &block)
         return nil if attrs.nil?
-        return attrs if attrs.is_a?(self)
+        return attrs if native?(attrs)
         #
         Gorillib::Model::Validate.hashlike!(attrs){ "attributes for #{self.inspect}" }
         klass = attrs.has_key?(:_type) ? Gorillib::Factory(attrs[:_type]) : self
@@ -238,45 +236,13 @@ module Gorillib
         klass.new(attrs, &block)
       end
 
-      # Defines a new field
-      #
-      # For each field that is defined, a getter and setter will be added as
-      # an instance method to the model. An Field instance will be added to
-      # result of the fields class method.
+      # A `native` object does not need any transformation; it is accepted directly.
+      # By default, an object is native if it `is_a?` this class
       #
-      # @example
-      #   field :height, Integer
-      #
-      # @param [Symbol] field_name             The field name. Must start with `[A-Za-z_]` and subsequently contain only `[A-Za-z0-9_]`
-      # @param [Class]  type                   The field's type (required)
-      # @option options [String] doc           Documentation string for the field (optional)
-      # @option options [Proc, Object] default Default value, or proc that instance can evaluate to find default value
-      #
-      # @return Gorillib::Model::Field
-      def field(field_name, type, options={})
-        options = options.symbolize_keys
-        field_type = options.delete(:field_type){ ::Gorillib::Model::Field }
-        fld = field_type.new(field_name, type, self, options)
-        @_own_fields[fld.name] = fld
-        _reset_descendant_fields
-        fld.send(:inscribe_methods, self)
-        fld
-      end
-
-      # @return [{Symbol => Gorillib::Model::Field}]
-      def fields
-        return @_fields if defined?(@_fields)
-        @_fields = ancestors.reverse.inject({}){|acc, ancestor| acc.merge!(ancestor.try(:_own_fields) || {}) }
-      end
-
-      # @return [true, false] true if the field is defined on this class
-      def has_field?(field_name)
-        fields.has_key?(field_name)
-      end
-
-      # @return [Array<Symbol>] The attribute names
-      def field_names
-        @_field_names ||= fields.keys
+      # @param  obj [Object] the object that will be received
+      # @return [true, false] true if the item does not need conversion
+      def native?(obj)
+        obj.is_a?(self)
       end
 
       # @return Class name and its attributes
@@ -284,62 +250,10 @@ module Gorillib
       # @example Inspect the model's definition.
       #   Person.inspect #=> Person[first_name, last_name]
       def inspect
-        "#{self.name || 'anon'}[#{ field_names.join(", ") }]"
-      end
-
-    protected
-
-      attr_reader :_own_fields
-
-      # Ensure that classes inherit all their parents' fields, even if fields
-      # are added after the child class is defined.
-      def _reset_descendant_fields
-        ObjectSpace.each_object(::Class) do |klass|
-          klass.__send__(:remove_instance_variable, '@_fields')      if (klass <= self) && klass.instance_variable_defined?('@_fields')
-          klass.__send__(:remove_instance_variable, '@_field_names') if (klass <= self) && klass.instance_variable_defined?('@_field_names')
-        end
-      end
-
-      # define the reader method `#foo` for a field named `:foo`
-      def define_attribute_reader(field_name, field_type, visibility)
-        define_meta_module_method(field_name, visibility) do
-          begin
-            read_attribute(field_name)
-          rescue StandardError => err ; err.polish("#{self.class}.#{field_name}") rescue nil ; raise ; end
-        end
+        "#{self.name || 'anon'}[#{ field_names.join(",") }]"
       end
+      def inspect_compact() self.name || inspect ; end
 
-      # define the writer method `#foo=` for a field named `:foo`
-      def define_attribute_writer(field_name, field_type, visibility)
-        define_meta_module_method("#{field_name}=", visibility) do |val|
-          write_attribute(field_name, val)
-        end
-      end
-
-      # define the present method `#foo?` for a field named `:foo`
-      def define_attribute_tester(field_name, field_type, visibility)
-        field = fields[field_name]
-        define_meta_module_method("#{field_name}?", visibility) do
-          attribute_set?(field_name) || field.has_default?
-        end
-      end
-
-      def define_attribute_receiver(field_name, field_type, visibility)
-        define_meta_module_method("receive_#{field_name}", visibility) do |val|
-          begin
-            val = field_type.receive(val)
-            write_attribute(field_name, val)
-            self
-          rescue StandardError => err ; err.polish("#{self.class}.#{field_name} type #{type} on #{val}") rescue nil ; raise ; end
-        end
-      end
-
-      def inherited(base)
-        base.instance_eval do
-          @_own_fields ||= {}
-        end
-        super
-      end
     end
 
     self.included do |base|