simple_params 1.0.3 → 1.0.4

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OGYzOTBkMWI1YTA1MmNlZThiMzZiMzE1MGQyN2NlMmM3NTc1NTMwNQ==
+    MWQxN2I0ZTRlYjM1NmFmMDc0ZGRhNDA5YWQ3ZDhjMWUzZWMzM2QzMw==
   data.tar.gz: !binary |-
-    NjExZWE4N2FiMDZhODJiNjM3M2EyNWFmM2E5Yzk4Y2RhNWM4YTk5ZQ==
+    MjA4ZmQ5NDcxMjM1OTRjNzAwZTMzM2Y3MjExMGJlZDIwNDVmY2YwZQ==
 SHA512:
   metadata.gz: !binary |-
-    MjlmNDFhNzZiMTZlNTI1MDIyZTA3NzZiOGIxNTdjYTg2MTczNTY1OWIzZDY4
-    N2VkMTM5NmU3ZDVmNWNkNzE5ZTRmOWNiMzI2OTM0MmNhYTc1NGFkMDlkMTQ1
-    N2YyOTc3MmRkMjkyNmYwMDQyY2Q4YTJlNDY0MmMzMThhNzBhM2Y=
+    YTI0YjczMDJjMTI0OGQ4NmY4ZDZkZWYwMGNhYTA5NzIyZjZjODRiMGE4ZTZi
+    NzZkZDJlY2YyMDE4YzQ3OWQ1YWE3Mjg1MDg2MjlhZTAyZTJhMTc3NTRiN2M5
+    ZGM5MTFlMTE3NjFjZDhjMDFkMjJhMjZjYTEwNTQ0NzViN2JiNWY=
   data.tar.gz: !binary |-
-    ZmQ2YTBiOWMyYTA4MWYwZmMzNDg2NGJmNTRjNjQwZGVlY2RjY2YwYmYyZGQ1
-    MzIzOGRjYjYzOGZhNTBlNjY4YWZjYjE2MWE4OGQ2MWFmOWM1YzdlNmVmZWM4
-    NmEzYjcyOGYzZDI3MjlmOGY0MjRlOTJlN2E1OGI4YzZlZjkxZjc=
+    YTY4MmRhMWRlYTQ1NmM1N2YzNmMwZjIzNTE3ZTNiZjQ3NDY0ZjhlMTI5MmI5
+    NTBiMmNjYTAxZWJiNzhkZTIxNThkMDFhMDc5NGE0OTdmYjI3ZTQ0ZmQ4ZDc0
+    Nzc4MjllNDYyZGZjNTJjM2FiNmFkNTUxMmEwNmM3ODFkODNlZmU=

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    simple_params (1.0.2)
+    simple_params (1.0.3)
       activemodel (>= 3.0, < 5.0)
       shoulda-matchers (~> 2.8)
       virtus (>= 1.0.0)

data/lib/simple_params/api_pie_doc/nested_array.rb

@@ -0,0 +1,31 @@
+module SimpleParams
+  class ApiPieDoc::NestedArray < ApiPieDoc::AttributeBase
+
+    attr_accessor :attributes
+
+    def initialize(simple_params_array)
+      super
+      self.attributes = attribute.values[0].map { |attribute| ApiPieDoc::Attribute.new(attribute) }
+      self.options ||= attribute.delete(:options) || attribute[1]
+    end
+
+    def name
+      attribute.keys.first.to_s
+    end
+
+    def to_s
+      return nil if do_not_document?
+      nested_description
+    end
+
+    private
+
+    def nested_description
+      start = "param :#{name}, Array, #{description}, #{requirement_description} do"
+      attribute_descriptors = []
+      attributes.each { |attribute| attribute_descriptors << attribute.to_s }
+      finish = "end"
+      [start, attribute_descriptors, finish].flatten.join("\n")
+    end
+  end
+end

data/lib/simple_params/api_pie_doc.rb

@@ -3,16 +3,21 @@ module SimpleParams
 
     attr_accessor :base_attributes,
                   :nested_hashes,
+                  :nested_arrays,
                   :nested_attributes,
+                  :nested_array_attributes,
                   :docs
 
     def initialize(simple_params)
       self.base_attributes = simple_params.defined_attributes
       self.nested_hashes = simple_params.nested_hashes
