attributor 5.0.2 → 5.1.0

data/lib/attributor/types/container.rb

@@ -9,9 +9,8 @@ module Attributor
     end
 
     module ClassMethods
-
-      def decode_string(value, context=Attributor::DEFAULT_ROOT_CONTEXT)
-        raise "#{self.name}.decode_string is not implemented. (when decoding #{Attributor.humanize_context(context)})"
+      def decode_string(_value, context = Attributor::DEFAULT_ROOT_CONTEXT)
+        raise "#{name}.decode_string is not implemented. (when decoding #{Attributor.humanize_context(context)})"
       end
 
       # Decode JSON string that encapsulates an array
@@ -19,24 +18,19 @@ module Attributor
       # @param value [String] JSON string
       # @return [Array] a normal Ruby Array
       #
-      def decode_json(value, context=Attributor::DEFAULT_ROOT_CONTEXT)
-        raise Attributor::DeserializationError, context: context, from: value.class, encoding: "JSON" , value: value unless value.kind_of? ::String
+      def decode_json(value, context = Attributor::DEFAULT_ROOT_CONTEXT)
+        raise Attributor::DeserializationError, context: context, from: value.class, encoding: 'JSON', value: value unless value.is_a? ::String
 
         # attempt to parse as JSON
         parsed_value = JSON.parse(value)
-
-        if self.valid_type?(parsed_value)
-          value = parsed_value
-        else
-          raise Attributor::CoercionError, context: context, from: parsed_value.class, to: self.name, value: parsed_value
+        unless valid_type?(parsed_value)
+          raise Attributor::CoercionError, context: context, from: parsed_value.class, to: name, value: parsed_value
         end
-        return value
 
-      rescue JSON::JSONError => e
-        raise Attributor::DeserializationError, context: context, from: value.class, encoding: "JSON" , value: value
+        parsed_value
+      rescue JSON::JSONError
+        raise Attributor::DeserializationError, context: context, from: value.class, encoding: 'JSON', value: value
       end
-
     end
-
   end
 end

data/lib/attributor/types/csv.rb

@@ -1,8 +1,6 @@
 module Attributor
-
   class CSV < Collection
-
-    def self.decode_string(value,context)
+    def self.decode_string(value, _context)
       value.split(',')
     end
 
@@ -11,25 +9,25 @@ module Attributor
       when ::String
         values
       when ::Array
-        values.collect { |value| member_attribute.dump(value,opts).to_s }.join(',')
+        values.collect { |value| member_attribute.dump(value, opts).to_s }.join(',')
       when nil
         nil
       else
         context = opts[:context] || DEFAULT_ROOT_CONTEXT
         name =  context.last.to_s
         type = values.class.name
-        reason = "Attributor::CSV only supports dumping values of type " +
+        reason = 'Attributor::CSV only supports dumping values of type ' \
                  "Array or String, not #{values.class.name}."
-        raise DumpError.new(context: context, name: name, type: type, original_exception: reason)
+        raise DumpError, context: context, name: name, type: type, original_exception: reason
       end
     end
 
-    def self.example(context=nil, options: {})
+    def self.example(context = nil, options: {})
       collection = super(context, options: options.merge(size: (2..4)))
-      return collection.join(',')
+      collection.join(',')
     end
 
-    def self.describe(shallow=false, example: nil)
+    def self.describe(shallow = false, example: nil)
       hash = super(shallow)
       hash.delete(:member_attribute)
       hash[:example] = example if example
@@ -39,6 +37,5 @@ module Attributor
     def self.family
       Collection.family
     end
-
   end
 end

data/lib/attributor/types/date.rb

@@ -1,36 +1,31 @@
 require 'date'
 
 module Attributor
+  class Date < Temporal
+    def self.native_type
+      ::Date
+    end
 
-    class Date < Temporal
-
-      def self.native_type
-        return ::Date
-      end
+    def self.example(context = nil, options: {})
+      load(Randgen.date, context)
+    end
 
