aform 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 93ff36848be09d703e47acb5b73764f97f235ce5
-  data.tar.gz: bcbac1680a8d4ced2f1bfcaa74170b4ab0ec0052
+  metadata.gz: 2a00654d7e27e53fa05173608a7f0630ebe6b771
+  data.tar.gz: c76a97771dd6d28f781b3b49c243b3634eebc0ca
 SHA512:
-  metadata.gz: f55367787834ae50febed73521daf8a8642a413d91224ed1bdba7924f189fe072d31021603495fa03b99d2e0c6be6abfa5f90442ba8d529edc3cd66d5c630896
-  data.tar.gz: adf3e582fbc4a2fee4d7895af355a6180d044f00bd083dfac303e4c8cc636a986204cbf438061d26a21967483266444e1d66f409fae42d059cfaaf5c65c684f7
+  metadata.gz: 82eb7f0087485fdc85a79bfdee55c7f1f24ebf0d8169a53c510a1889e36d337c45829d20d3afdca609f6fcfc792b2ba498fe685d2356060aa77d7b43d1a87d90
+  data.tar.gz: bc19d70163f31bbf851063a4518b11eec248e509b98ff7ea952214949f32420ca15d556d4b3c376ffeaac6e84713b46978d4ddc1cfd8ce469afff50c4a626291

data/lib/aform.rb

@@ -9,8 +9,4 @@ require 'aform/model'
 require 'aform/builder'
 require 'aform/errors'
 require 'aform/form_saver'
-require 'aform/uniqueness_validator'
-
-module Aform
-  # Your code goes here...
-end
+require 'aform/uniqueness_validator'

data/lib/aform/builder.rb

@@ -1,4 +1,5 @@
 require 'active_model'
+#tested within model test
 class Aform::Builder
   def initialize(model_klass)
     @model_klass = model_klass

data/lib/aform/form.rb

@@ -2,40 +2,38 @@ module Aform
   class Form
     class_attribute :params, :pkey, :validations, :nested_form_klasses
 
-    attr_reader :form_model, :attributes, :nested_forms, :model, :nested_models, :parent
+    attr_reader :form_model, :attributes, :nested_forms, :record, :parent
 
-    def initialize(model, attributes, parent = nil ,model_klass = Aform::Model,
-      model_builder = Aform::Builder, errors_klass = Aform::Errors,
-      form_saver = Aform::FormSaver, transaction_klass = ActiveRecord::Base)
-      @model_klass, @model_builder, @errors_klass = model_klass, model_builder, errors_klass
-      @model, @attributes, @transaction_klass = model, attributes, transaction_klass
+    def initialize(record, attributes, parent = nil, opts = {})
+      @opts = opts
+      @attributes = attributes
+      @record = record
       @parent = parent
-      @form_saver = form_saver
-      creator = @model_builder.new(@model_klass)
-      @form_model = creator.build_model_klass(self.params, self.validations).new(@model, self, @attributes)
+      assign_opts_instances
       initialize_nested
     end
 
-    def invalid?
-      !valid?
-    end
-
     def valid?
       if @nested_forms
         main = @form_model.valid?
-        nested = @nested_forms.values.flatten.map(&:valid?).all? #all? don't invoike method on each element
+        #all? don't invoike method on each element
+        nested = @nested_forms.values.flatten.map(&:valid?).all?
         main && nested
       else
         @form_model.valid?
       end
     end
 
+    def invalid?
+      !valid?
+    end
+
     def save
-      self.valid? && @form_saver.new(self, @transaction_klass).save
+      self.valid? && @form_saver.save
     end
 
     def errors
-      @errors_klass.new(self).messages
+      @errors.messages
     end
 
     class << self
@@ -80,26 +78,34 @@ module Aform
 
     private
 