+      self.nested_arrays = simple_params.nested_arrays
       self.nested_attributes = []
+      self.nested_array_attributes = []
       self.docs = []
 
       build_nested_attributes
+      build_nested_array_attributes
     end
 
     def build
@@ -24,6 +29,10 @@ module SimpleParams
         docs << NestedAttribute.new(nested_attribute).to_s
       end
 
+      nested_array_attributes.each do |nested_attribute|
+        docs << NestedArray.new(nested_attribute).to_s
+      end
+
       docs.join("\n")
     end
 
@@ -34,5 +43,11 @@ module SimpleParams
         nested_attributes << { name => parameter_set.defined_attributes, options: parameter_set.options }
       end
     end
+
+    def build_nested_array_attributes
+      nested_arrays.each do |name, parameter_set|
+        nested_array_attributes << { name => parameter_set.defined_attributes, options: parameter_set.options }
+      end
+    end
   end
 end

data/lib/simple_params/errors.rb

@@ -2,14 +2,23 @@ require "active_model"
 
 module SimpleParams
   class Errors < ActiveModel::Errors
+    attr_reader :base
 
-    def initialize(base, nested_attributes = [])
+    def initialize(base, nested_hash_errors = {}, nested_array_errors = {})
       super(base)
-      @nested_attributes = symbolize_nested(nested_attributes)
+      @base = base
+      @nested_hash_errors = symbolize_nested(nested_hash_errors)
+      @nested_array_errors = symbolize_nested(nested_array_errors)
     end
 
     def [](attribute)
-      get(attribute.to_sym) || reset_attribute(attribute.to_sym)
+      if is_a_nested_hash_error_attribute?(attribute)
+        set(attribute.to_sym, @nested_hash_errors[attribute.to_sym])
+      elsif is_a_nested_array_error_attribute?(attribute)
+        set(attribute.to_sym, @nested_array_errors[attribute.to_sym])
+      else
+        get(attribute.to_sym) || set(attribute.to_sym, [])
+      end
     end
 
     def []=(attribute, error)
@@ -28,26 +37,18 @@ module SimpleParams
 
     def clear
       super
-      @nested_attributes.each do |attribute|
-        if fetch_nested_attribute(attribute).present?
-          fetch_nested_attribute(attribute).errors.clear
-        end
-      end
+      @nested_hash_errors.map { |attribute, errors| errors.clear }
     end
 
     def empty?
       super &&
-      @nested_attributes.all? do |attribute|
-        if fetch_nested_attribute(attribute).present?
-          fetch_nested_attribute(attribute).errors.empty?
-        end
-      end
+      @nested_hash_errors.all? { |attribute, errors| errors.empty? }
     end
     alias_method :blank?, :empty? 
 
     def include?(attribute)
-      if fetch_nested_attribute(attribute)
-        !fetch_nested_attribute(attribute).errors.empty?
+      if is_a_nested_hash_error_attribute?(attribute)
+        !@nested_hash_errors[attribute.to_sym].empty?
       else
         messages[attribute].present?
       end
@@ -57,21 +58,16 @@ module SimpleParams
 
     def values
       messages.values +
-      @nested_attributes.map do |attribute|
-        if fetch_nested_attribute(attribute).present?
-          fetch_nested_attribute(attribute).errors.values
-        end
+      @nested_hash_errors.map do |attribute, errors|
+        errors.values
       end
     end
 
     def full_messages
       parent_messages = map { |attribute, message| full_message(attribute, message) }
-      nested_messages = @nested_attributes.map do |attribute|
-        if fetch_nested_attribute(attribute)
-          messages = fetch_nested_attribute(attribute).errors.full_messages
-          messages.map do |message|
-            "#{attribute} " + message
-          end
+      nested_messages = @nested_hash_errors.map do |attribute, errors|
+        unless errors.full_messages.nil?
+          errors.full_messages.map { |message| "#{attribute} " + message }
         end
       end
       (parent_messages + nested_messages).flatten
@@ -88,10 +84,10 @@ module SimpleParams
         self.messages.dup
       end
 
-      @nested_attributes.map do |attribute|
-        errors = nested_error_messages(attribute, full_messages)
+      @nested_hash_errors.map do |attribute, errors|
+        error_messages = nested_error_messages(attribute, full_messages)
         unless errors.empty?
