simple_params 1.6.4 → 1.6.5

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MTM0ZTQ4ZDljMTUxYmJhMWIwMjg3OWRjNWZmYzJjYTgwYmJlNmE4Yg==
+    YWNlZDM0YjZkNWQxNjhhOGRjZDJjMWJiMzBiMTU1NGQ3ZjljNTZmMQ==
   data.tar.gz: !binary |-
-    ODM2NGY2NGU2MTVkMTIzMjdhNWY4YjJmYzI2NGVjYTliMDJjMTQ3Mw==
+    MTExMDdjMmE1MWJkOWEzNWJkOWEyOTg5MThmMWQ5ZTNhNjRiY2U5YQ==
 SHA512:
   metadata.gz: !binary |-
-    MDI0ZjU1YmQwNGUyMWIwYWZkYjQwZjgwYjgxMWM1OTI4N2E3ZjYzOGI1Mzhk
-    M2UxODE5YzFiNjhkNTkxNDM3NGVmNmQ1ODVkNjAxYmI0NDFiYjFhOWQzOTc3
-    YjdiMTJlMGZlNzYwYzA0ZmQ1MDJkZTRiYTRkNGUwMDViNmJkY2M=
+    YmY4ZDg1NjFjNDYxNTBjZGRhNDhkMTBjNGI3Y2RmOTEyZWExYWVjZmQ0OWQz
+    YTBiNzBhMjY4N2NlYzgyNmQwNTg0MjQxZGNkMmU5ZDNkOWI5MDhiY2VhZTg3
+    ZmE5MTYxMThjNWU1OTBiZTk2MGVkNTJiZjBlNzNiYWIyM2YxN2Y=
   data.tar.gz: !binary |-
-    M2UyNTA3ODk3ZTk4NDY3NmM4MTIyNDMwNmZiNzc2NDM2MTAyZjY0MTNlMmFj
-    OGRlMGVjOTgyZDcxODJlNmYxMTUxMzAyZjU1OGIyYzNhODFhMDE1YTBmN2Nk
-    MGQ2YjIwNzkyYjA0ZGEyOWE5NjA2NTU4NmYzMGJiYWU0YmRjYmE=
+    ZjVkZTVmNWRlZWJmNzVhOWI3ZWE5NDllMDg2NGZlZWQzYWJlMmFiZTlkOTc1
+    NWJhZTdjNGE2MTQ4NDk5YjdhZTFiYjlhOTc4OWYyZTg2Y2EzNjg2Y2U5ZDFm
+    ZDJiZmFkNGVlZmU3OGU4MzU0NTczYjZmNjg0NjU5YTEwYTA1OWQ=

data/Gemfile.lock

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

data/lib/simple_params/concerns/rails_helpers.rb

@@ -64,7 +64,7 @@ module SimpleParams
         # TODO: This needs more testing
         singular_key = singularized_key(name)
         define_method("build_#{singular_key}") do |value={}|
-          klass.new(value, self, name)
+          klass.new(value, self)
         end
       end
 

data/lib/simple_params/concerns/validations.rb

@@ -23,19 +23,10 @@ module SimpleParams
 
     private
     def nested_classes_valid?
-      nested_classes.map do |key, array|
-        nested_class_valid?(send("#{key}") )
-      end.all?
-    end
-
-    def nested_class_valid?(nested_class)
-      if nested_class.is_a?(Array)
-        # Have to map? & THEN all?, or else it won't
-        #  necessarily call valid? on every object
-        nested_class.map { |klass| klass.nil? || klass.valid? }.all?
-      else
-        nested_class.nil? || nested_class.valid?
-      end
+      # Need to map them, THEN call all?, otherwise validations won't get run
+      # on every nested class
+      validations = all_nested_classes.map { |klass| klass.valid? }
+      validations.all?
     end
   end
 end

data/lib/simple_params/errors.rb

@@ -4,10 +4,11 @@ module SimpleParams
   class Errors < ActiveModel::Errors
     attr_reader :base
 
-    def initialize(base, nested_classes = {})
+    def initialize(base, nested_classes = {}, nested_classes_array = [])
       super(base)
       @base = base
       @nested_classes = symbolize_nested(nested_classes)
+      @nested_classes_array = nested_classes_array
     end
 
     def [](attribute)
@@ -98,11 +99,6 @@ module SimpleParams
       @nested_classes.keys.include?(attribute.to_sym)
     end
 
-    def set_nested(attribute)
-      klass = nested_class(attribute)
-      errors = run_or_mapped_run(klass) { |k| k.errors if k.present? }
-      set(attribute.to_sym, errors)
-    end
 
     def add_error_to_attribute(attribute, error)
       if nested_attribute?(attribute)
@@ -138,6 +134,11 @@ module SimpleParams
       nested.inject({}) { |memo,(k,v) | memo[k.to_sym] = v; memo }
     end
 
+    def set_nested(attribute)
+      klass = nested_class(attribute)
+      errors = run_or_mapped_run(klass) { |k| k.errors if k.present? }
+      set(attribute.to_sym, errors)
+    end
 
     def nested_instances
       array =[]

data/lib/simple_params/nested_class_list.rb

@@ -0,0 +1,46 @@
+module SimpleParams
+  class NestedClassList
+    attr_reader :parent
+
+    def initialize(parent)
+      @parent = parent
+    end
+
+    def to_hash
+      nested_class_hash
+    end
+
+    def get_class_key(klass)
+      nested_class_hash.each do |key, value|
+        if value.is_a?(Array)
+          return key if value.include?(klass)
+        else
+          return key if value == klass
+        end
+      end
+    end
+
+    def class_instances
+      nested_class_hash.each_pair.inject([]) do |array, (key, value)|
+        array << value
+        array.flatten.compact
+      end
+    end
+
+    private
+    def nested_class_hash
+      @nested_class_hash ||= nested_class_attributes.inject({}) do |hash, param|
+        hash[param.to_sym] = get_nested_class_from_parent(param)
+        hash
+      end
+    end
+
+    def nested_class_attributes
+      @parent.nested_class_attributes
+    end
+
+    def get_nested_class_from_parent(klass)
+      @parent.send(klass)
+    end
+  end
+end

data/lib/simple_params/nested_errors.rb

@@ -0,0 +1,89 @@
+require "active_model"
+
+module SimpleParams
+  class NestedErrors < ActiveModel::Errors
+    attr_reader :base
+
+    def initialize(base)
+      super(base)
+      @base = base
+    end
+
+    def array?
+      @base.array?
+    end
+
+    def hash?
+      @base.hash?
+    end
+
+    def [](attribute)
+      get(attribute.to_sym) || set(attribute.to_sym, [])
+    end
+
+    def []=(attribute, error)
+      add_error_to_attribute(attribute, error)
+    end
+
+    def add(attribute, message = :invalid, options = {})
+      message = normalize_message(attribute, message, options)
+      if exception = options[:strict]
+        exception = ActiveModel::StrictValidationFailed if exception == true
+        raise exception, full_message(attribute, message)
+      end
+
+      add_error_to_attribute(attribute, message)
+    end
+
+    def clear
+      super
+    end
+
+    def empty?
+      super
+    end
+    alias_method :blank?, :empty? 
+
+    def include?(attribute)
+      messages[attribute].present?
+    end
+    alias_method :has_key?, :include? 
+    alias_method :key?, :include?
+
+    def values
+      messages.values
+    end
+
+    def full_messages
+      map { |attribute, message| full_message(attribute, message) }
+    end
+
+    def to_hash(full_messages = false)
+      get_messages(self, full_messages)
+    end
+
+    def to_s(full_messages = false)
+      array = to_a.compact
+      array.join(', ')
+    end
+
+    private
+    def add_error_to_attribute(attribute, error)
+      self[attribute] << error
+    end
+
+    def get_messages(object, full_messages = false)
+      if full_messages
+        object.messages.each_with_object({}) do |(attribute, array), messages|
+          messages[attribute] = array.map { |message| object.full_message(attribute, message) }
+        end
+      else
+        object.messages.dup
+      end
+    end
+
+    def empty_messages?(msgs)
+      msgs.nil? || msgs.empty?
+    end
+  end
+end