-      def self.example(context=nil, options: {})
-        return self.load(/[:date:]/.gen, context)
-      end
+    def self.load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, **_options)
+      return value if value.is_a?(native_type)
+      return nil if value.nil?
 
-      def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
-        return value if value.is_a?(self.native_type)
-        return nil if value.nil?
-        
-        return value.to_date if value.respond_to?(:to_date)
+      return value.to_date if value.respond_to?(:to_date)
 
-        case value
-        when ::String
-          begin
-            return ::Date.parse(value)
-          rescue ArgumentError => e
-            raise Attributor::DeserializationError, context: context, from: value.class, encoding: "Date" , value: value            
-          end
-        else
-          raise CoercionError, context: context, from: value.class, to: self, value: value
+      case value
+      when ::String
+        begin
+          return ::Date.parse(value)
+        rescue ArgumentError
+          raise Attributor::DeserializationError, context: context, from: value.class, encoding: 'Date', value: value
         end
+      else
+        raise CoercionError, context: context, from: value.class, to: self, value: value
       end
-
     end
-
   end
-
+end

data/lib/attributor/types/date_time.rb

@@ -5,34 +5,27 @@ require_relative '../exceptions'
 require 'date'
 
 module Attributor
-
   class DateTime < Temporal
-
     def self.native_type
-      return ::DateTime
+      ::DateTime
     end
 
-    def self.example(context=nil, options: {})
-      return self.load(/[:date:]/.gen, context)
+    def self.example(context = nil, options: {})
+      load(Randgen.date, context)
     end
 
-    def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
+    def self.load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, **_options)
       # We assume that if the value is already in the right type, we've decoded it already
-      return value if value.is_a?(self.native_type)
+      return value if value.is_a?(native_type)
       return value.to_datetime if value.respond_to?(:to_datetime)
       return nil unless value.is_a?(::String)
       # TODO: we should be able to convert not only from String but Time...etc
       # Else, we'll decode it from String.
       begin
         return ::DateTime.parse(value)
-      rescue ArgumentError => e
-        raise Attributor::DeserializationError, context: context, from: value.class, encoding: "DateTime" , value: value
+      rescue ArgumentError
+        raise Attributor::DeserializationError, context: context, from: value.class, encoding: 'DateTime', value: value
       end
     end
-
-    
-
-
   end
-
 end

data/lib/attributor/types/float.rb

@@ -2,22 +2,21 @@
 # See: http://ruby-doc.org/core-2.1.0/Float.html
 
 module Attributor
-
   class Float
     include Type
 
     def self.native_type
-      return ::Float
+      ::Float
     end
 
-    def self.example(context=nil, options: {})
+    def self.example(_context = nil, options: {})
       min = options[:min].to_f || 0.0
       max = options[:max].to_f || Math.PI
 
-      rand * (max-min) + min
+      rand * (max - min) + min
     end
 
-    def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
+    def self.load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, **options)
       Float(value)
     rescue TypeError
       super
@@ -26,6 +25,5 @@ module Attributor
     def self.family
       'numeric'
     end
-    
   end
 end

data/lib/attributor/types/hash.rb

@@ -2,10 +2,10 @@ module Attributor
   class InvalidDefinition < StandardError
     def initialize(type, cause)
       type_name = if type.name
-        type.name
-      else
-        type.inspect
-      end
+                    type.name
+                  else
+                    type.inspect
+                  end
 
       msg = "Structure definition for type #{type_name} is invalid. The following exception has occurred: #{cause.inspect}"
       super(msg)
@@ -16,7 +16,6 @@ module Attributor
   end
 
   class Hash
-
     MAX_EXAMPLE_DEPTH = 5
     CIRCULAR_REFERENCE_MARKER = '...'.freeze
 
@@ -45,13 +44,13 @@ module Attributor
     def self.key_type=(key_type)
       @key_type = Attributor.resolve_type(key_type)
       @key_attribute = Attribute.new(@key_type)