-          messages.merge!(attribute.to_sym => errors)
+          messages.merge!(attribute.to_sym => error_messages)
         end
       end
       messages
@@ -104,14 +100,14 @@ module SimpleParams
 
     private
     def nested_error_messages(attribute, full_messages = false)
-      if fetch_nested_attribute(attribute)
-        if full_messages
-          errors = fetch_nested_attribute(attribute).errors
+      if is_a_nested_hash_error_attribute?(attribute)
+        errors = @nested_hash_errors[attribute.to_sym]
+        if full_messages          
           errors.messages.each_with_object({}) do |(attr, array), messages|
             messages[attr] = array.map { |message| errors.full_message(attr, message) }
           end
         else
-          fetch_nested_attribute(attribute).errors.messages.dup
+          errors.messages.dup
         end
       else
         {}
@@ -119,29 +115,23 @@ module SimpleParams
     end
 
     def add_error_to_attribute(attribute, error)
-      if fetch_nested_attribute(attribute)
-        fetch_nested_attribute(attribute).errors[:base] = error
+      if is_a_nested_hash_error_attribute?(attribute)
+        @nested_hash_errors[attribute.to_sym][:base] = error
       else
         self[attribute] << error
       end
     end
 
-    def reset_attribute(attribute)
-      if fetch_nested_attribute(attribute)
-        set(attribute.to_sym, fetch_nested_attribute(attribute).errors) 
-      else
-        set(attribute.to_sym, [])
-      end
+    def is_a_nested_hash_error_attribute?(attribute)
+      @nested_hash_errors.keys.include?(attribute.to_sym)
     end
 
-    def fetch_nested_attribute(attribute)
-      if @nested_attributes.include?(attribute)
-        @base.send(attribute)
-      end
+    def is_a_nested_array_error_attribute?(attribute)
+      @nested_array_errors.keys.include?(attribute.to_sym)
     end
 
     def symbolize_nested(nested)
-      nested.map { |x| x.to_sym }
+      nested.inject({}) { |memo,(k,v) | memo[k.to_sym] = v; memo }
     end
   end
 end

data/lib/simple_params/params.rb

@@ -5,6 +5,7 @@ module SimpleParams
   class Params
     include Virtus.model
     include ActiveModel::Validations