+    def assign_opts_instances
+      @errors     = @opts[:errors] || Aform::Errors.new(self)
+      @form_saver = @opts[:form_saver] || Aform::FormSaver.new(self)
+      @form_model = @opts[:form_model] || Aform::Model.\
+        build_klass(self.params, self.validations).\
+        new(record, self, attributes)
+    end
+
     def initialize_nested
-      if nested_form_klasses
-        nested_form_klasses.each do |k,v|
-          if attributes.has_key?(k) && attributes[k]
-            attributes[k].each do |attrs|
-              @nested_forms ||= {}
-              @nested_forms[k] ||= []
-              model = nested_ar_model(k, attrs, v.pkey)
-              @nested_forms[k] << v.new(model, attrs, self, @model_klass, @model_builder,
-                                        @errors_klass, @form_saver, @transaction_klass)
+      @nested_forms =
+        if nested_form_klasses
+          nested_form_klasses.inject({}) do |memo, (k, v)|
+            if attributes[k]
+              nested = attributes[k].map do |attrs|
+                v.new(nested_record(k, attrs, v.pkey), attrs, self, @opts)
+              end
+              memo.merge(k => nested)
+            else
+              memo
             end
           end
         end
-      end
     end
 
-    def nested_ar_model(association, attrs, key = :id)
+    def nested_record(association, attrs, key)
       key = key || :id
-      klass = association.to_s.classify.constantize
-      klass.find_by(key => attrs[key]) || klass.new
+      record.send(association).find_by(key => attrs[key]) || \
+        association.to_s.classify.constantize.new
     end
   end
-end
+end

data/lib/aform/form_saver.rb

@@ -1,11 +1,15 @@
 module Aform
   class FormSaver
-    def initialize(form, transaction_klass = ActiveRecord::Base)
+    attr_reader :transaction_klass, :rollback_klass
+
+    def initialize(form, opts = {})
+      @transaction_klass = opts[:transaction_klass] ||= ActiveRecord::Base
+      @rollback_klass = opts[:rollback_klass] ||= ActiveRecord::Rollback
       @form = form
-      @transaction_klass = transaction_klass
     end
 
     def save
+      result = false
       @transaction_klass.transaction do
         result =
           if @form.nested_forms
@@ -13,9 +17,9 @@ module Aform
           else
             @form.form_model.save
           end
-        raise(ActiveRecord::Rollback) unless result
-        result
+        raise(@rollback_klass) unless result
       end
+      result
     end
 
     protected
@@ -23,11 +27,11 @@ module Aform
     def save_nested(form)
       form.nested_forms.map do |k, v|
         v.map do |nf|
-          result = nf.form_model.save(form.model.send(k))
+          result = nf.form_model.save(form.record.send(k))
           save_nested(nf) if nf.nested_forms
           result
         end
-      end
+      end.flatten
     end
   end
 end

data/lib/aform/model.rb

@@ -10,6 +10,10 @@ class Aform::Model
     @attributes.merge! attributes_for_save(attributes)
   end
 
+  def self.build_klass(params, validations, builder = Aform::Builder.new(Aform::Model))
+    builder.build_model_klass(params, validations)
+  end
+
   def self.model_name
     ActiveModel::Name.new(self, nil, "Aform::Model")
   end

data/lib/aform/uniqueness_validator.rb

@@ -1,4 +1,5 @@
 require 'active_record'
+# tested within integration test
 class UniquenessValidator < ::ActiveRecord::Validations::UniquenessValidator
   def validate_each(form, attribute, value)
     object = form.instance_variable_get(:@object)

data/lib/aform/version.rb

@@ -1,3 +1,3 @@
 module Aform
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/test/form_saver_test.rb

@@ -1,41 +1,79 @@
 require 'test_helper'
 
 describe Aform::FormSaver do
+  class RollbackKlass < Exception
+  end
+
   class TransactionKlass
     def self.transaction
       yield
+    rescue RollbackKlass
+      true
     end
   end
 
-  class TestForm
-    def form_model
-
+  def mock_nested_form(save = true)
+    form_model = OpenStruct.new
+    form_model.define_singleton_method :save do |*args|
+      save
     end