data/lib/simple_params/nested_params.rb

@@ -31,11 +31,11 @@ module SimpleParams
 
       def build(params, parent, name)
         if params.is_a?(Array)
-          params.map { |p| build_instance(p, parent, name) }.compact
+          params.map { |p| build_instance(p, parent) }.compact
         elsif with_ids?
-          params.each_pair.map { |key, val| build_instance({key => val}, parent, name) }.compact
+          params.each_pair.map { |key, val| build_instance({key => val}, parent) }.compact
         else
-          build_instance(params, parent, name)
+          build_instance(params, parent)
         end
       end
 
@@ -44,8 +44,8 @@ module SimpleParams
         NestedParamsClassBuilder.new(parent).build(self, name, options, &block)
       end
 
-      def build_instance(params, parent, name)
-        instance = self.new(params, parent, name)
+      def build_instance(params, parent)
+        instance = self.new(params, parent)
         instance.destroyed? ? nil : instance
       end
     end
@@ -54,14 +54,21 @@ module SimpleParams
 
     # Should allow NestedParams to be initialized with no arguments, in order
     #  to be compatible with some Rails form gems like 'nested_form'
-    def initialize(params={}, parent = nil, parent_attribute_name = nil)
+    def initialize(params={}, parent = nil)
       @parent = parent
-      @parent_attribute_name = parent_attribute_name
       @id = extract_id(params)
       @params = extract_initialization_params(params)
       super(@params)
     end
 
+    def array?
+      self.class.array?
+    end
+
+    def symbol
+      self.class.name_symbol
+    end
+
     def destroyed?
       sym_params = symbolize_params(params)
       [true, 1, "1", "true"].include?(sym_params[:_destroy])

data/lib/simple_params/nested_params_class_builder.rb

@@ -7,14 +7,21 @@ module SimpleParams
     #TODO: Need to test this!
     def build(nested_params, name, options, &block)
       klass_name = name.to_s.split('_').collect(&:capitalize).join
+      name_symbol = name.to_sym
       Class.new(nested_params).tap do |klass|
         @parent.send(:remove_const, klass_name) if @parent.const_defined?(klass_name)
         @parent.const_set(klass_name, klass)
+
         klass.instance_eval <<-DEF
           def parent_class
             #{@parent}
           end
+
+          def name_symbol
+            :#{name_symbol}
+          end
         DEF
+
         klass.class_eval('extend ActiveModel::Naming')
         klass.class_eval(&block)
         klass.class_eval("self.options = #{options}")

data/lib/simple_params/params.rb

@@ -78,13 +78,18 @@ module SimpleParams
             init_value = if opts[:optional]
               klass.hash? ? nil : []
             else 
-              klass_instance = klass.new({}, self, name)
+              klass_instance = klass.new({}, self)
               klass.hash? ? klass_instance : [klass_instance]
             end
             instance_variable_set("@#{name}", init_value)
           end
         end
 
+        define_method("#{name}_params") do
+          original_params = instance_variable_get("@original_params")
+          original_params[:"#{name}"] || original_params[:"#{name}_attributes"]
+        end
+
         define_method("#{name}=") do |initializer|
           init_value = klass.build(initializer, self, name)
           instance_variable_set("@#{name}", init_value)
@@ -101,15 +106,12 @@ module SimpleParams
       params = InitializationHash.new(params)
       @original_params = params.original_params
       define_attributes(@original_params)
-
-      # Nested Classes
-      @nested_classes = nested_classes.keys
       set_accessors(params)
     end
 
     def define_attributes(params)
       self.class.defined_attributes.each_pair do |key, opts|
-        send("#{key}_attribute=", Attribute.new(self, key, opts))
+        self.send("#{key}_attribute=", Attribute.new(self, key, opts))
       end
     end
 
@@ -117,11 +119,19 @@ module SimpleParams
       HashBuilder.new(self).build
     end
 
+    def nested_class_attributes
+      nested_classes.keys
+    end
+
+    def nested_class_hash
+      nested_class_list.to_hash
+    end
+
+    def all_nested_classes
+      nested_class_list.class_instances
+    end
+
     def errors