+    extend ActiveModel::Naming
     include SimpleParams::Validations
 
     TYPES = [
@@ -31,6 +32,10 @@ module SimpleParams
 
       attr_accessor :strict_enforcement, :options
 
+      def model_name
+        ActiveModel::Name.new(self)
+      end
+
       def api_pie_documentation
         SimpleParams::ApiPieDoc.new(self).build
       end
@@ -61,11 +66,22 @@ module SimpleParams
         @nested_hashes ||= {}
       end
 
+      def nested_array(name, opts={}, &block)
+        attr_accessor name
+        nested_array_class = define_nested_class(name, opts, &block)
+        @nested_arrays ||= {}
+        @nested_arrays[name.to_sym] = nested_array_class
+      end
+
+      def nested_arrays
+        @nested_arrays ||= {}
+      end
+
       def defined_attributes
         @define_attributes ||= {}
       end
-      private
 
+      private
       def define_attribute(name, opts = {})
         opts[:type] ||= :string
         defined_attributes[name.to_sym] = opts
@@ -103,12 +119,10 @@ module SimpleParams
       def define_nested_class(name, options, &block)
         klass_name = name.to_s.split('_').collect(&:capitalize).join
         Class.new(Params).tap do |klass|
-          # def self.model_name 
-          #   ActiveModel::Name.new(self)
-          # end
+          self.const_set(klass_name, klass)
+          extend ActiveModel::Naming
           klass.class_eval(&block)
           klass.class_eval("self.options = #{options}")
-          self.const_set(klass_name, klass)
         end
       end
     end
@@ -124,13 +138,16 @@ module SimpleParams
       @original_params = hash_to_symbolized_hash(params)
       define_attributes(@original_params)
 
-      # Errors
+      # Nested Hashes
       @nested_params = nested_hashes.keys
-      @errors = SimpleParams::Errors.new(self, @nested_params)
+
+      # Nested Arrays
+      @nested_arrays = nested_arrays.keys
 
       # Nested Classes
       set_accessors(params)
       initialize_nested_classes
+      initialize_nested_array_classes
     end
 
     def define_attributes(params)
@@ -140,7 +157,7 @@ module SimpleParams
     end
 
     def attributes
-      (defined_attributes.keys + nested_hashes.keys).flatten
+      (defined_attributes.keys + nested_hashes.keys + nested_arrays.keys).flatten
     end
 
     def original_params
@@ -151,9 +168,6 @@ module SimpleParams
 
     def to_hash
       hash = {}
-      # self.class.defined_attributes.each_pair do |key, opts|
-      #   hash[key.to_sym] = send(key)
-      # end
       attributes.each do |attribute|
         if send(attribute).is_a?(SimpleParams::Params)
           hash[attribute] = send(attribute).to_hash
@@ -165,6 +179,20 @@ module SimpleParams
       hash
     end
 
+    def errors
+      nested_errors_hash = {}
+      @nested_params.each do |param|
+        nested_errors_hash[param.to_sym] = send(param).errors
+      end
+
+      nested_arrays_hash = {}
+      @nested_arrays.each do |array|
+        nested_arrays_hash[array.to_sym] = send(array).map(&:errors)
+      end
+
+      @errors ||= SimpleParams::Errors.new(self, nested_errors_hash, nested_arrays_hash)
+    end
+
     # Overriding this method to allow for non-strict enforcement!
     def method_missing(method_name, *arguments, &block)
       if strict_enforcement?
@@ -197,7 +225,7 @@ module SimpleParams
     def set_accessors(params={})
       params.each do |attribute_name, value|
         # Don't set accessors for nested classes
-        unless value.is_a?(Hash)
+        unless value.is_a?(Hash) 
           send("#{attribute_name}=", value)
         end
       end
@@ -226,6 +254,10 @@ module SimpleParams
       self.class.nested_hashes
     end
 
+    def nested_arrays
+      self.class.nested_arrays
+    end
+
     def initialize_nested_classes
       nested_hashes.each do |key, klass|
         initialization_params = @original_params[key.to_sym] || {}
@@ -233,6 +265,17 @@ module SimpleParams
       end
     end
 
+    def initialize_nested_array_classes
+      nested_arrays.each do |key, klass|
+        initialization_params = @original_params[key.to_sym] || []
+        initialization_array = []
+        initialization_params.each do |initialization_param|
+          initialization_array << klass.new(initialization_param, self)
+        end
+        send("#{key}=", initialization_array)
+      end
+    end
+
     def define_anonymous_class(name, hash)
       klass_name = name.to_s.split('_').collect(&:capitalize).join
       anonymous_klass = Class.new(Params).tap do |klass|

data/lib/simple_params/validations.rb

@@ -14,6 +14,11 @@ module SimpleParams
         nested_class = send("#{key}") 
         nested_class.valid?
       end
+
+      nested_arrays.each do |key, array|
+        nested_array = send("#{key}") 
+        nested_array.each { |a| a.valid? }
+      end
       errors.empty?
     ensure
       self.validation_context = current_context

data/lib/simple_params/version.rb

@@ -1,3 +1,3 @@
 module SimpleParams
-  VERSION = "1.0.3"
+  VERSION = "1.0.4"
 end

data/lib/simple_params.rb

@@ -9,6 +9,7 @@ require 'simple_params/type_mappings'
 require 'simple_params/api_pie_doc'
 require 'simple_params/api_pie_doc/attribute_base'
 require 'simple_params/api_pie_doc/attribute'
+require 'simple_params/api_pie_doc/nested_array'
 require 'simple_params/api_pie_doc/nested_attribute'
 require 'simple_params/validation_matchers/validation_matcher'
 require 'simple_params/validation_matchers/coercion_matcher'

data/spec/acceptance_spec.rb

@@ -6,6 +6,7 @@ class AcceptanceParams < SimpleParams::Params
   param :name
   param :age, type: :integer, optional: true, validations: { inclusion: { in: 18..100 } }
   param :color, default: "red", validations: { inclusion: { in: ["red", "green"] }}
+  param :sibling_names, type: :array, optional: true
   validate :name_has_letters
 
   nested_hash :address do
@@ -16,6 +17,11 @@ class AcceptanceParams < SimpleParams::Params
     param :company, optional: true
   end
 
+  nested_array :dogs do
+    param :name
+    param :age, type: :integer, validations: { inclusion: { in: 1..20 } }
+  end
+
   def name_has_letters
     if name.present? && !(name =~ /^[a-zA-Z]*$/)
       errors.add(:name, "must only contain letters")
@@ -59,13 +65,15 @@ describe SimpleParams::Params do
         name: "Tom", 
         age: nil,
         color: "red",
+        sibling_names: nil,
         address: { 
           street: "1 Main St.",
           city: nil,
           zip_code: nil,
           state: "North Carolina",
           company: nil
-        }
+        },
+        dogs: []
       })
     end
   end