-      @concrete=true
+      @concrete = true
     end
 
     def self.value_type=(value_type)
       @value_type = Attributor.resolve_type(value_type)
       @value_attribute = Attribute.new(@value_type)
-      @concrete=true
+      @concrete = true
     end
 
     def self.family
@@ -59,16 +58,16 @@ module Attributor
     end
 
     @saved_blocks = []
-    @options = {allow_extra: false}
+    @options = { allow_extra: false }
     @keys = {}
 
     def self.inherited(klass)
-      k = self.key_type
-      v = self.value_type
+      k = key_type
+      v = value_type
 
       klass.instance_eval do
         @saved_blocks = []
-        @options = {allow_extra: false}
+        @options = { allow_extra: false }
         @keys = {}
         @key_type = k
         @value_type = v
@@ -83,7 +82,7 @@ module Attributor
     def self.attributes(**options, &key_spec)
       raise @error if @error
 
-      self.keys(options, &key_spec)
+      keys(options, &key_spec)
     end
 
     def self.keys(**options, &key_spec)
@@ -93,15 +92,15 @@ module Attributor
         @saved_blocks << key_spec
         @options.merge!(options)
       elsif @saved_blocks.any?
-        self.definition
+        definition
       end
       @keys
     end
 
     def self.definition
       opts = {
-        :key_type => @key_type,
-        :value_type => @value_type
+        key_type: @key_type,
+        value_type: @value_type
       }.merge(@options)
 
       blocks = @saved_blocks.shift(@saved_blocks.size)
@@ -109,7 +108,7 @@ module Attributor
       compiler.parse(*blocks)
 
       if opts[:case_insensitive_load] == true
-        @insensitive_map = self.keys.keys.each_with_object({}) do |k, map|
+        @insensitive_map = keys.keys.each_with_object({}) do |k, map|
           map[k.downcase] = k
         end
       end
@@ -127,7 +126,7 @@ module Attributor
     end
 
     def self.valid_type?(type)
-      type.kind_of?(self) || type.kind_of?(::Hash)
+      type.is_a?(self) || type.is_a?(::Hash)
     end
 
     # @example Hash.of(key: String, value: Integer)
@@ -146,74 +145,64 @@ module Attributor
     def self.add_requirement(req)
       @requirements << req
       return unless req.attr_names
-      non_existing = req.attr_names - self.attributes.keys
+      non_existing = req.attr_names - attributes.keys
       unless non_existing.empty?
-        raise "Invalid attribute name(s) found (#{non_existing.join(', ')}) when defining a requirement of type #{req.type} for #{Attributor.type_name(self)} ." +
-        "The only existing attributes are #{self.attributes.keys}"
+        raise "Invalid attribute name(s) found (#{non_existing.join(', ')}) when defining a requirement of type #{req.type} for #{Attributor.type_name(self)} ." \
+              "The only existing attributes are #{attributes.keys}"
       end
-
     end
 
     def self.construct(constructor_block, **options)
       return self if constructor_block.nil?
 
       unless @concrete
-        return self.of(key:self.key_type, value: self.value_type)
-        .construct(constructor_block,**options)
+        return of(key: key_type, value: value_type)
+               .construct(constructor_block, **options)
       end
 
-      if options[:case_insensitive_load] && !(self.key_type <= String)
-        raise Attributor::AttributorException.new(":case_insensitive_load may not be used with keys of type #{self.key_type.name}")
+      if options[:case_insensitive_load] && !(key_type <= String)
+        raise Attributor::AttributorException, ":case_insensitive_load may not be used with keys of type #{key_type.name}"
       end
 
-      self.keys(options, &constructor_block)
+      keys(options, &constructor_block)
       self
     end
 
-
     def self.example_contents(context, parent, **values)
-
       hash = ::Hash.new
       example_depth = context.size
 
-      self.keys.each do |sub_attribute_name, sub_attribute|
-
-
+      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
+        sub_context = generate_subcontext(context, sub_attribute_name)
+        block = proc do
           value = values.fetch(sub_attribute_name) do
             sub_attribute.example(sub_context, parent: parent)
           end