+    OpenStruct.new(nested_forms: nil,
+                   form_model: form_model)
+  end
 
-    def nested_forms
-      {comments: }
-    end
+  def mock_form(nested_forms: nil, record: nil, save: true)
+    OpenStruct.new(nested_forms: nested_forms,
+                   form_model: OpenStruct.new(save: save),
+                   record: record)
   end
 
-  let(:form) do
-    OpenStruct
-    form = {
-      form_model: :form_model,
-      nested_forms: [
-        {comments: [
-                    nested_form1: {
-                      form_model: :form_model,
-                      nested_forms: [:nested_form2]
-                    }
-          ]
-        }
-      ]
-    }
+  def form_saver(form)
+    Aform::FormSaver.new(form, {transaction_klass: TransactionKlass,
+                                rollback_klass: RollbackKlass})
   end
 
-  subject { Aform::FormSaver.new(form, TransactionKlass) }
+  describe "#save" do
+    context "saving form" do
+      it "success" do
+        form = mock_form
+        form_saver(form).save.must_equal(true)
+      end
+
+      it "failure" do
+        form = mock_form(save: false)
+        form_saver(form).save.must_equal(false)
+      end
+    end
 
-  it "saves form" do
+    context "saving nested forms" do
+      it "success" do
+        nested_forms = [mock_nested_form, mock_nested_form]
+        form = mock_form(nested_forms: {comments: nested_forms},
+                         record: OpenStruct.new(comments: []))
+        form_saver(form).save.must_equal(true)
+      end
 
+      it "failure" do
+        nested_forms = [mock_nested_form(false), mock_nested_form]
+        form = mock_form(nested_forms: {comments: nested_forms},
+                         record: OpenStruct.new(comments: []))
+        form_saver(form).save.must_equal(false)
+      end
+    end
+  end
+
+  context "rollback transaction" do
+    class TestTransactionKlass
+      def self.transaction
+        yield
+      end
+    end
+
+    it "raises RollbackKlass" do
+      form = mock_form(save: false)
+      form_saver = Aform::FormSaver.new(form, {transaction_klass: TestTransactionKlass,
+                                               rollback_klass: RollbackKlass})
+      -> { form_saver.save }.must_raise(RollbackKlass)
+    end
   end
 end

data/test/form_test.rb

@@ -2,26 +2,17 @@ require 'test_helper'
 
 describe Aform::Form do
 
-  let(:ar_model) { mock("ar_model") }
-
-  before do
-    @mock_model_instance = mock("model_instance")
-    @mock_model_klass = mock("model_class")
-    @mock_model_klass.stubs(:new).returns(@mock_model_instance)
-    @mock_builder_instance = mock("builder_instance")
-    @mock_builder_instance.stubs(:build_model_klass).returns(@mock_model_klass)
-    @mock_builder_klass = mock("builder_class")
-    @mock_builder_klass.stubs(:new).returns(@mock_builder_instance)
-    @mock_transaction = mock("ar_model")
-    @mock_errors = mock("mock_errors")
-  end
+  let(:record) { mock("record") }
+  let(:form_model) {mock("form_model")}
+  let(:form_saver) {mock("form_saver")}
+  let(:errors) {mock("errors")}
 
   describe ".param" do
     subject do
       Class.new(Aform::Form) do
         param :name, :count
         param :size, model_field: :count
-      end.new(ar_model, {}, @mock_model_klass, @mock_builder_klass, @mock_errors, @mock_transaction)
+      end
     end
 
     it "stores params" do
@@ -39,7 +30,7 @@ describe Aform::Form do
         validate do
           errors.add(:base, "Must be foo to be a bar")
         end
-      end.new(ar_model, {}, @mock_model_klass, @mock_builder_klass, @mock_errors, @mock_transaction)
+      end
     end
 
     it "saves validations" do
