simple_params 1.1.2 → 1.2.0

data/lib/simple_params/validation_matchers/nested_array_matcher.rb

@@ -14,7 +14,8 @@ module SimpleParams
 
       def matches?(subject)
         super(subject)
-        subject.send(:nested_arrays).has_key?(@attribute)
+        subject.send(:nested_classes).has_key?(@attribute) &&
+        subject.send(:nested_classes)[@attribute.to_sym].array?
       end
 
       def description

data/lib/simple_params/validation_matchers/nested_parameter_matcher.rb

@@ -14,7 +14,8 @@ module SimpleParams
 
       def matches?(subject)
         super(subject)
-        subject.send(:nested_hashes).has_key?(@attribute)
+        subject.send(:nested_classes).has_key?(@attribute) &&
+        subject.send(:nested_classes)[@attribute.to_sym].hash?
       end
 
       def description

data/lib/simple_params/version.rb

@@ -1,3 +1,3 @@
 module SimpleParams
-  VERSION = "1.1.2"
+  VERSION = "1.2.0"
 end

data/lib/simple_params.rb

@@ -2,14 +2,20 @@ require 'simple_params/version'
 require 'simple_params/attribute'
 require 'simple_params/formatter'
 require 'simple_params/errors'
-require 'simple_params/validations'
+require 'simple_params/concerns/has_attributes'
+require 'simple_params/concerns/date_time_helpers'
+require 'simple_params/concerns/hash_helpers'
+require 'simple_params/concerns/has_typed_params'
+require 'simple_params/concerns/rails_helpers'
+require 'simple_params/concerns/strict_params'
+require 'simple_params/concerns/validations'
 require 'simple_params/params'
+require 'simple_params/nested_params'
 require 'simple_params/simple_params_error'
 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/api_pie_doc_spec.rb

@@ -12,33 +12,20 @@ describe SimpleParams::ApiPieDoc do
       expect(api_pie_doc.base_attributes.keys).to include(:amount, :color, :first_initial)
     end
 
-    specify "should give object nested_hashes" 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]
+    specify "should give object nested_classes" do
+      expect(api_pie_doc.nested_classes.keys).to eq [:address, :phone, :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)
+      expect_any_instance_of(SimpleParams::ApiPieDoc).to receive(:build_nested_classes)
       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]
+      expect(api_pie_doc.nested_attributes.flat_map(&:keys)).to include(:address, :phone, :dogs)
+      expect(api_pie_doc.nested_attributes[0].values.flat_map(&:keys)).to eq [:street, :city, :zip_code, :state, :type]
+      expect(api_pie_doc.nested_attributes[1].values.flat_map(&:keys)).to eq [:cell_phone, :phone_number, :area_code, :type]
+      expect(api_pie_doc.nested_attributes[2].values.flat_map(&:keys)).to eq [:name, :age, :type]
     end
 
     specify "should give object docs" do

data/spec/errors_spec.rb

@@ -4,10 +4,7 @@ describe SimpleParams::Errors do
   class Person
     extend ActiveModel::Naming
     def initialize
-      @errors = SimpleParams::Errors.new(self, 
-        { dog: dog.errors }, 
-        { cats: cats_errors }, 
-      )
+      @errors = SimpleParams::Errors.new(self, {dog: dog, cats: cats})
     end
 
     attr_accessor :name, :age
@@ -21,10 +18,6 @@ describe SimpleParams::Errors do
       @cats ||= [Cat.new]
     end
 
-    def cats_errors
-      cats.map { |cat| cat.errors }
-    end
-
     def read_attribute_for_validation(attr)
       send(attr)
     end
@@ -47,6 +40,10 @@ describe SimpleParams::Errors do
     attr_accessor :breed
     attr_reader   :errors
 
+    def id
+      nil
+    end
+
     def read_attribute_for_validation(attr)
       send(attr)
     end
@@ -70,6 +67,10 @@ describe SimpleParams::Errors do
     attr_accessor :age
     attr_reader   :errors
 
+    def id
+      123
+    end
+
     def read_attribute_for_validation(attr)
       send(attr)
     end
@@ -194,7 +195,7 @@ describe SimpleParams::Errors do
       person.errors[:cats][0].should eq(cat_errors)
     end
 
-    it "can add to nested errors through []", failing: true do
+    it "can add to nested errors through []" do
       person = Person.new
       person.errors[:cats].first[:base] = 'should not be nil' 
       person.errors[:cats].first[:base].should eq(['should not be nil']) 