-          sub_attribute.load(value,sub_context)
-
+          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
+    def self.example(context = nil, **values)
+      return new if key_type == Object && value_type == Object && keys.empty?
 
-      context ||= ["#{Hash}-#{rand(10000000)}"]
+      context ||= ["#{Hash}-#{rand(10_000_000)}"]
       context = Array(context)
 
-      if self.keys.any?
-        result = self.new
+      if keys.any?
+        result = new
         result.extend(ExampleMixin)
 
-        result.lazy_attributes = self.example_contents(context, result, values)
+        result.lazy_attributes = example_contents(context, result, values)
       else
         hash = ::Hash.new
 
@@ -223,31 +212,27 @@ module Attributor
           hash[example_key] = value_type.example(subcontext)
         end
 
-        result = self.new(hash)
+        result = new(hash)
       end
 
       result
     end
 
-
     def self.dump(value, **opts)
-      if loaded = self.load(value)
+      if (loaded = load(value))
         loaded.dump(**opts)
-      else
-        nil
       end
     end
 
-
-    def self.check_option!(name, definition)
+    def self.check_option!(name, _definition)
       case name
       when :reference
-        :ok # FIXME ... actually do something smart
+        :ok # FIXME: ... actually do something smart
       when :dsl_compiler
         :ok
       when :case_insensitive_load
-        unless self.key_type <= String
-          raise Attributor::AttributorException, ":case_insensitive_load may not be used with keys of type #{self.key_type.name}"
+        unless key_type <= String
+          raise Attributor::AttributorException, ":case_insensitive_load may not be used with keys of type #{key_type.name}"
         end
         :ok
       when :allow_extra
@@ -257,37 +242,40 @@ module Attributor
       end
     end
 
-
-    def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, recurse: false,  **options)
+    def self.load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, recurse: false, **_options)
       context = Array(context)
 
+      return value if value.is_a?(self)
+      return nil if value.nil? && !recurse
+
+      loaded_value = self.parse(value, context)
+
+      return from_hash(loaded_value, context, recurse: recurse) if keys.any?
+      load_generic(loaded_value, context)
+    end
+
+    def self.parse(value, context)
       if value.nil?
-        if recurse
-          loaded_value = {}
-        else
-          return nil
-        end
-      elsif value.is_a?(self)
-        return value
-      elsif value.kind_of?(Attributor::Hash)
-        loaded_value = value.contents
+        {}
+      elsif value.is_a?(Attributor::Hash)
+        value.contents
       elsif value.is_a?(::Hash)
-        loaded_value = value
+        value
       elsif value.is_a?(::String)
-        loaded_value = decode_json(value,context)
+        decode_json(value, context)
       elsif value.respond_to?(:to_hash)
-        loaded_value = value.to_hash
+        value.to_hash
       else
         raise Attributor::IncompatibleTypeError, context: context, value_type: value.class, type: self
       end
+    end
 
-      return self.from_hash(loaded_value,context, recurse: recurse) if self.keys.any?
-      return self.new(loaded_value) if (key_type == Object && value_type == Object)
+    def self.load_generic(value, context)
+      return new(value) if key_type == Object && value_type == Object
 
-      loaded_value.each_with_object(self.new) do| (k, v), obj |
-        obj[self.key_type.load(k,context)] = self.value_type.load(v,context)
+      value.each_with_object(new) do |(k, v), obj|
+        obj[key_type.load(k, context)] = value_type.load(v, context)
       end
-
     end
 
     def self.generate_subcontext(context, key_name)
@@ -295,66 +283,55 @@ module Attributor
     end
 
     def generate_subcontext(context, key_name)
-      self.class.generate_subcontext(context,key_name)
+      self.class.generate_subcontext(context, key_name)
     end
 
-    def get(key, context: self.generate_subcontext(Attributor::DEFAULT_ROOT_CONTEXT,key))
+    def get(key, context: generate_subcontext(Attributor::DEFAULT_ROOT_CONTEXT, key))
       key = self.class.key_attribute.load(key, context)
 