@@ -67,11 +58,11 @@ describe Aform::Form do
         param :name, :count
         validates_presence_of :name
         validates :count, presence: true, inclusion: {in: 1..100}
-      end.new(ar_model, {}, @mock_model_klass, @mock_builder_klass, @mock_errors, @mock_transaction)
+      end.new(record, {}, nil, {form_model: form_model} )
     end
 
-    it "calls valid? on model" do
-      @mock_model_instance.expects(:valid?)
+    it "calls valid? on form_model" do
+      form_model.expects(:valid?)
       subject.valid?
     end
   end
@@ -82,29 +73,29 @@ describe Aform::Form do
         param :name, :count
         validates_presence_of :name
         validates :count, presence: true, inclusion: {in: 1..100}
-      end.new(ar_model, {}, @mock_model_klass, @mock_builder_klass, @mock_errors, @mock_transaction)
+      end.new(record, {}, nil, {form_saver: form_saver, form_model: form_model})
     end
 
     it "calls model.save" do
       subject.stubs(:valid?).returns(true)
-      @mock_model_instance.expects(:save)
+      form_saver.expects(:save)
       subject.save
     end
   end
 
   describe "#errors" do
-    #subject do
-    #  Class.new(Aform::Form) do
-    #    param :name, :count
-    #    validates_presence_of :name
-    #    validates :count, presence: true, inclusion: {in: 1..100}
-    #  end.new(ar_model, {}, @mock_model_klass, @mock_builder_klass)
-    #end
-    #
-    #it "calls model.errors" do
-    #  @mock_model_instance.expects(:errors)
-    #  subject.errors
-    #end
+    subject do
+      Class.new(Aform::Form) do
+        param :name, :count
+        validates_presence_of :name
+        validates :count, presence: true, inclusion: {in: 1..100}
+      end.new(record, {}, nil, {form_saver: form_saver, form_model: form_model, errors: errors})
+    end
+
+    it "calls model.errors" do
+      errors.expects(:messages)
+      subject.errors
+    end
   end
 
   describe "nested objects" do
@@ -130,81 +121,6 @@ describe Aform::Form do
       it "defines `nested_forms`" do
         subject.nested_form_klasses.must_equal({comments: subject.comments})
       end
-
-      describe "initialization" do
-        it "initializes nested froms" do
-          model = mock("ar_model")
-          relation = mock("relation")
-          relation.expects(:build).times(2)
-          model.stubs(comments: relation)
-          subject.new(model, {name: "name", count: 1,
-                              comments: [{author: "Joe", message: "Message 1"},
-                                         {author: "Smith", message: "Message 2"}]},
-                      @mock_model_klass, @mock_builder_klass, @mock_errors, @mock_transaction)
-        end
-
-        context "when `id` is present" do
-          it "finds model for nested form" do
-            model = mock("ar_model")
-            relation = mock("relation")
-            relation.stubs(:build)
-            #TODO: rewirte tests
-            relation.expects(:select).returns([1])
-            model.stubs(comments: relation)
-            subject.new(model, {name: "name", count: 1,
-                                comments: [{author: "Joe", message: "Message 1"},
-                                           {id: 21, author: "Smith", message: "Message 2"}]},
-                        @mock_model_klass, @mock_builder_klass, @mock_errors, @mock_transaction)
-          end
-        end
-      end
-
-      #describe "#valid?" do
-      #  it "calls valid? on nested forms" do
-      #    Aform::Model.any_instance.expects(:valid?).returns(true).times(3)
-      #    model = mock("ar_model")
-      #    @mock_model_instance.stubs(:valid?).returns(true)
-      #    model.stubs(comments: stub(build: mock("ar_comment_model")))
-      #    form = subject.new(model, {name: "name", count: 1,
-      #                               comments: [{author: "Joe", message: "Message 1"},
-      #                                          {author: "Smith", message: "Message 2"}]},
-      #                       @mock_model_klass, @mock_builder_klass, @mock_errors, @mock_transaction)
-      #    form.valid?
-      #  end
-      #
-      #  #it "calls valid? on nested forms when main form is not valid" do
-      #  #  Aform::Model.any_instance.expects(:valid?).returns(false).times(3)
-      #  #  model = mock("ar_model")
-      #  #  model.stubs(comments: stub(build: mock("ar_comment_model")))
-      #  #  form = subject.new(model, {name: "name", count: 1,
-      #  #                             comments: [{author: "Joe", message: "Message 1"},
-      #  #                                        {author: "Smith", message: "Message 2"}]},
-      #  #                     @mock_model_klass, @mock_builder_klass, @mock_errors, @mock_transaction)
-      #  #  form.valid?
-      #  #end
-      #end
-
-      #describe "#save" do
-      #  before do
-      #    model = mock("ar_model")
-      #    model.stubs(comments: stub(build: mock("ar_comment_model")))
-      #    @mock_model_instance.stubs(:valid?).returns(true)
-      #    @form = subject.new(model, {name: "name", count: 1,
-      #                               comments: [{author: "Joe", message: "Message 1"},
-      #                                          {author: "Smith", message: "Message 2"}]},
-      #                        @mock_model_klass, @mock_builder_klass, @mock_errors, @mock_transaction)
-      #  end
-      #
-      #  it "calls save on nested forms" do
-      #    Aform::Model.any_instance.expects(:save).returns(true).times(3)
-      #    @form.save
-      #  end
-      #
-      #  it "calls valid? on nested forms" do
-      #    Aform::Model.any_instance.expects(:valid?).returns(false).times(3)
-      #    @form.save
-      #  end
-      #end
     end
   end
 end