@@ -135,7 +143,7 @@ describe SimpleParams::Params do
   describe "attributes", attributes: true do
     it "returns array of attribute symbols" do
       params = AcceptanceParams.new
-      params.attributes.should eq([:reference, :name, :age, :color, :address])
+      params.attributes.should eq([:reference, :name, :age, :color, :sibling_names, :address, :dogs])
     end
 
     it "returns array of attribute symbols for nested class" do
@@ -305,6 +313,7 @@ describe SimpleParams::Params do
         param :name, String, desc: '', required: true
         param :age, Integer, desc: '', required: false
         param :color, String, desc: '', required: false
+        param :sibling_names, Array, desc: '', required: false
         param :address, Hash, desc: '', required: true do
           param :street, String, desc: '', required: true
           param :city, String, desc: '', required: true
@@ -312,6 +321,10 @@ describe SimpleParams::Params do
           param :state, String, desc: '', required: false
           param :company, String, desc: '', required: false
         end
+        param :dogs, Array, desc: '', required: true do
+          param :name, String, desc: '', required: true
+          param :age, Integer, desc: '', required: true
+        end
       API_PIE_DOCS
 
       expect(documentation).to be_a String

data/spec/api_pie_doc/nested_array_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe SimpleParams::ApiPieDoc::NestedArray do
+
+  let(:simple_param_attribute) {
+    {:address=>
+      {:street=>{:type=>:string},
+       :city=>{:validations=>{:length=>{:in=>4..40}, :presence=>true}, :type=>:string},
+       :zip_code=>{:optional=>true, :type=>:string},
+       :state=>{:default=>"North Carolina", :type=>:string}
+      },
+    :options=>{desc: 'i like pie'}
+    }
+  }
+  let(:nested_attribute) { described_class.new(simple_param_attribute) }
+
+  it_behaves_like 'a base attribute'
+
+  describe '#initialize' do
+    specify 'should give instance an attribute' do
+      expect(nested_attribute.attribute).to eq simple_param_attribute
+    end
+
+    specify 'should give instance options' do
+      expect(nested_attribute.options).to eq({ desc: 'i like pie' })
+    end
+  end
+
+  describe '#name' do
+    specify 'should set respond with the right name' do
+      expect(nested_attribute.name).to eq 'address'
+    end
+  end
+
+  describe '#options' do
+    specify 'should return nested attribute options' do
+      expect(nested_attribute.options).to eq({desc: 'i like pie'})
+    end
+  end
+
+  describe '#to_s' do
+    specify 'should return properly formatted string' do
+      expect(nested_attribute.to_s).to eq("param :address, Array, desc: 'i like pie', required: true do\nparam :street, String, desc: '', required: true\nparam :city, String, desc: '', required: true\nparam :zip_code, String, desc: '', required: false\nparam :state, String, desc: '', required: false\nend")
+    end
+  end
+end

data/spec/api_pie_doc_spec.rb

@@ -16,17 +16,31 @@ describe SimpleParams::ApiPieDoc do
       expect(api_pie_doc.nested_hashes.keys).to eq [:address, :phone]
     end
 
+    specify "should give object nested_arrays" do
+      expect(api_pie_doc.nested_arrays.keys).to eq [:dogs]
+    end
+
     specify "should call #build_nested_attributes" do
       expect_any_instance_of(SimpleParams::ApiPieDoc).to receive(:build_nested_attributes)
       api_pie_doc
     end
 
+    specify "should call #build_nested_array_attributes" do
+      expect_any_instance_of(SimpleParams::ApiPieDoc).to receive(:build_nested_array_attributes)
+      api_pie_doc
+    end
+
     specify "should give object nested_attributes" do
       expect(api_pie_doc.nested_attributes.flat_map(&:keys)).to include(:address, :phone)
       expect(api_pie_doc.nested_attributes[0].values.flat_map(&:keys)).to eq [:street, :city, :zip_code, :state]
       expect(api_pie_doc.nested_attributes[1].values.flat_map(&:keys)).to eq [:cell_phone, :phone_number, :area_code]
     end
 