-      nested_class_hash = {}
-      @nested_classes.each do |param|
-        nested_class_hash[param.to_sym] = send(param)
-      end
       @errors ||= SimpleParams::Errors.new(self, nested_class_hash)
     end
 
@@ -132,6 +142,10 @@ module SimpleParams
       end
     end
 
+    def nested_class_list
+      @nested_class_list ||= NestedClassList.new(self)
+    end
+
     def defined_attributes
       self.class.defined_attributes
     end

data/lib/simple_params/validation_matchers/validation_matcher.rb

@@ -7,7 +7,7 @@ module SimpleParams
   end
 end
 
-
+# Just Leaving this here for reference as to what we're inhereting from
 # module Shoulda
 #   module Matchers
 #     module ActiveModel

data/lib/simple_params/version.rb

@@ -1,3 +1,3 @@
 module SimpleParams
-  VERSION = "1.6.4"
+  VERSION = "1.6.5"
 end

data/lib/simple_params.rb

@@ -11,6 +11,8 @@ require 'simple_params/concerns/validations'
 require 'simple_params/params'
 require 'simple_params/initialization_hash'
 require 'simple_params/hash_builder'
+require 'simple_params/nested_class_list'
+require 'simple_params/nested_errors'
 require 'simple_params/nested_params'
 require 'simple_params/nested_params_class_builder'
 require 'simple_params/simple_params_error'

data/spec/acceptance_spec.rb

@@ -104,6 +104,23 @@ describe SimpleParams::Params do
     end
   end
 
+
+  describe "nested_parameter_accessors", nested_parameter_accessors: true do
+    it "returns params hash for nested attribute" do
+      params = AcceptanceParams.new(name: "Tom", address: { "street" => "1 Main St."} )
+      params.address_params.should eq({
+        street: "1 Main St."
+      })
+    end
+
+    it "returns params hash for nested attribute" do
+      params = AcceptanceParams.new(name: "Tom", address_attributes: { "street" => "1 Main St."} )
+      params.address_params.should eq({
+        street: "1 Main St."
+      })
+    end
+  end
+
   describe "to_hash", to_hash: true do
     it "returns params hash" do
       params = AcceptanceParams.new(
@@ -282,12 +299,6 @@ describe SimpleParams::Params do
       params.attributes.should eq([:reference, :name, :date_of_birth, :content, :current_time, :age, :color, :sibling_names, :address, :phone, :dogs, :cats, :birds])
     end
 
-    it "returns array of attribute symbols for nested class" do
-      params = AcceptanceParams::Address.new({}, nil, :address)
-      params.parent_attribute_name.should eq(:address)
-      params.attributes.should eq([:street, :city, :zip_code, :state, :company, :_destroy])
-    end
-
     it "initializes attributes correctly" do
       params = AcceptanceParams.new
       attribute = params.instance_variable_get("@age_attribute")
@@ -600,7 +611,7 @@ describe SimpleParams::Params do
           }
         end
 
-        it "is valid after multiple times" do
+        it "is valid after multiple times", failing: true do
           acceptance_params = AcceptanceParams.new(params)
           acceptance_params.valid?
           acceptance_params.should be_valid

data/spec/nested_errors_spec.rb