@@ -375,7 +376,7 @@ describe SimpleParams::Errors do
   end
 
   describe "#to_hash", to_hash: true do
-    it "to_hash returns the error messages hash", hash_failing: true do
+    it "to_hash returns the error messages hash" do
       person = Person.new
       person.errors.add(:name, "can not be blank")
       person.errors.to_hash.should eq({ name: ["can not be blank"] })
@@ -408,6 +409,28 @@ describe SimpleParams::Errors do
         }
       })
     end
+
+    it "handles nested attributes with base errors and array errors" do
+      person = Person.new
+      person.errors.add(:base, :invalid)
+      person.errors.add(:name, "can not be blank")
+      person.dog.errors.add(:base, :invalid)
+      person.dog.errors.add(:breed, "can not be nil")
+      person.cats.first.errors.add(:name, "can not be blank")
+      person.errors.to_hash.should eq({ 
+        base: ["is invalid"],
+        name: ["can not be blank"],
+        dog: {
+          base: ["is invalid"],
+          breed: ["can not be nil"]
+        },
+        cats: [
+          {
+            name: ["can not be blank"]
+          }
+        ]
+      })
+    end
   end
 
   describe "#as_json", as_json: true do

data/spec/nested_params_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+require 'fixtures/dummy_params'
+
+describe SimpleParams::NestedParams do
+  # Turn off Constant Redefined errors
+  before(:each) do
+    $VERBOSE = nil
+  end
+
+  class DummyParentClass < SimpleParams::Params
+  end
+
+  describe "class_methods", class_methods: true do
+    let!(:parent) { DummyParentClass }
+    let!(:name) { :my_special_params }
+
+    describe "define_new_hash_class", define_new_hash_class: true do
+      let(:options) do
+        {
+          first_option: "yes",
+          second_option: "totally"
+        }
+      end
+
+      let(:defined_class) do
+        described_class.define_new_hash_class(parent, name, options) do
+          param :name, default: "Tom"
+          param :age
+        end
+      end
+
+      it "has correct name" do
+        defined_class.name.should eq("DummyParentClass::MySpecialParams")
+      end
+
+      it "has correct options" do
+        defined_class.options.should eq(
+          {
+            first_option: "yes", 
+            second_option: "totally",
+            type: :hash
+          }
+        )
+      end
+
+      it "has correct type" do
+        defined_class.type.should eq(:hash)
+      end
+
+      it "does not use ids" do
+        defined_class.with_ids?.should eq(false)
+      end
+    end
+
+    describe "define_new_array_class", define_new_array_class: true do
+      let(:options) do
+        {
+          first_option: "yes",
+          second_option: "totally",
+          with_ids: true
+        }
+      end
+
+      let(:defined_class) do
+        described_class.define_new_array_class(parent, name, options) do
+          param :name, default: "Tom"
+          param :age
+        end
+      end
+
+      it "has correct name" do
+        defined_class.name.should eq("DummyParentClass::MySpecialParams")
+      end
+
+      it "has correct options" do
+        defined_class.options.should eq(
+          {
+            first_option: "yes", 
+            second_option: "totally",
+            with_ids: true,
+            type: :array
+          }
+        )
+      end
+
+      it "has correct type" do
+        defined_class.type.should eq(:array)
+      end
+
+      it "doe use ids" do
+        defined_class.with_ids?.should eq(true)
+      end
+    end
+  end
+
+  describe "initialization" do
+    context "with hash class" do
+      context "without ids" do
+        let(:defined_class) do
+          described_class.define_new_hash_class(DummyParentClass, :demo, {}) do
+            param :name, default: "Tom"
+            param :age, type: :integer
+          end
+        end
+
+        subject { defined_class.new(name: "Bill", age: 21) }
+        
+        specify "name" do
+          expect(subject.name).to eq "Bill"
+        end
+
+        specify "age" do
+          expect(subject.age).to eq 21
+        end
+
+        specify "id" do
+          expect(subject.id).to eq nil
+        end
+      end
+
+      context "with ids" do
+        let(:defined_class) do
+          described_class.define_new_hash_class(DummyParentClass, :demo, { with_ids: true }) do
+            param :name, default: "Tom"
+            param :age, type: :integer
+          end
+        end
+
+        subject { defined_class.new("132" => { name: "Bill", age: 21 }) }
+        
+        specify "name" do
+          expect(subject.name).to eq "Bill"
+        end
+
+        specify "age" do
+          expect(subject.age).to eq 21
+        end
+
+        specify "id" do
+          expect(subject.id).to eq "132"
+        end
+      end
+    end
+
+    context "with array class" do
+      context "without ids" do
+        let(:defined_class) do
+          described_class.define_new_array_class(DummyParentClass, :demo, {}) do
+            param :name, default: "Tom"
+            param :age, type: :integer
+          end
+        end
+
+        subject { defined_class.new(name: "Bill", age: 21) }
+        
+        specify "name" do
+          expect(subject.name).to eq "Bill"
+        end
+
+        specify "age" do
+          expect(subject.age).to eq 21
+        end
+
+        specify "id" do
+          expect(subject.id).to eq nil
+        end
+      end
+
+      context "with ids" do
+        let(:defined_class) do
+          described_class.define_new_array_class(DummyParentClass, :demo, { with_ids: true }) do
+            param :name, default: "Tom"
+            param :age, type: :integer
+          end
+        end
+
+        subject { defined_class.new("132" => { name: "Bill", age: 21 }) }
+        
+        specify "name" do
+          expect(subject.name).to eq "Bill"
+        end
+
+        specify "age" do
+          expect(subject.age).to eq 21
+        end
+
+        specify "id" do
+          expect(subject.id).to eq "132"
+        end
+      end
+    end
+  end
+end

data/spec/params_spec.rb

@@ -66,6 +66,13 @@ describe SimpleParams::Params do
         params.address.zip_code = "20165"
         params.address.zip_code.should eq("20165")
       end
+
+      it "can set nested_array with hash" do
+        params.address= { street: "2 Oak Ave.", city: "Miami", zip_code: "90210" }
+        params.address.street.should eq("2 Oak Ave.")
+        params.address.city.should eq("Miami")
+        params.address.zip_code.should eq("90210")
+      end
     end
 
     describe "nested arrays", nested: true do
@@ -80,6 +87,14 @@ describe SimpleParams::Params do
         params.dogs.first.should_not be_nil
         params.dogs.first.name.should eq("SPOT")
       end
+
+      it "can set nested arrays with arrays" do
+        params.dogs = [{ name: "Spot", age: 20 }]
+        params.dogs.count.should eq(1)
+        params.dogs.first.should_not be_nil
+        params.dogs.first.name.should eq("SPOT")
+        params.dogs.first.age.should eq(20)
+      end
     end
   end
 

data/spec/rails_integration_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+class RailsIntegrationParams < SimpleParams::Params
+  param :name
+  param :age, type: :integer, optional: true, validations: { inclusion: { in: 18..100 } }
+  param :current_time, type: :datetime, optional: true
+
+  nested_hash :address do
+    param :street
+    param :city, validations: { length: { in: 4..40 } }
+    param :zip_code, optional: true
+    param :state, default: "North Carolina"
+  end
+
+  nested_array :dogs, with_ids: true do
+    param :name
+    param :age, type: :integer, validations: { inclusion: { in: 1..20 } }
+  end
+end
+
+describe SimpleParams::Params do
+  let!(:params) do
+    RailsIntegrationParams.new(
+      name: "Tom",
+      age: 21,
+      "current_time(6i)" => 59,
+      "current_time(5i)" => 58,
+      "current_time(4i)" => 11,
+      "current_time(3i)" => 4,
+      "current_time(2i)" => 3,
+      "current_time(1i)" => 2009,
+      address_attributes: {
+        street: "1 Main St.",
+        city: "Charlotte"
+      },
+      dogs_attributes: [
+        "0" => {
+          name: "Spot",
+          age: 4
+        },
+        "1" => {
+          age: 6
+        }
+      ]
+    )
+  end
+
+  specify "is not persisted" do
+    expect(params).to_not be_persisted
+  end
+
+  specify "setting datetime" do
+    expect(params.current_time).to eq DateTime.new(2009, 3, 4, 11, 58, 59)
+  end
+
+  specify "sets address" do
+    address = params.address
+    expect(address.street).to eq "1 Main St."
+    expect(address.city).to eq "Charlotte"
+  end
+
+  specify "sets dogs"do
+    dogs = params.dogs
+    expect(dogs.count).to eq 2
+    expect(dogs[0].name).to eq "Spot"
+    expect(dogs[0].age).to eq 4
+    expect(dogs[1].name).to eq nil
+    expect(dogs[1].age).to eq 6
+  end
+end