data/test/model_test.rb

@@ -1,9 +1,19 @@
 require 'test_helper'
 
 describe Aform::Model do
-  subject { Aform::Builder.new(Aform::Model).build_model_klass(fields, validations) }
+  subject { Aform::Model.build_klass(fields, validations) }
 
-  let(:ar_model) { mock("ar_model") }
+  def mock_ar_model(attributes: {}, save: true)
+    model = OpenStruct.new(attributes: attributes, save: save)
+    model.define_singleton_method :assign_attributes do |attrs|
+      @table[:attributes] = attrs
+    end
+    model
+  end
+
+  def mock_form
+    OpenStruct.new
+  end
 
   context "validations" do
     context "by type" do
@@ -11,11 +21,11 @@ describe Aform::Model do
       let(:validations){ [{method: :validates_presence_of, options: [:name]}] }
 
       it "is not valid" do
-        subject.new(ar_model).wont_be :valid?
+        subject.new(mock_ar_model, mock_form).wont_be :valid?
       end
 
       it "is valid" do
-        subject.new(ar_model, name: "the name").must_be :valid?
+        subject.new(mock_ar_model, mock_form, {name: "the name"}).must_be :valid?
       end
     end
 
@@ -24,11 +34,11 @@ describe Aform::Model do
       let(:validations){ [{method: :validates, options: [:count, {presence: true, inclusion: {in: 1..100}}]}] }
 
       it "is not valid" do
-        subject.new(ar_model, count: -1).wont_be :valid?
+        subject.new(mock_ar_model, mock_form, count: -1).wont_be :valid?
       end
 
       it "is valid" do
-        subject.new(ar_model, name: "the name", count: 3).must_be :valid?
+        subject.new(mock_ar_model, mock_form, name: "the name", count: 3).must_be :valid?
       end
     end
 
@@ -42,42 +52,33 @@ describe Aform::Model do
         skip("not implemented")
       end
     end
-
-    context "when marked for destruction" do
-      let(:fields){ [{field: :name}, {field: :count}] }
-      let(:validations){ [{method: :validates_presence_of, options: [:name]}] }
-
-      it "is not valid" do
-        subject.new(ar_model, _destroy: true).must_be :valid?
-      end
-    end
   end
 
   describe "#save" do
     let(:fields){ [{field: :name}, {field: :count}] }
     let(:validations){ [] }