@@ -0,0 +1,333 @@
+require 'spec_helper'
+
+describe SimpleParams::NestedErrors do
+  class Car
+    extend ActiveModel::Naming
+    def initialize
+      @errors = SimpleParams::NestedErrors.new(self)
+    end
+
+    attr_accessor :make
+    attr_accessor :model
+    attr_reader   :errors
+
+    def array?; false; end
+    def hash?; true; end
+
+    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
+
+  class Plane
+    extend ActiveModel::Naming
+    def initialize
+      @errors = SimpleParams::NestedErrors.new(self)
+    end
+
+    attr_accessor :pilot
+    attr_accessor :number
+    attr_reader   :errors
+
+    def array?; true; end
+    def hash?; false; end
+
+    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"
+      errors.get(:foo).should eq(["omg"])
+    end
+
+    it "sets the error with the provided key" do
+      errors = SimpleParams::Errors.new(self)
+      errors.set(:foo, "omg")
+      errors.messages.should eq({ foo: "omg" })
+    end
+
+    it "values returns an array of messages" do
+      errors = SimpleParams::Errors.new(self)
+      errors.set(:foo, "omg")
+      errors.set(:baz, "zomg")
+      errors.values.should eq(["omg", "zomg"])
+    end
+
+    it "keys returns the error keys" do
+      errors = SimpleParams::Errors.new(self)
+      errors.set(:foo, "omg")
+      errors.set(:baz, "zomg")
+      errors.keys.should eq([:foo, :baz])
+    end    
+
+    describe "setting on model" do
+      it "assign error" do
+        car = Car.new
+        car.errors[:make] = 'should not be nil'
+        car.errors[:make].should eq(["should not be nil"])
+      end
+
+      it "add an error message on a specific attribute" do
+        car = Car.new
+        car.errors.add(:make, "can not be blank")
+        car.errors[:make].should eq(["can not be blank"])
+      end
+
+      it "add an error with a symbol" do
+        car = Car.new
+        car.errors.add(:make, :blank)
+        message = car.errors.generate_message(:make, :blank)
+        car.errors[:make].should eq([message])
+      end
+
+      it "add an error with a proc" do
+        car = Car.new
+        message = Proc.new { "can not be blank" }
+        car.errors.add(:make, message)
+        car.errors[:make].should eq(["can not be blank"])
+      end
+    end
+  end
+
+  describe "#clear", clear: true do
+    it "clears errors" do
+      car = Car.new
+      car.errors[:make] = 'should not be nil'
+      car.errors[:make].should eq(["should not be nil"])
+      car.errors.clear
+      car.errors.should be_empty
+    end
+  end
+
+  describe "#empty?, #blank?, and #include?", empty: true do
+    it "is empty without any errors" do
+      car = Car.new
+      car.errors.should be_empty
+      car.errors.should be_blank
+      car.errors.should_not have_key(:make)
+    end
+
+    it "is not empty with errors" do
+      car = Car.new
+      car.errors[:make] = 'should not be nil'
+      car.errors.should_not be_empty
+      car.errors.should_not be_blank
+      car.errors.should have_key(:make)
+    end
+  end
+
+  describe "#added?", added: true do
+    it "added? detects if a specific error was added to the object" do
+      car = Car.new
+      car.errors.add(:make, "can not be blank")
+      car.errors.added?(:make, "can not be blank").should be_truthy
+    end
+
+    it "added? handles symbol message" do
+      car = Car.new
+      car.errors.add(:make, :blank)
+      car.errors.added?(:make, :blank).should be_truthy
+    end
+
+    it "added? handles proc messages" do
+      car = Car.new
+      message = Proc.new { "can not be blank" }
+      car.errors.add(:make, message)
+      car.errors.added?(:make, message).should be_truthy
+    end
+
+    it "added? defaults message to :invalid" do
+      car = Car.new
+      car.errors.add(:make)
+      car.errors.added?(:make).should be_truthy
+    end
+
+    it "added? matches the given message when several errors are present for the same attribute" do
+      car = Car.new
+      car.errors.add(:make, "can not be blank")
+      car.errors.add(:make, "is invalid")
+      car.errors.added?(:make, "can not be blank").should be_truthy
+    end
+
+    it "added? returns false when no errors are present" do
+      car = Car.new
+      car.errors.added?(:make).should_not be_truthy
+    end
+
+    it "added? returns false when checking a nonexisting error and other errors are present for the given attribute" do
+      car = Car.new
+      car.errors.add(:make, "is invalid")
+      car.errors.added?(:make, "can not be blank").should_not be_truthy
+    end    
+  end
+
+  describe "#size", size: true do
+    it "size calculates the number of error messages" do
+      car = Car.new
+      car.errors.add(:make, "can not be blank")
+      car.errors.size.should eq(1)
+    end
+  end
+
+  describe "#to_a", to_a: true do
+    it "to_a returns the list of errors with complete messages containing the attribute names" do
+      car = Car.new
+      car.errors.add(:make, "can not be blank")
+      car.errors.add(:make, "can not be nil")
+      car.errors.to_a.should eq(["make can not be blank", "make can not be nil"])
+    end
+  end
+
+  describe "#to_s", to_s: true do
+    it "to_a returns the list of errors with complete messages containing the attribute names" do
+      car = Car.new
+      car.errors.add(:make, "can not be blank")
+      car.errors.add(:make, "can not be nil")
+      car.errors.to_s.should eq("make can not be blank, make can not be nil")
+    end
+
+  end
+
+  describe "#to_hash", to_hash: true do
+    it "to_hash returns the error messages hash" do
+      car = Car.new
+      car.errors.add(:make, "can not be blank")
+      car.errors.to_hash.should eq({ make: ["can not be blank"] })
+    end
+  end
+
+  describe "#as_json", as_json: true do
+    it "as_json creates a json formatted representation of the errors hash" do
+      car = Car.new
+      car.errors[:make] = 'can not be nil'
+      car.errors[:make].should eq(["can not be nil"])
+      car.errors.as_json.should eq({ make: ["can not be nil"] })
+    end
+
+    it "as_json with :full_messages option creates a json formatted representation of the errors containing complete messages" do
+      car = Car.new
+      car.errors[:make] = 'can not be nil'
+      car.errors[:make].should eq(["can not be nil"])
+      car.errors.as_json(full_messages: true).should eq({ make: ["make can not be nil"] })
+    end    
+  end
+
+  describe "#full_messages", full_messages: true do
+    it "full_messages creates a list of error messages with the attribute name included" do
+      car = Car.new
+      car.errors.add(:make, "can not be blank")
+      car.errors.add(:make, "can not be nil")
+      car.errors.full_messages.should eq(["make can not be blank", "make can not be nil"])
+    end
+
+    it "full_messages_for contains all the error messages for the given attribute" do
+      car = Car.new
+      car.errors.add(:make, "can not be blank")
+      car.errors.add(:make, "can not be nil")
+      car.errors.full_messages_for(:make).should eq(["make can not be blank", "make can not be nil"])
+    end
+
+    it "full_messages_for does not contain error messages from other attributes" do
+      car = Car.new
+      car.errors.add(:make, "can not be blank")
+      car.errors.add(:model, "can not be blank")
+      car.errors.full_messages_for(:make).should eq(["make can not be blank"])
+    end
+
+    it "full_messages_for returns an empty list in case there are no errors for the given attribute" do
+      car = Car.new
+      car.errors.add(:make, "can not be blank")
+      car.errors.full_messages_for(:model).should eq([])
+    end
+
+    it "full_message returns the given message when attribute is :base" do
+      car = Car.new
+      car.errors.full_message(:base, "press the button").should eq("press the button")
+    end
+
+    it "full_message returns the given message with the attribute name included" do
+      car = Car.new
+      car.errors.full_message(:make, "can not be blank").should eq("make can not be blank")
+      car.errors.full_message(:model, "can not be blank").should eq("model can not be blank")
+    end
+  end
+
+  describe "#generate_message", generate_message: true do
+    it "generate_message works without i18n_scope" do
+      car = Car.new
+      Car.should_not respond_to(:i18n_scope)
+      expect {
+        car.errors.generate_message(:make, :blank)
+      }.to_not raise_error
+    end
+  end
+
+  describe "#adds_on_empty", add_on_empty: true do
+    it "add_on_empty generates message" do
+      car = Car.new
+      car.errors.should_receive(:generate_message).with(:make, :empty, {})
+      car.errors.add_on_empty :make
+    end
+
+    it "add_on_empty generates message for multiple attributes" do
+      car = Car.new
+      car.errors.should_receive(:generate_message).with(:make, :empty, {})
+      car.errors.should_receive(:generate_message).with(:model, :empty, {})
+      car.errors.add_on_empty [:make, :model]
+    end
+
+    it "add_on_empty generates message with custom default message" do
+      car = Car.new
+      car.errors.should_receive(:generate_message).with(:make, :empty, { message: 'custom' })
+      car.errors.add_on_empty :make, message: 'custom'
+    end
+
+    it "add_on_empty generates message with empty string value" do
+      car = Car.new
+      car.make = ''
+      car.errors.should_receive(:generate_message).with(:make, :empty, {})
+      car.errors.add_on_empty :make
+    end
+  end
+
+  describe "#adds_on_blank", add_on_blank: true do
+    it "add_on_blank generates message" do
+      car = Car.new
+      car.errors.should_receive(:generate_message).with(:make, :blank, {})
+      car.errors.add_on_blank :make
+    end
+
+    it "add_on_blank generates message for multiple attributes" do
+      car = Car.new
+      car.errors.should_receive(:generate_message).with(:make, :blank, {})
+      car.errors.should_receive(:generate_message).with(:model, :blank, {})
+      car.errors.add_on_blank [:make, :model]
+    end
+
+    it "add_on_blank generates message with custom default message" do
+      car = Car.new
+      car.errors.should_receive(:generate_message).with(:make, :blank, { message: 'custom' })
+      car.errors.add_on_blank :make, message: 'custom'
+    end
+  end
+end

data/spec/nested_params_spec.rb

@@ -28,6 +28,10 @@ describe SimpleParams::NestedParams do
         defined_class.name.should eq("DummyParentClass::MySpecialParams")
       end
 
+      it "has correct name_symbol", failing: true do
+        defined_class.name_symbol.should eq(:my_special_params)
+      end
+
       it "has correct parent class" do
         defined_class.parent_class.should eq(DummyParentClass)
       end
@@ -102,7 +106,7 @@ describe SimpleParams::NestedParams do
           end
         end
 
-        subject { defined_class.new({name: "Bill", age: 21}, nil, :my_special_params) }
+        subject { defined_class.new(name: "Bill", age: 21) }
         
         specify "name" do
           expect(subject.name).to eq "Bill"
@@ -125,7 +129,7 @@ describe SimpleParams::NestedParams do
           end
         end
 
-        subject { defined_class.new({ "132" => { name: "Bill", age: 21 } }, nil, :my_special_params) }
+        subject { defined_class.new({ "132" => { name: "Bill", age: 21 } }) }
         
         specify "name" do
           expect(subject.name).to eq "Bill"
@@ -150,7 +154,7 @@ describe SimpleParams::NestedParams do
           end
         end
 
-        subject { defined_class.new({name: "Bill", age: 21}, nil, :my_special_params) }
+        subject { defined_class.new(name: "Bill", age: 21) }
         
         specify "name" do
           expect(subject.name).to eq "Bill"
@@ -173,7 +177,7 @@ describe SimpleParams::NestedParams do
           end
         end
 
-        subject { defined_class.new({ "132" => { name: "Bill", age: 21 } }, nil, :my_special_params) }
+        subject { defined_class.new({ "132" => { name: "Bill", age: 21 } }) }
         
         specify "name" do
           expect(subject.name).to eq "Bill"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_params
 version: !ruby/object:Gem::Version
-  version: 1.6.4
+  version: 1.6.5
 platform: ruby
 authors:
 - brycesenz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-03 00:00:00.000000000 Z
+date: 2015-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -143,6 +143,8 @@ files:
 - lib/simple_params/formatter.rb
 - lib/simple_params/hash_builder.rb
 - lib/simple_params/initialization_hash.rb
+- lib/simple_params/nested_class_list.rb
+- lib/simple_params/nested_errors.rb
 - lib/simple_params/nested_params.rb
 - lib/simple_params/nested_params_class_builder.rb
 - lib/simple_params/params.rb
@@ -169,6 +171,7 @@ files:
 - spec/formatter_spec.rb
 - spec/initialization_hash_spec.rb
 - spec/multiple_classes_spec.rb
+- spec/nested_errors_spec.rb
 - spec/nested_params_spec.rb
 - spec/params_spec.rb
 - spec/rails_integration_spec.rb
@@ -217,6 +220,7 @@ test_files:
 - spec/formatter_spec.rb
 - spec/initialization_hash_spec.rb
 - spec/multiple_classes_spec.rb
+- spec/nested_errors_spec.rb
 - spec/nested_params_spec.rb
 - spec/params_spec.rb
 - spec/rails_integration_spec.rb