-      if self.class.keys.empty?
-        if @contents.key? key
-          value = @contents[key]
-          loaded_value = value_attribute.load(value, context)
-          return self[key] = loaded_value
-        else
-          if self.class.options[:case_insensitive_load]
-            key = key.downcase
-            @contents.each do |k,v|
-              if key == k.downcase
-                return self.get(key, context: context)
-              end
-            end
-          end
-        end
-        return nil
-      end
-
+      return self.get_generic(key, context) if self.class.keys.empty?
       value = @contents[key]
 
       # FIXME: getting an unset value here should not force it in the hash
       if (attribute = self.class.keys[key])
         loaded_value = attribute.load(value, context)
-        if loaded_value.nil?
-          return nil
-        else
-          return self[key] = loaded_value
-        end
+        return nil if loaded_value.nil?
+        return self[key] = loaded_value
       end
 
       if self.class.options[:case_insensitive_load]
         key = self.class.insensitive_map[key.downcase]
-        return self.get(key, context: context)
+        return get(key, context: context)
       end
 
       if self.class.options[:allow_extra]
-        if self.class.extra_keys.nil?
-          return @contents[key] = self.class.value_attribute.load(value, context)
-        else
-          extra_keys_key = self.class.extra_keys
-
-          if @contents.key? extra_keys_key
-            return @contents[extra_keys_key].get(key, context: context)
-          end
+        return @contents[key] = self.class.value_attribute.load(value, context) if self.class.extra_keys.nil?
+        extra_keys_key = self.class.extra_keys
 
+        if @contents.key? extra_keys_key
+          return @contents[extra_keys_key].get(key, context: context)
         end
-      end
 
+      end
 
       raise LoadError, "Unknown key received: #{key.inspect} for #{Attributor.humanize_context(context)}"
     end
 
+    def get_generic(key, context)
+      if @contents.key? key
+        value = @contents[key]
+        loaded_value = value_attribute.load(value, context)
+        return self[key] = loaded_value
+      elsif self.class.options[:case_insensitive_load]
+        key = key.downcase
+        @contents.each do |k, _v|
+          return get(key, context: context) if key == k.downcase
+        end
+      end
+      nil
+    end
 
-    def set(key, value, context: self.generate_subcontext(Attributor::DEFAULT_ROOT_CONTEXT,key), recurse: false)
+    def set(key, value, context: generate_subcontext(Attributor::DEFAULT_ROOT_CONTEXT, key), recurse: false)
       key = self.class.key_attribute.load(key, context)
 
       if self.class.keys.empty?
@@ -367,51 +344,50 @@ module Attributor
 
       if self.class.options[:case_insensitive_load]
         key = self.class.insensitive_map[key.downcase]
-        return self.set(key, value, context: context)
+        return set(key, value, context: context)
       end
 
       if self.class.options[:allow_extra]
-        if self.class.extra_keys.nil?
-          return self[key] = self.class.value_attribute.load(value, context)
-        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
-          end
+        return self[key] = self.class.value_attribute.load(value, context) if self.class.extra_keys.nil?
 
-          return self[extra_keys_key].set(key, value, context: context)
+        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
         end
+
+        return self[extra_keys_key].set(key, value, context: context)
+
       end
 
       raise LoadError, "Unknown key received: #{key.inspect} while loading #{Attributor.humanize_context(context)}"
     end
 
-    def self.from_hash(object,context, recurse: false)
-      hash = self.new
+    def self.from_hash(object, context, recurse: false)
+      hash = new
 
       # if the hash definition includes named extra keys, initialize
       # its value from the object in case it provides some already.
       # this is to ensure it exists when we handle any extra keys
       # that may exist in the object later
-      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, recurse: recurse)
+      if extra_keys
+        sub_context = generate_subcontext(context, extra_keys)
+        v = object.fetch(extra_keys, {})
+        hash.set(extra_keys, v, context: sub_context, recurse: recurse)
       end
 