+    let(:model) { mock_ar_model }
+    let(:form_model) { subject.new(model, mock_form, name: "name", count: 2, other_attr: "other")}
 
-    let(:form_model) { subject.new(ar_model, name: "name", count: 2, other_attr: "other")}
-
-    it "calls `ar_model.assign_attributes`" do
-      ar_model.expects(:assign_attributes).with(name: "name", count: 2).returns(true)
-      ar_model.stubs(:save)
+    it "assigns attributes to model" do
       form_model.save
+      model.attributes.must_equal({name: "name", count: 2})
     end
 
-    it "calls `ar_model.save`" do
-      ar_model.stubs(:assign_attributes).returns(true)
-      ar_model.expects(:save).returns(true)
+    it "saves model" do
+      model.expects(:save)
       form_model.save
     end
 
     context "when keys are strings" do
-      let(:form_model) { subject.new(ar_model, "name" => "name", "count" => 2, "other_attr" => "other")}
+      let(:form_model) { subject.new(model, mock_form,
+                                     "name" => "name",
+                                     "count" => 2,
+                                     "other_attr" => "other")}
 
-      it "calls `ar_model.assign_attributes`" do
-        ar_model.expects(:assign_attributes).with(name: "name", count: 2).returns(true)
-        ar_model.stubs(:save)
+      it "calls assigns attributes" do
         form_model.save
+        model.attributes.must_equal(name: "name", count: 2)
       end
     end
 
@@ -85,42 +86,36 @@ describe Aform::Model do
       let(:fields){ [{field: :name}, {field: :count, options: {model_field: :size}}] }
 
       it "convert attributes" do
-        ar_model.expects(:assign_attributes).with(name: "name", size: 2).returns(true)
-        ar_model.stubs(:save)
         form_model.save
+        model.attributes.must_equal(name: "name", size: 2)
       end
     end
-  end
 
-  describe "#nested_save" do
-    let(:fields){ [{field: :name}, {field: :count}] }
-    let(:validations){ [] }
-    let(:form_model) { subject.new(ar_model, name: "name", count: 2, other_attr: "other")}
+    context "when association is given" do
+      let(:association) {[]}
+      before do
+        form_model.save(association)
+      end
 
-    it "calls `ar_model.assign_attributes`" do
-      ar_model.expects(:assign_attributes).with(name: "name", count: 2).returns(true)
-      ar_model.stubs(:persisted?).returns(false)
-      form_model.nested_save
+      it "adds object to association" do
+        association.must_equal([model])
+      end
     end
+  end
 
-    it "calls `ar_model.save` if persisted? is true" do
-      ar_model.stubs(:assign_attributes).returns(true)
-      ar_model.stubs(:persisted?).returns(true)
-      ar_model.expects(:save).returns(true)
-      form_model.nested_save
-    end
+  context "when object for destroying" do
+    let(:fields){ [{field: :name}, {field: :count}] }
+    let(:validations){ [{method: :validates_presence_of, options: [:name]}] }
+    let(:model) { mock_ar_model }
+    let(:form_model) { subject.new(model, mock_form, count: 2, _destroy: true)}
 
-    context "when marked for destruction" do
-      let(:form_model) { subject.new(ar_model, name: "name", count: 2, _destroy: true)}
-      it "removes element" do
-        ar_model.expects(:destroy).returns(true)
-        form_model.nested_save
-      end
+    it "is valid" do
+      form_model.must_be :valid?
+    end
 
-      it "calls `ar_model.assign_attributes`" do
-        ar_model.expects(:assign_attributes).with(name: "name", count: 2).returns(true)
-        form_model.nested_save
-      end
+    it "assigns attributes" do
+      form_model.save
+      model.attributes.must_equal(count: 2)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aform
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Anton Versal
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-21 00:00:00.000000000 Z
+date: 2014-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport