attributor 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eaf11f67f19da1559c3abdbcebed02193ac9e5e3
-  data.tar.gz: 6ba6a1dbf45d4e2d43450036651f0d4c0fde9829
+  metadata.gz: 6e832c8023013ffad5fa5a40e13200e5dcfeb4c4
+  data.tar.gz: a1d2a7043187872b6cdc424b503b8ce08a5935ab
 SHA512:
-  metadata.gz: 410e51a836135f981bee0cc40aabb254c526ade79aafa224a96881dac78b8c1986ff088b33f89e80da8a0899ebc086a9ff589768130adf78ca3cb84ae7a8b350
-  data.tar.gz: 22d78b19144db5a3c19b778a6c9c32e66ce819f86d3a71dc443462ab0f4a8911345cefe193995b43897c8fd30224de0a67a7e000fa79a5b18a66586e70adbb67
+  metadata.gz: 26f1bd976df8c4ad47ea3e617e2abdcabd7d6d070a82dce44abb2e16ededcae6289ca7e074ba503f9ee7f6f4e79036bb49078509c2812f63ca02d3eab190466e
+  data.tar.gz: ee7b663e6d9095d2909f355cf0f78e76d0cc5e6c8c0a2b0f44338fed5776a9a36360aba0b81f9a2b7ac532b88c2b8e7c8168187503405ed1b8cff1a82fc36cbd

data/CHANGELOG.md

@@ -1,6 +1,15 @@
 Attributor Changelog
 ============================
 
+2.4.0
+------
+
+* `Model` is now a subclass of `Hash`. 
+  * The interface for `Model` instances is almost entirely unchanged, except for the addition of `Hash`-like methods (i.e., you can now do `some_model[:key]` to access attributes).
+  * This fixes numerous incompatabilities between models and hashes, as well as confusing differences between the behavior when loading a model vs a hash.
+* `String.load` now raises `IncompatibleTypeError` for `Enumerable` values.
+* Added `Symbol` type, use with caution as it will automatically call `#to_sym` on anything loaded. 
+
 2.3.0
 ------
 

data/lib/attributor.rb

@@ -13,7 +13,8 @@ module Attributor
   require_relative 'attributor/dsl_compiler'
   require_relative 'attributor/attribute_resolver'
 
-
+  require_relative 'attributor/example_mixin'
+  
   require_relative 'attributor/extensions/randexp'
 
 
@@ -37,7 +38,7 @@ module Attributor
       raise AttributorException.new("Could not find attribute type for: #{name} [klass: #{klass.name}]")  unless  klass < Attributor::Type
     end
 
-    if klass.respond_to?(:construct)
+    if klass.constructable?
       return klass.construct(constructor_block, options)
     end
 
@@ -48,7 +49,15 @@ module Attributor
 
   def self.humanize_context( context )
     raise "NIL CONTEXT PASSED TO HUMANZE!!" unless context
-    raise "INVALID CONTEXT!!! (got: #{context.inspect})" unless context.is_a? Enumerable
+
+    if context.kind_of? ::String
+      context = Array(context)
+    end
+
+    unless context.is_a? Enumerable
+      raise "INVALID CONTEXT!!! (got: #{context.inspect})" 
+    end
+    
     begin
       return context.join('.')
     rescue Exception => e
@@ -70,8 +79,7 @@ module Attributor
   require_relative 'attributor/types/bigdecimal'
   require_relative 'attributor/types/integer'
   require_relative 'attributor/types/string'
-  require_relative 'attributor/types/model'
-  require_relative 'attributor/types/struct'
+  require_relative 'attributor/types/symbol'
   require_relative 'attributor/types/boolean'
   require_relative 'attributor/types/date'
   require_relative 'attributor/types/date_time'
@@ -79,6 +87,8 @@ module Attributor
   require_relative 'attributor/types/float'
   require_relative 'attributor/types/collection'
   require_relative 'attributor/types/hash'
+  require_relative 'attributor/types/model'
+  require_relative 'attributor/types/struct'
   
 
   require_relative 'attributor/types/csv'

data/lib/attributor/dsl_compiler.rb

@@ -80,6 +80,7 @@ module Attributor
     #     end
     # @api semiprivate
     def define(name, attr_type=nil, **opts, &block)
+      # add to existing attribute if present
       if (existing_attribute = attributes[name])
         if existing_attribute.attributes
           existing_attribute.type.attributes(&block)
@@ -87,28 +88,26 @@ module Attributor
         end
       end
 
+      # determine inherited attribute
+      inherited_attribute = nil      
       if (reference = self.options[:reference])
-        inherited_attribute = reference.attributes[name]
-      else
-        inherited_attribute = nil
+        if (inherited_attribute = reference.attributes[name])
+          opts = inherited_attribute.options.merge(opts) unless attr_type
+          opts[:reference] = inherited_attribute.type if block_given?
+        end
       end
 
+      # determine attribute type to use
       if attr_type.nil?
-        if inherited_attribute
-          attr_type = inherited_attribute.type
-          # Only inherit opts if no explicit attr_type was given.
-          opts = inherited_attribute.options.merge(opts)
-        elsif block_given?
+        if block_given?
           attr_type = Attributor::Struct
+        elsif inherited_attribute
+          attr_type = inherited_attribute.type
         else
           raise AttributorException, "type for attribute with name: #{name} could not be determined"
         end
       end
 
-      if block_given? && inherited_attribute
-        opts[:reference] = inherited_attribute.type
-      end
-
       Attributor::Attribute.new(attr_type, opts, &block)
     end
 

data/lib/attributor/example_mixin.rb

@@ -0,0 +1,63 @@
+# poorly-optimized, but handy, mixin for Hash and Model examples.
+# primarily enables support for lazy values.
+
+module Attributor
+
+  module ExampleMixin
+
+    def self.extended(obj)
+      obj.class.attributes.each do |name, _|
+        obj.define_singleton_method(name) do
+          get(name)
+        end
+      end
+    end
+
+    def lazy_attributes
+      @lazy_attributes ||= {}
+    end
+
+    def lazy_attributes=(val)
+      @lazy_attributes = val
+    end
+
+    def keys
+      @contents.keys | lazy_attributes.keys
+    end
+
+    def key?(key)
+      @contents.key?(key) || lazy_attributes.key?(key)
+    end
+
+    def get(key, context: self.generate_subcontext(Attributor::DEFAULT_ROOT_CONTEXT,key))
+      key = self.class.key_attribute.load(key, context)
+
+      unless @contents.key? key
+        if lazy_attributes.key?(key)
+          proc = lazy_attributes.delete(key)
+          @contents[key] = proc.call(self)
+        end
+      end
+
+      super
+    end
+
+    def attributes
+      lazy_attributes.keys.each do |name|
+        self.__send__(name)
+      end
+
+      super
+    end
+
+    def contents
+      lazy_attributes.keys do |key|
+        proc = lazy_attributes.delete(key)
+        @contents[key] = proc.call(self)
+      end
+      
+      super
+    end
+  end
+
+end

data/lib/attributor/type.rb

@@ -10,7 +10,12 @@ module Attributor
 
 
     module ClassMethods
-      
+  
+      # Does this type support the generation of subtypes? 
+      def constructable? 
+        false
+      end
+
       # Generic decoding and coercion of the attribute.
       def load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
         return nil if value.nil?

data/lib/attributor/types/collection.rb

@@ -90,6 +90,11 @@ module Attributor
       hash
     end
 
+
+    def self.constructable? 
+      true
+    end
+
     def self.construct(constructor_block, options)
 
       member_options =  (options[:member_options]  || {} ).clone

data/lib/attributor/types/hash.rb

@@ -2,6 +2,9 @@ module Attributor
   class Hash
     extend Forwardable
 
+    MAX_EXAMPLE_DEPTH = 5
+    CIRCULAR_REFERENCE_MARKER = '...'.freeze
+
     include Container
     include Enumerable
 
@@ -19,24 +22,15 @@ module Attributor
     @key_attribute = Attribute.new(@key_type)
     @value_attribute = Attribute.new(@value_type)
 
-    def self.key_type=(key_type)
-      resolved_key_type = Attributor.resolve_type(key_type)
-      unless resolved_key_type.ancestors.include?(Attributor::Type)
-        raise Attributor::AttributorException.new("Hashes only support key types that are Attributor::Types. Got #{resolved_key_type.name}")
-      end
 
-      @key_type = resolved_key_type
+    def self.key_type=(key_type)
+      @key_type = Attributor.resolve_type(key_type)
       @key_attribute = Attribute.new(@key_type)
       @concrete=true
     end
 
     def self.value_type=(value_type)
-      resolved_value_type = Attributor.resolve_type(value_type)
-      unless resolved_value_type.ancestors.include?(Attributor::Type)
-        raise Attributor::AttributorException.new("Hashes only support value types that are Attributor::Types. Got #{resolved_value_type.name}")
-      end
-
-      @value_type = resolved_value_type
+      @value_type = Attributor.resolve_type(value_type)
       @value_attribute = Attribute.new(@value_type)
       @concrete=true
     end
@@ -113,6 +107,10 @@ module Attributor
       end
     end
 
+    def self.constructable?
+      true
+    end
+
 
     def self.construct(constructor_block, **options)
       return self if constructor_block.nil?
@@ -131,34 +129,64 @@ module Attributor
     end
 
 
-    def self.example(context=nil, options: {})
-      return self.new if (key_type == Object && value_type == Object)
-
+    def self.example_contents(context, parent, **values)
       hash = ::Hash.new
+      example_depth = context.size
+
+      self.keys.each do |sub_attribute_name, sub_attribute|
+        if sub_attribute.attributes
+          # TODO: add option to raise an exception in this case?
+          next if example_depth > MAX_EXAMPLE_DEPTH
+        end
+
+        sub_context = self.generate_subcontext(context,sub_attribute_name)
+        block = Proc.new do
+          value = values.fetch(sub_attribute_name) do
+            sub_attribute.example(sub_context, parent: parent)
+          end
+
+          sub_attribute.load(value,sub_context)
+        end
+
+
+        hash[sub_attribute_name] = block
+      end
+
+      hash
+    end
+
+    def self.example(context=nil, **values)
+      if (key_type == Object && value_type == Object && self.keys.empty?)
+        return self.new 
+      end
+
       context ||= ["#{Hash}-#{rand(10000000)}"]
       context = Array(context)
 
       if self.keys.any?
-        self.keys.each do |sub_name, sub_attribute|
-          subcontext = context + ["at(#{sub_name})"]
-          hash[sub_name] = sub_attribute.example(subcontext)
-        end
+        result = self.new
+        result.extend(ExampleMixin)
+
+        result.lazy_attributes = self.example_contents(context, result, values)
       else
-        size = rand(3) + 1
+        hash = ::Hash.new
 
-        size.times do |i|
+        (rand(3) + 1).times do |i|
           example_key = key_type.example(context + ["at(#{i})"])
           subcontext = context + ["at(#{example_key})"]
           hash[example_key] = value_type.example(subcontext)
         end
+
+        result = self.new(hash)
       end
 
-      self.new(hash)
+      result
     end
 
 
     def self.dump(value, **opts)
-      self.load(value).dump(**opts)
+      self.load(value).
+        dump(**opts)
     end
 
 
@@ -182,6 +210,8 @@ module Attributor
 
 
     def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, recurse: false, **options)
+      context = Array(context)
+
       if value.nil?
         if recurse
           loaded_value = {}
@@ -191,6 +221,10 @@ module Attributor
       elsif value.is_a?(self)
         return value
       elsif value.kind_of?(Attributor::Hash)
+        if (value.keys - self.attributes.keys).any?
+          raise Attributor::IncompatibleTypeError, context: context, value_type: value.class, type: self
+        end
+
         loaded_value = value.contents
       elsif value.is_a?(::Hash)
         loaded_value = value
@@ -219,8 +253,9 @@ module Attributor
 
     def get(key, context: self.generate_subcontext(Attributor::DEFAULT_ROOT_CONTEXT,key))
       key = self.class.key_attribute.load(key, context)
-      value = @contents[key]
       
+      value = @contents[key]
+
       if (attribute = self.class.keys[key])
         return self[key] = attribute.load(value, context)
       end
@@ -236,12 +271,10 @@ module Attributor
         else
           extra_keys_key = self.class.extra_keys
 
-          unless @contents.key? extra_keys_key
-            extra_keys_value = self.class.keys[extra_keys_key].load({})
-            @contents[extra_keys_key] = extra_keys_value
+          if @contents.key? extra_keys_key
+            return @contents[extra_keys_key].get(key, context: context)
           end
 
-          return @contents[extra_keys_key].get(key, context: context)
         end
       end
 
@@ -249,11 +282,11 @@ module Attributor
     end
 
 
-    def set(key, value, context: self.generate_subcontext(Attributor::DEFAULT_ROOT_CONTEXT,key))
+    def set(key, value, context: self.generate_subcontext(Attributor::DEFAULT_ROOT_CONTEXT,key), recurse: false)
       key = self.class.key_attribute.load(key, context)
 
       if (attribute = self.class.keys[key])
-        return self[key] = attribute.load(value, context)
+        return self[key] = attribute.load(value, context, recurse: recurse)
       end
 
       if self.class.options[:case_insensitive_load]
@@ -289,14 +322,14 @@ module Attributor
       if self.extra_keys
         sub_context = self.generate_subcontext(context,self.extra_keys)
         v = object.fetch(self.extra_keys, {})
-        hash.set(self.extra_keys, v, context: sub_context)
+        hash.set(self.extra_keys, v, context: sub_context, recurse: recurse)
       end
 
       object.each do |k,v|
         next if k == self.extra_keys
 
         sub_context = self.generate_subcontext(Attributor::DEFAULT_ROOT_CONTEXT,k)
-        hash.set(k, v, context: sub_context)
+        hash.set(k, v, context: sub_context, recurse: recurse)
       end
 
       # handle default values for missing keys
@@ -342,13 +375,26 @@ module Attributor
       hash
     end
 
-    # TODO: chance value_type and key_type to be attributes?
-    # TODO: add a validate, which simply validates that the incoming keys and values are of the right type.
-    #       Think about the format of the subcontexts to use: let's use .at(key.to_s)
+    # TODO: Think about the format of the subcontexts to use: let's use .at(key.to_s)
     attr_reader :contents
-    def_delegators :@contents, :[], :[]=, :each, :size, :keys, :key?, :values, :empty?, :has_key?
+    
+    def_delegators :@contents, 
+      :[], 
+      :[]=, 
+      :each, 
+      :size, 
+      :keys, 
+      :key?, 
+      :values, 
+      :empty?, 
+      :has_key?
+
+    attr_reader :validating, :dumping
 
     def initialize(contents={})
+      @validating = false
+      @dumping = false
+
       @contents = contents
     end
 
@@ -360,7 +406,6 @@ module Attributor
       self.class.value_type
     end
 
-
     def key_attribute
       self.class.key_attribute
     end
@@ -412,10 +457,15 @@ module Attributor
       end
     end
 
+
     def dump(**opts)
+      return CIRCULAR_REFERENCE_MARKER if @dumping
+
+      @dumping = true
+
       @contents.each_with_object({}) do |(k,v),hash|
         k = self.key_attribute.dump(k,opts)
-        
+
         if (attribute_for_value = self.class.keys[k])
           v = attribute_for_value.dump(v,opts)
         else
@@ -424,6 +474,8 @@ module Attributor
 
         hash[k] = v
       end
+    ensure
+      @dumping = false
     end
 
   end

data/lib/attributor/types/model.rb

@@ -1,27 +1,43 @@
 module Attributor
-  class Model
-    include Attributor::Type
-    MAX_EXAMPLE_DEPTH = 5
-    CIRCULAR_REFERENCE_MARKER = '...'.freeze
+  class Model < Hash
 
     # FIXME: this is not the way to fix this. Really we should add finalize! to Models.
     undef :timeout
     undef :format
     undef :test rescue nil
 
+    # Remove undesired methods inherited from Hash
+    undef :size
+    undef :keys
+    undef :values
+    undef :empty? 
+    undef :has_key?
+
+    @key_type = Symbol
+    @value_type = Object
+
+    @key_attribute = Attribute.new(@key_type)
+    @value_attribute = Attribute.new(@value_type)
+
     def self.inherited(klass)
+      k = self.key_type
+      ka = self.key_attribute 
+
+      v = self.value_type
+      va = self.value_attribute
+
       klass.instance_eval do
         @saved_blocks = []
         @options = {}
-        @attributes = {}
-      end
-    end
+        @keys = {}
+        @key_type = k
+        @value_type = v
 
-    class << self
-      attr_reader :options
+        @key_attribute = ka
+        @value_attribute = va
+      end
     end
 
-
     # Define accessors for attribute of given name.
     #
     # @param name [::Symbol] attribute name
@@ -32,98 +48,30 @@ module Attributor
       self.define_writer(name)
     end
 
-
     def self.define_reader(name)
       module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{name}
-          return @attributes[:#{name}] if @attributes.has_key?(:#{name})
-
-          @attributes[:#{name}] = begin
-            if (proc = @lazy_attributes.delete :#{name})
-              if proc.arity > 0
-                proc.call(self)
-              else
-                proc.call
-              end
-            end
-          end
+          @contents[:#{name}]
         end
       RUBY
     end
 
 
     def self.define_writer(name)
-      attribute = self.attributes[name]
       context = ["assignment","of(#{name})"].freeze
-      # note: paradoxically, using define_method ends up being faster for the writer
-      #       attribute is captured by the block, saving us from having to retrieve it from
-      #       the class's attributes hash on each write.
       module_eval do
         define_method(name.to_s + "=") do |value|
-          # TODO: what type of context do we report with unscoped assignments?
-          #  => for now this would report "assignment.of(field_name)" is that good?
-          @attributes[name] = attribute.load(value,context)
+          self.set(name, value, context: context)
         end
       end
     end
 
-
     def self.describe(shallow=false)
       hash = super
-
-      # Spit attributes if it's the root or if it's an anonymous structures
-      if ( !shallow || self.name == nil) && self.attributes
-        hash[:attributes] = self.attributes.each_with_object({}) do |(sub_name, sub_attribute), sub_attributes|
-          sub_attributes[sub_name] = sub_attribute.describe(true)
-        end
-      end
-
+      hash[:attributes] = hash.delete :keys
       hash
     end
 
-
-    def self.example(context=nil, **values)
-      result = self.new
-
-      context = case context
-      when nil
-        ["#{self.name}-#{result.object_id.to_s}"]
-      when ::String
-        [context]
-      else
-        context
-      end
-
-      example_depth = context.size
-
-      self.attributes.each do |sub_attribute_name,sub_attribute|
-        if sub_attribute.attributes
-           # TODO: add option to raise an exception in this case?
-           next if example_depth > MAX_EXAMPLE_DEPTH
-        end
-
-        sub_context = self.generate_subcontext(context,sub_attribute_name)
-
-        result.lazy_attributes[sub_attribute_name] = Proc.new do
-          value = values.fetch(sub_attribute_name) do
-            sub_attribute.example(sub_context, parent: result)
-          end
-
-          sub_attribute.load(value,sub_context)
-        end
-      end
-
-      result
-    end
-
-    def self.dump(value, **opts)
-      self.load(value).dump(**opts)
-    end
-
-    def self.native_type
-      self
-    end
-
     def self.check_option!(name, value)
       case name
       when :identity
@@ -140,115 +88,16 @@ module Attributor
       end
     end
 
-
-    # Model-specific decoding and coercion of the attribute.
-    def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, recurse: false, **options)
-      if value.nil?
-        if recurse
-          value = {}
-        else
-          return value
-        end
-      end
-
-      return value if value.kind_of?(self.native_type)
-
-      context = Array(context)
-
-      hash = case value
-      when ::String
-        # Strings are assumed to be JSON-serialized for now.
-        begin
-          JSON.parse(value)
-        rescue
-          raise DeserializationError, context: context, from: value.class, encoding: "JSON" , value: value
-        end
-      when ::Hash
-        value
-      else
-        raise IncompatibleTypeError,  context: context, value_type: value.class, type: self
-      end
-
-      self.from_hash(hash,context, recurse: recurse)
-    end
-
-
-    def self.from_hash(hash,context, recurse: false)
-      model = self.new
-
-      self.attributes.each do |attribute_name, attribute|
-        # p [attribute_name, attribute]
-        # OPTIMIZE: deleting the keys as we go is mucho faster, but also very risky
-        # Note: use "load" vs. attribute assignment so we can propagate the right context down.
-        sub_context = self.generate_subcontext(context,attribute_name)
-        model.attributes[attribute_name] = attribute.load(hash[attribute_name] || hash[attribute_name.to_s], sub_context, recurse: recurse)
-      end
-
-      unknown_keys = hash.keys.collect {|k| k.to_sym} - self.attributes.keys
-
-      if unknown_keys.any?
-        raise AttributorException, "Unknown attributes received: #{unknown_keys.inspect} while loading #{Attributor.humanize_context(context)}"
-      end
-
-      model
-    end
-
-    # method to only define the block of attributes for the model
-    # This will be a lazy definition. So we'll only save it in an instance class var for later.
-    def self.attributes(opts={},&block)
-      if block_given?
-        @saved_blocks.push(block)
-        @options.merge!(opts)
-      elsif @saved_blocks.any?
-        self.definition
-      end
-
-      @attributes
-    end
-
-
-    def self.validate(object,context=Attributor::DEFAULT_ROOT_CONTEXT,_attribute)
-      context = [context] if context.is_a? ::String
-
-      unless object.kind_of?(self)
-        raise ArgumentError, "#{self.name} can not validate object of type #{object.class.name} for #{Attributor.humanize_context(context)}."
-      end
-
-      object.validate(context)
-    end
-
-    def self.valid_type?(type)
-      type.kind_of?(self) || type.kind_of?(::Hash)
-    end
-
-    def self.dsl_class
-      @options[:dsl_compiler] || DSLCompiler
-    end
-
-    # Returns the "compiled" definition for the model.
-    # By "compiled" I mean that it will create a new Compiler object with the saved options and saved block that has been passed in the 'attributes' method. This compiled object is memoized (remember, there's one instance of a compiled definition PER MODEL CLASS).
-    # TODO: rework this with Model.finalize! support.
-    def self.definition
-      blocks = @saved_blocks.shift(@saved_blocks.size)
-
-      compiler = dsl_class.new(self, self.options)
-      compiler.parse(*blocks)
-
-      nil
+    def self.generate_subcontext(context, subname)
+      context + [subname] 
     end
 
-    attr_reader :lazy_attributes, :validating, :dumping
-
-
-    def initialize( data = nil)
-      @lazy_attributes = ::Hash.new
-      @validating = false
-      @dumping = false
+    def initialize(data = nil)
       if data
         loaded = self.class.load(data)
-        @attributes = loaded.attributes
+        @contents = loaded.attributes
       else
-        @attributes = ::Hash.new
+        @contents = {}
       end
     end
 
@@ -279,10 +128,7 @@ module Attributor
 
 
     def attributes
-      @lazy_attributes.keys.each do |name|
-        self.__send__(name)
-      end
-      @attributes
+      @contents
     end
 
 
@@ -311,12 +157,10 @@ module Attributor
 
     def dump(context: Attributor::DEFAULT_ROOT_CONTEXT, **opts)
       return CIRCULAR_REFERENCE_MARKER if @dumping
-
       @dumping = true
 
       self.attributes.each_with_object({}) do |(name, value), result|
         attribute = self.class.attributes[name]
-
         result[name.to_sym] = attribute.dump(value, context: context + [name] )
       end
     ensure
@@ -324,4 +168,5 @@ module Attributor
     end
 
   end
+
 end

data/lib/attributor/types/string.rb

@@ -6,8 +6,11 @@ module Attributor
       return ::String
     end
 
-
     def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
+      if value.kind_of?(Enumerable)
+        raise IncompatibleTypeError,  context: context, value_type: value.class, type: self
+      end
+
       value && String(value)
     rescue
       super

data/lib/attributor/types/struct.rb

@@ -2,6 +2,9 @@
 module Attributor
   class Struct < Attributor::Model
     
+    def self.constructable? 
+      true
+    end
 
     # Construct a new subclass, using attribute_definition to define attributes.
     def self.construct(attribute_definition, options={})

data/lib/attributor/types/symbol.rb

@@ -0,0 +1,21 @@
+module Attributor
+  class Symbol
+    include Type
+
+    def self.native_type
+      return ::Symbol
+    end
+
+
+    def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
+      value.to_sym
+    rescue
+      super
+    end
+
+    def self.example(context=nil, options:{})
+      :example
+    end
+  end
+
+end

data/lib/attributor/version.rb

@@ -1,3 +1,3 @@
 module Attributor
-  VERSION = "2.3.0"
+  VERSION = "2.4.0"
 end

data/spec/dsl_compiler_spec.rb

@@ -110,10 +110,10 @@ describe Attributor::DSLCompiler do
           attribute_options.merge(:reference => reference_type)
         end
 
-        it 'is unhappy from somewhere else if you do not specify a type' do
-          expect {
-            dsl_compiler.attribute(attribute_name, attribute_options, &attribute_block)
-          }.to raise_error(/does not support anonymous generation/)
+        it 'sets the type of the attribute to Struct' do
+          Attributor::Attribute.should_receive(:new).
+            with(expected_type, {:description=>"The turkey", :reference=>Turkey})
+          dsl_compiler.attribute(attribute_name, attribute_options, &attribute_block)
         end
 
         it 'passes the correct reference to the created attribute' do

data/spec/support/hashes.rb

@@ -5,3 +5,10 @@ class HashWithModel < Attributor::Hash
   end
 end
 
+
+class HashWithStrings < Attributor::Hash
+  keys do
+    key :name, String
+    key :something, String
+  end
+end

data/spec/support/models.rb

@@ -42,6 +42,7 @@ end
 
 
 # http://en.wikipedia.org/wiki/Cormorant
+
 class Cormorant < Attributor::Model
   attributes do
     # This will be a collection of arbitrary Ruby Objects

data/spec/types/collection_spec.rb

@@ -147,16 +147,14 @@ describe Attributor::Collection do
       end
 
       context 'for invalid values' do
-        {
-          # FIXME: https://github.com/rightscale/attributor/issues/24
-          #::String  => ["foo", "bar"],
-          #::Object  => [::Object.new]
-          ::Chicken => [::Turkey.new]
-        }.each do |member_type, value|
-          it "raises error when member_type is #{member_type} and value is #{value.inspect}" do
-            expect { type.of(member_type).load(value).should == value }.to raise_error(Attributor::AttributorException)
-          end
+        let(:member_type) { ::Chicken }
+        let(:value) { [::Turducken.example] }
+        it "raises error when incoming value is not of member_type" do
+          expect {
+            val = type.of(member_type).load(value)
+          }.to raise_error(Attributor::AttributorException)
         end
+
       end
     end
 

data/spec/types/model_spec.rb

@@ -66,7 +66,7 @@ describe Attributor::Model do
       context 'with infinitely-expanding sub-attributes' do
         let(:model_class) do
           Class.new(Attributor::Model) do
-            this = self 
+            this = self
             attributes do
               attribute :name, String
               attribute :child, this
@@ -167,6 +167,15 @@ describe Attributor::Model do
         end
       end
 
+      context 'with an instance of different model' do
+        it 'raises some sort of error' do
+          expect {
+            turducken = Turducken.example
+            chicken = Chicken.load(turducken,context)
+          }.to raise_error(Attributor::IncompatibleTypeError, /Type Chicken cannot load values of type Turducken.*#{context.join('.')}/)
+        end
+      end
+
       context "with a hash" do
         context 'for a complete set of attributes' do
           it 'loads the given attributes' do
@@ -190,13 +199,12 @@ describe Attributor::Model do
           it 'raises an error' do
             expect {
               Chicken.load(hash, context)
-            }.to raise_error(Attributor::AttributorException, /Unknown attributes.*#{context.join('.')}/)
+            }.to raise_error(Attributor::AttributorException, /Unknown key received/)
+            #raise_error(Attributor::AttributorException, /Unknown attributes.*#{context.join('.')}/)
           end
         end
       end
 
-
-
     end
 
   end
@@ -213,7 +221,7 @@ describe Attributor::Model do
 
     context 'initialize' do
 
-      subject(:chicken) { Chicken.new( attributes_data ) }
+      subject(:chicken) { Chicken.new(attributes_data) }
       context 'supports passing an initial hash object for attribute values' do
         let(:attributes_data){ {age: '1', email:'rooster@coup.com'} }
         it 'and sets them in loaded format onto the instance attributes' do
@@ -228,23 +236,23 @@ describe Attributor::Model do
       context 'supports passing a JSON encoded data object' do
         let(:attributes_hash){ {age: 1, email:'rooster@coup.com'} }
         let(:attributes_data){ JSON.dump(attributes_hash) }
-          it 'and sets them in loaded format onto the instance attributes' do
-            Chicken.should_receive(:load).with(attributes_data).and_call_original
-            attributes_hash.keys.each do |attr_name|
-              Chicken.attributes[attr_name].should_receive(:load).with(attributes_hash[attr_name],instance_of(Array), recurse: false).and_call_original
-            end
-            subject.age.should be(1)
-            subject.email.should == attributes_hash[:email]
+        it 'and sets them in loaded format onto the instance attributes' do
+          Chicken.should_receive(:load).with(attributes_data).and_call_original
+          attributes_hash.keys.each do |attr_name|
+            Chicken.attributes[attr_name].should_receive(:load).with(attributes_hash[attr_name],instance_of(Array), recurse: false).and_call_original
           end
+          subject.age.should be(1)
+          subject.email.should == attributes_hash[:email]
         end
-        context 'supports passing a native model for the data object' do
-          let(:attributes_data){ Chicken.example }
-          it 'sets a new instance pointing to the exact same attributes (careful about modifications!)' do
-            attributes_data.attributes.each do |attr_name, attr_value|
-              subject.send(attr_name).should be(attr_value)
-            end
+      end
+      context 'supports passing a native model for the data object' do
+        let(:attributes_data){ Chicken.example }
+        it 'sets a new instance pointing to the exact same attributes (careful about modifications!)' do
+          attributes_data.attributes.each do |attr_name, attr_value|
+            subject.send(attr_name).should be(attr_value)
           end
         end
+      end
     end
 
     context 'getting and setting attributes' do

data/spec/types/string_spec.rb

@@ -56,4 +56,13 @@ describe Attributor::String do
     end
   end
 
+  context 'for Enumerable values' do
+    let(:value) { [1] }
+
+    it 'raises IncompatibleTypeError' do
+      expect {
+        type.load(value)
+      }.to raise_error(Attributor::IncompatibleTypeError)
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: attributor
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Josep M. Blanquer
@@ -257,6 +257,7 @@ files:
 - lib/attributor/attribute.rb
 - lib/attributor/attribute_resolver.rb
 - lib/attributor/dsl_compiler.rb
+- lib/attributor/example_mixin.rb
 - lib/attributor/exceptions.rb
 - lib/attributor/extensions/randexp.rb
 - lib/attributor/type.rb
@@ -276,6 +277,7 @@ files:
 - lib/attributor/types/object.rb
 - lib/attributor/types/string.rb
 - lib/attributor/types/struct.rb
+- lib/attributor/types/symbol.rb
 - lib/attributor/types/tempfile.rb
 - lib/attributor/types/time.rb
 - lib/attributor/version.rb