-      object.each do |k,val|
-        next if k == self.extra_keys
+      object.each do |k, val|
+        next if k == extra_keys
 
-        sub_context = self.generate_subcontext(context,k)
+        sub_context = generate_subcontext(context, k)
         hash.set(k, val, context: sub_context, recurse: recurse)
       end
 
       # handle default values for missing keys
-      self.keys.each do |key_name, attribute|
+      keys.each do |key_name, attribute|
         next if hash.key?(key_name)
-        sub_context = self.generate_subcontext(context,key_name)
+        sub_context = generate_subcontext(context, key_name)
         default = attribute.load(nil, sub_context, recurse: recurse)
         hash[key_name] = default unless default.nil?
       end
@@ -419,35 +395,32 @@ module Attributor
       hash
     end
 
-
-    def self.validate(object,context=Attributor::DEFAULT_ROOT_CONTEXT,_attribute)
+    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)}."
+      unless object.is_a?(self)
+        raise ArgumentError, "#{name} can not validate object of type #{object.class.name} for #{Attributor.humanize_context(context)}."
       end
 
       object.validate(context)
     end
 
-    def self.describe(shallow=false, example: nil)
+    def self.describe(shallow = false, example: nil)
       hash = super(shallow)
 
-      if key_type
-        hash[:key] = {type: key_type.describe(true)}
-      end
+      hash[:key] = { type: key_type.describe(true) } if key_type
 
-      if self.keys.any?
+      if keys.any?
         # Spit keys if it's the root or if it's an anonymous structures
-        if ( !shallow || self.name == nil)
+        if !shallow || name.nil?
           required_names = []
           # FIXME: change to :keys when the praxis doc browser supports displaying those
-          hash[:attributes] = self.keys.each_with_object({}) do |(sub_name, sub_attribute), sub_attributes|
+          hash[:attributes] = keys.each_with_object({}) do |(sub_name, sub_attribute), sub_attributes|
             required_names << sub_name if sub_attribute.options[:required] == true
             sub_example = example.get(sub_name) if example
             sub_attributes[sub_name] = sub_attribute.describe(true, example: sub_example)
           end
-          hash[:requirements] = self.requirements.each_with_object([]) do |req, list|
+          hash[:requirements] = requirements.each_with_object([]) do |req, list|
             described_req = req.describe(shallow)
             if described_req[:type] == :all
               # Add the names of the attributes that have the required flag too
@@ -458,11 +431,11 @@ module Attributor
           end
           # Make sure we create an :all requirement, if there wasn't one so we can add the required: true attributes
           unless required_names.empty?
-            hash[:requirements] << {type: :all, attributes: required_names }
+            hash[:requirements] << { type: :all, attributes: required_names }
           end
         end
       else
-        hash[:value] = {type: value_type.describe(true)}
+        hash[:value] = { type: value_type.describe(true) }
       end
 
       hash
@@ -479,7 +452,7 @@ module Attributor
       self[k]
     end
 
-    def []=(k,v)
+    def []=(k, v)
       @contents[k] = v
     end
 
@@ -487,7 +460,7 @@ module Attributor
       @contents.each(&block)
     end
 
-    alias_method :each_pair, :each
+    alias each_pair each
 
     def size
       @contents.size
@@ -508,14 +481,14 @@ module Attributor
     def key?(k)
       @contents.key?(k)
     end
-    alias_method :has_key?, :key?
+    alias has_key? key?
 
     def merge(h)
       case h
       when self.class
         self.class.new(contents.merge(h.contents))
       when Attributor::Hash
-        raise ArgumentError, "cannot merge Attributor::Hash instances of different types" unless h.is_a?(self.class)
+        raise ArgumentError, 'cannot merge Attributor::Hash instances of different types' unless h.is_a?(self.class)
       else
         raise TypeError, "no implicit conversion of #{h.class} into Attributor::Hash"
       end
@@ -527,7 +500,7 @@ module Attributor
 
     attr_reader :validating, :dumping
 
-    def initialize(contents={})
+    def initialize(contents = {})
       @validating = false
       @dumping = false
 
@@ -550,80 +523,82 @@ module Attributor
       self.class.value_attribute
     end
 
-
     def ==(other)
       contents == other || (other.respond_to?(:contents) ? contents == other.contents : false)
     end
 
-    def validate(context=Attributor::DEFAULT_ROOT_CONTEXT)
+    def validate(context = Attributor::DEFAULT_ROOT_CONTEXT)
       context = [context] if context.is_a? ::String
-      errors = []
 
       if self.class.keys.any?
-        extra_keys = @contents.keys - self.class.keys.keys
-        if extra_keys.any? && !self.class.options[:allow_extra]
-          return extra_keys.collect do |k|
-            "#{Attributor.humanize_context(context)} can not have key: #{k.inspect}"
-          end
+        self.validate_keys(context)
+      else
+        self.validate_generic(context)
+      end
+    end
+
+    def validate_keys(context)
+      extra_keys = @contents.keys - self.class.keys.keys
+      if extra_keys.any? && !self.class.options[:allow_extra]
+        return extra_keys.collect do |k|
+          "#{Attributor.humanize_context(context)} can not have key: #{k.inspect}"
         end
+      end
 
-        keys_with_values = Array.new
+      errors = []
+      keys_with_values = []
 
-        self.class.keys.each do |key, attribute|
-          sub_context = self.class.generate_subcontext(context,key)
+      self.class.keys.each do |key, attribute|
+        sub_context = self.class.generate_subcontext(context, key)
 
-          value = @contents[key]
-          unless value.nil?
-            keys_with_values << key
-          end
+        value = @contents[key]
+        keys_with_values << key unless value.nil?
 
-          if value.respond_to?(:validating) # really, it's a thing with sub-attributes
-            next if value.validating
-          end
-
-          errors.push(*attribute.validate(value, sub_context))
-        end
-        self.class.requirements.each do |req|
-          validation_errors = req.validate(keys_with_values, context)
-          errors.push(*validation_errors) unless validation_errors.empty?
+        if value.respond_to?(:validating) # really, it's a thing with sub-attributes
+          next if value.validating
         end
-      else
-        @contents.each do |key, value|
-          # FIXME: the sub contexts and error messages don't really make sense here
-          unless key_type == Attributor::Object
-            sub_context = context + ["key(#{key.inspect})"]
-            errors.push(*key_attribute.validate(key, sub_context))
-          end
 
-          unless value_type == Attributor::Object
-            sub_context = context + ["value(#{value.inspect})"]
-            errors.push(*value_attribute.validate(value, sub_context))
-          end
-        end
+        errors.concat attribute.validate(value, sub_context)
+      end
+      self.class.requirements.each do |requirement|
+        validation_errors = requirement.validate(keys_with_values, context)
+        errors.concat(validation_errors) unless validation_errors.empty?
       end
       errors
     end
 
+    def validate_generic(context)
+      @contents.each_with_object([]) do |(key, value), errors|
+        # FIXME: the sub contexts and error messages don't really make sense here
+        unless key_type == Attributor::Object
+          sub_context = context + ["key(#{key.inspect})"]
+          errors.concat key_attribute.validate(key, sub_context)
+        end
+
+        unless value_type == Attributor::Object
+          sub_context = context + ["value(#{value.inspect})"]
+          errors.concat value_attribute.validate(value, sub_context)
+        end
+      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)
+      contents.each_with_object({}) do |(k, v), hash|
+        k = key_attribute.dump(k, opts)
 
-        if (attribute_for_value = self.class.keys[k])
-          v = attribute_for_value.dump(v,opts)
-        else
-          v = self.value_attribute.dump(v,opts)
-        end
+        v = if (attribute_for_value = self.class.keys[k])
+              attribute_for_value.dump(v, opts)
+            else
+              value_attribute.dump(v, opts)
+            end
 
         hash[k] = v
       end
     ensure
       @dumping = false
     end
-
   end
-
 end