+    specify "should give object nested_array_attributes" do
+      expect(api_pie_doc.nested_array_attributes.flat_map(&:keys)).to include(:dogs)
+      expect(api_pie_doc.nested_array_attributes[0].values.flat_map(&:keys)).to eq [:name, :age]
+    end
+
     specify "should give object docs" do
       expect(api_pie_doc.docs).to eq []
     end

data/spec/errors_spec.rb

@@ -4,7 +4,10 @@ describe SimpleParams::Errors do
   class Person
     extend ActiveModel::Naming
     def initialize
-      @errors = SimpleParams::Errors.new(self, ["dog"])
+      @errors = SimpleParams::Errors.new(self, 
+        { dog: dog.errors }, 
+        { cats: cats_errors }, 
+      )
     end
 
     attr_accessor :name, :age
@@ -14,6 +17,14 @@ describe SimpleParams::Errors do
       @dog ||= Dog.new
     end
 
+    def cats
+      @cats ||= [Cat.new]
+    end
+
+    def cats_errors
+      cats.map { |cat| cat.errors }
+    end
+
     def read_attribute_for_validation(attr)
       send(attr)
     end
@@ -49,7 +60,30 @@ describe SimpleParams::Errors do
     end
   end
 
-  describe "setting and getting errors" do
+  class Cat
+    extend ActiveModel::Naming
+    def initialize
+      @errors = SimpleParams::Errors.new(self)
+    end
+
+    attr_accessor :name
+    attr_accessor :age
+    attr_reader   :errors
+
+    def read_attribute_for_validation(attr)
+      send(attr)
+    end
+
+    def self.human_attribute_name(attr, options = {})
+      attr
+    end
+
+    def self.lookup_ancestors
+      [self]
+    end
+  end
+
+  describe "setting and getting errors", setters_getters: true do
     it "get returns the errors for the provided key" do
       errors = SimpleParams::Errors.new(self)
       errors[:foo] = "omg"
@@ -105,7 +139,7 @@ describe SimpleParams::Errors do
     end
   end
 
-  describe "setting and getting nested error model" do
+  describe "setting and getting nested error model", nested_model: true do
     it "can access error model" do
       person = Person.new
       dog = person.dog
@@ -152,7 +186,55 @@ describe SimpleParams::Errors do
     end
   end
 
-  describe "#clear" do
+  describe "setting and getting nested array error model", nested_array: true do
+    it "can access error model" do
+      person = Person.new
+      cats = person.cats
+      cat_errors = cats.first.errors
+      person.errors[:cats][0].should eq(cat_errors)
+    end
+
+    it "can add to nested errors through []", failing: true do
+      person = Person.new
+      person.errors[:cats].first[:base] = 'should not be nil' 
+      person.errors[:cats].first[:base].should eq(['should not be nil']) 
+      person.cats.first.errors[:base].should eq(['should not be nil'])
+    end
+
+    it "can add to nested errors through add" do
+      person = Person.new
+      person.errors[:cats].first.add(:age, 'should not be nil')
+      person.cats.first.errors[:age].should eq(['should not be nil'])
+    end
+
+    it "can add multiple errors to nested errors through []" do
+      person = Person.new
+      person.errors[:cats].first[:name] = 'should not be nil'
+      person.errors[:cats].first[:name] = 'must be cute'
+      person.cats.first.errors[:name].should eq(['should not be nil', 'must be cute'])
+    end
+
+    it "can add multiple errors to nested errors through add" do
+      person = Person.new
+      person.errors[:cats].first.add(:name, 'should not be nil')
+      person.errors[:cats].first.add(:name, 'must be cute')
+      person.cats.first.errors[:name].should eq(['should not be nil', 'must be cute'])
+    end
+
+    it "can add individual errors to nested attributes through []" do
+      person = Person.new
+      person.errors[:cats][0][:age] = 'should not be nil'
+      person.cats.first.errors[:age].should eq(['should not be nil'])
+    end
+
+    it "can add individual errors to nested attributes through add" do
+      person = Person.new
+      person.errors[:cats].first.add(:age, 'should not be nil')
+      person.cats.first.errors[:age].should eq(['should not be nil'])
+    end
+  end
+
+  describe "#clear", clear: true do
     it "clears errors" do
       person = Person.new
       person.errors[:name] = 'should not be nil'
@@ -173,7 +255,7 @@ describe SimpleParams::Errors do
     end
   end
 
-  describe "#empty?, #blank?, and #include?" do
+  describe "#empty?, #blank?, and #include?", empty: true do
     it "is empty without any errors" do
       person = Person.new
       person.errors.should be_empty
@@ -201,7 +283,7 @@ describe SimpleParams::Errors do
     end
   end
 
-  describe "#added?" do
+  describe "#added?", added: true do
     it "added? detects if a specific error was added to the object" do
       person = Person.new
       person.errors.add(:name, "can not be blank")
@@ -246,7 +328,7 @@ describe SimpleParams::Errors do
     end    
   end
 
-  describe "#size" do
+  describe "#size", size: true do
     it "size calculates the number of error messages" do
       person = Person.new
       person.errors.add(:name, "can not be blank")
@@ -260,7 +342,7 @@ describe SimpleParams::Errors do
     end
   end
 
-  describe "#to_a" do
+  describe "#to_a", to_a: true do
     it "to_a returns the list of errors with complete messages containing the attribute names" do
       person = Person.new
       person.errors.add(:name, "can not be blank")
@@ -276,7 +358,7 @@ describe SimpleParams::Errors do
     end
   end
 
-  describe "#to_s" do
+  describe "#to_s", to_s: true do
     it "to_a returns the list of errors with complete messages containing the attribute names" do
       person = Person.new
       person.errors.add(:name, "can not be blank")
@@ -292,8 +374,8 @@ describe SimpleParams::Errors do
     end
   end
 
-  describe "#to_hash" do
-    it "to_hash returns the error messages hash" do
+  describe "#to_hash", to_hash: true do
+    it "to_hash returns the error messages hash", hash_failing: true do
       person = Person.new
       person.errors.add(:name, "can not be blank")
       person.errors.to_hash.should eq({ name: ["can not be blank"] })
@@ -328,7 +410,7 @@ describe SimpleParams::Errors do
     end
   end
 
-  describe "#as_json" do
+  describe "#as_json", as_json: true do
     it "as_json creates a json formatted representation of the errors hash" do
       person = Person.new
       person.errors[:name] = 'can not be nil'
@@ -368,7 +450,7 @@ describe SimpleParams::Errors do
     end
   end
 
-  describe "#full_messages" do
+  describe "#full_messages", full_messages: true do
     it "full_messages creates a list of error messages with the attribute name included" do
       person = Person.new
       person.errors.add(:name, "can not be blank")
@@ -408,7 +490,7 @@ describe SimpleParams::Errors do
     end
   end
 
-  describe "#generate_message" do
+  describe "#generate_message", generate_message: true do
     it "generate_message works without i18n_scope" do
       person = Person.new
       Person.should_not respond_to(:i18n_scope)
@@ -418,7 +500,7 @@ describe SimpleParams::Errors do
     end
   end
 
-  describe "#adds_on_empty" do
+  describe "#adds_on_empty", add_on_empty: true do
     it "add_on_empty generates message" do
       person = Person.new
       person.errors.should_receive(:generate_message).with(:name, :empty, {})
@@ -446,7 +528,7 @@ describe SimpleParams::Errors do
     end
   end
 
-  describe "#adds_on_blank" do
+  describe "#adds_on_blank", add_on_blank: true do
     it "add_on_blank generates message" do
       person = Person.new
       person.errors.should_receive(:generate_message).with(:name, :blank, {})

data/spec/fixtures/dummy_params.rb

@@ -27,6 +27,11 @@ class DummyParams < SimpleParams::Params
     }
   end
 
+  nested_array :dogs do
+    param :name
+    param :age, type: :integer, validations: { inclusion: { in: 1..20 } }
+  end
+
   def lower_case_colors(val)
     val.downcase
   end

data/spec/params_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'fixtures/dummy_params'
 
 describe SimpleParams::Params do
-  describe "strict parameter enforcement" do
+  describe "strict parameter enforcement", param_enforcement: true do
     context "with default handling (strict enforcement)" do
       it "raises error on expected param" do
         expect { DummyParams.new(other_param: 1) }.to raise_error(SimpleParamsError)
@@ -67,12 +67,26 @@ describe SimpleParams::Params do
         params.address.zip_code.should eq("20165")
       end
     end
+
+    describe "nested arrays", nested: true do
+      it "can access nested arrays as arrays" do
+        params.dogs.should respond_to(:first)
+        params.dogs.first.should be_nil
+      end
+
+      it "can access nested arrays as arrays with data", failing: true do
+        params = DummyParams.new(dogs: [{ name: "Spot", age: 20 }])
+        params.dogs.should respond_to(:first)
+        params.dogs.first.should_not be_nil
+        params.dogs.first.name.should eq("Spot")
+      end
+    end
   end
 
   describe "attributes", attributes: true do
     it "returns array of attribute symbols" do
       params = DummyParams.new
-      params.attributes.should eq([:name, :age, :first_initial, :amount, :color, :height, :address, :phone])
+      params.attributes.should eq([:name, :age, :first_initial, :amount, :color, :height, :address, :phone, :dogs])
     end
   end
 
@@ -123,7 +137,40 @@ describe SimpleParams::Params do
     end
   end
 
-  describe "optional params with inclusion" do
+  describe "validations", validations: true do
+    let(:params) do
+      DummyParams.new(
+        name: nil,
+        age: 30,
+        address: {
+          city: "Greenville"
+        },
+        dogs: [
+          { name: "Spot", age: 12 },
+          { age: 14 }
+        ]
+      )
+    end
+
+    it "validates required params" do
+      params.should_not be_valid
+      params.errors[:name].should eq(["can't be blank"])
+    end
+
+    it "validates nested params" do
+      params.should_not be_valid
+      params.address.errors[:street].should eq(["can't be blank"])
+      params.errors[:address][:street].should eq(["can't be blank"])
+    end
+
+    it "validates nested arrays" do
+      params.should_not be_valid
+      params.errors[:dogs][0][:name].should eq([])
+      params.errors[:dogs][1][:name].should eq(["can't be blank"])
+    end
+  end
+
+  describe "optional params with inclusion", optional_params: true do
     let(:params) do
       DummyParams.new(
         name: "Bill",
@@ -311,7 +358,7 @@ describe SimpleParams::Params do
   end
 
   describe "api_pie_documentation", api_pie_documentation: true do
-    it "generates valida api_pie documentation" do
+    it "generates valid api_pie documentation" do
       documentation = DummyParams.api_pie_documentation
       api_docs = <<-API_PIE_DOCS
                   param :name, String, desc: '', required: true
@@ -331,6 +378,10 @@ describe SimpleParams::Params do
                     param :phone_number, String, desc: '', required: true
                     param :area_code, String, desc: '', required: false
                   end
+                  param :dogs, Array, desc: '', required: true do
+                    param :name, String, desc: '', required: true
+                    param :age, Integer, desc: '', required: true
+                  end
                 API_PIE_DOCS
 
       expect(documentation).to be_a String

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_params
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - brycesenz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-23 00:00:00.000000000 Z
+date: 2015-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -131,6 +131,7 @@ files:
 - lib/simple_params/api_pie_doc.rb
 - lib/simple_params/api_pie_doc/attribute.rb
 - lib/simple_params/api_pie_doc/attribute_base.rb
+- lib/simple_params/api_pie_doc/nested_array.rb
 - lib/simple_params/api_pie_doc/nested_attribute.rb
 - lib/simple_params/attribute.rb
 - lib/simple_params/errors.rb
@@ -149,6 +150,7 @@ files:
 - simple_params.gemspec
 - spec/acceptance_spec.rb
 - spec/api_pie_doc/attribute_spec.rb
+- spec/api_pie_doc/nested_array_spec.rb
 - spec/api_pie_doc/nested_attribute_spec.rb
 - spec/api_pie_doc_spec.rb
 - spec/attribute_spec.rb
@@ -191,6 +193,7 @@ summary: A DSL for specifying params, including type coercion and validation
 test_files:
 - spec/acceptance_spec.rb
 - spec/api_pie_doc/attribute_spec.rb
+- spec/api_pie_doc/nested_array_spec.rb
 - spec/api_pie_doc/nested_attribute_spec.rb
 - spec/api_pie_doc_spec.rb
 - spec/attribute_spec.rb