aform 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6e0b098dd9b0e5a9923997ab226a3112303bc544
+  data.tar.gz: c95259178fad5768b17a20c10c68bc5503513552
+SHA512:
+  metadata.gz: e775499f47737d02c36c1b18def8cbb3bb439a3d0bd671d46a7ca403b4860604e0b94c4740fa586a1bd0deb41c623e0688baaacc3e117163c4c41bb6a50d384f
+  data.tar.gz: d742de23c84c233ee75113892d00dbc7c97218bedc9d44e2af32bcf1404d32d762de74e19538af24a9e4dded4a11df55a3c3c21b646714f6fdfcc9179338333e

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea
+database.sqlite3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in aform.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Anton Versal
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Aform
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'aform'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install aform
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/aform/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/*_test.rb'
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.name = "test:integration"
+  t.pattern = 'test/integration/*_test.rb'
+end

data/aform.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'aform/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "aform"
+  spec.version       = Aform::VERSION
+  spec.authors       = ["Anton Versal"]
+  spec.email         = ["ant.ver@gmail.com"]
+  spec.summary       = %q{Filling AR models from complex JSON}
+  spec.description   = %q{Form Object implementation for filling models from JSON with nested arrays}
+  spec.homepage      = "https://github.com/antonversal/aform"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency             "activesupport"
+  spec.add_dependency             "activemodel"
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "minitest-emoji"
+  spec.add_development_dependency "mocha"
+  spec.add_development_dependency "activerecord"
+  spec.add_development_dependency "sqlite3"
+end

data/lib/aform/builder.rb

@@ -0,0 +1,22 @@
+require 'active_model'
+class Aform::Builder
+  def initialize(model_klass)
+    @model_klass = model_klass
+  end
+
+  def build_model_klass(params, validations)
+    Class.new(@model_klass) do
+      class_attribute :params
+
+      self.params = params
+
+      validations.each do |v|
+        send(v[:method], *v[:options])
+      end if validations
+
+      params.each do |p|
+        self.send(:define_method, p) { @attributes[p] }
+      end if params
+    end
+  end
+end

data/lib/aform/errors.rb

@@ -0,0 +1,26 @@
+module Aform
+  class Errors
+    def initialize(form)
+      @form = form
+    end
+
+    def messages
+      @form.model.errors.messages.merge(nested_messages(@form))
+    end
+
+    private
+
+    def nested_messages(form)
+      if nf = form.nested_forms
+        nf.inject({}) do |memo, (k,v)|
+          messages = v.map do |e|
+            e.model.errors.messages.merge(nested_messages(e))
+          end
+          memo.merge(k => messages)
+        end
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/aform/form.rb

@@ -0,0 +1,105 @@
+module Aform
+  class Form
+    class_attribute :params
+    class_attribute :validations
+    class_attribute :nested_form_klasses
+
+    attr_accessor :model, :attributes, :nested_forms
+
+    def initialize(ar_model, attributes, model_klass = Aform::Model,
+      model_builder = Aform::Builder, errors_klass = Aform::Errors)
+      @model_klass, @model_builder, @errors_klass = model_klass, model_builder, errors_klass
+      @ar_model = ar_model
+      creator = @model_builder.new(@model_klass)
+      self.model = creator.build_model_klass(self.params, self.validations).new(@ar_model, attributes)
+      self.attributes = attributes
+      initialize_nested
+    end
+
+    #TODO don't save all models if at leas one is fail
+
+    def invalid?
+      !valid?
+    end
+
+    def valid?
+      if self.nested_forms
+        main = self.model.valid?
+        nested = self.nested_forms.values.flatten.map(&:valid?).all? #all? don't invoike method on each element
+        main && nested
+      else
+        self.model.valid?
+      end
+    end
+
+    def save
+      if self.valid?
+        if self.nested_forms
+          self.model.save && self.nested_forms.values.flatten.all?(&:save)
+        else
+          self.model.save
+        end
+      end
+    end
+
+    def errors
+      @errors_klass.new(self).messages
+    end
+
+    class << self
+      def param(*args)
+        self.params ||= []
+        self.params += args
+      end
+
+      def method_missing(meth, *args, &block)
+        if meth.to_s.start_with?("validate")
+          options = {method: meth, options: args}
+          options.merge!(block: block) if block_given?
+          self.validations ||= []
+          self.validations << options
+        elsif meth == :has_many
+          define_nested_form(args, &block)
+        else
+          super
+        end
+      end
+    end
+
+    protected
+
+    def self.define_nested_form(args, &block)
+      name = args.shift
+      self.nested_form_klasses ||= {}
+      class_attribute name
+      klass = Class.new(Aform::Form, &block)
+      self.send("#{name}=", klass)
+      self.nested_form_klasses.merge! name => klass
+    end
+
+    private
+
+    def initialize_nested
+      if nested_form_klasses
+        nested_form_klasses.each do |k,v|
+          if attributes.has_key? k
+            attributes[k].each do |attrs|
+              self.nested_forms ||= {}
+              self.nested_forms[k] ||= []
+              model = nested_ar_model(@ar_model, k, attrs)
+              self.nested_forms[k] << v.new(model, attrs, @model_klass, @model_builder, @errors_klass)
+            end
+          end
+        end
+      end
+    end
+
+    def nested_ar_model(ar_model, association, attrs)
+      if attrs.has_key? :id
+        ar_model.public_send(association).find(attrs[:id])
+      else
+        ar_model.public_send(association).build
+      end
+    end
+  end
+end

data/lib/aform/model.rb

@@ -0,0 +1,27 @@
+require 'active_model'
+class Aform::Model
+  include ActiveModel::Model
+
+  def initialize(object, attributes = {}, destroy_key = :_destroy)
+    @destroy = attributes[destroy_key]
+    @attributes = attributes.select{|k,v| params.include? k }
+    @object = object
+  end
+
+  def self.model_name
+    ActiveModel::Name.new(self, nil, "Aform::Model")
+  end
+
+  def save
+    if @destroy
+      @object.destroy
+    else
+      @object.assign_attributes(@attributes)
+      @object.save
+    end
+  end
+
+  def valid?
+    @destroy || super
+  end
+end

data/lib/aform/version.rb

@@ -0,0 +1,3 @@
+module Aform
+  VERSION = "0.0.1"
+end

data/lib/aform.rb

@@ -0,0 +1,10 @@
+require 'active_support/core_ext/class/attribute'
+require 'aform/version'
+require 'aform/form'
+require 'aform/model'
+require 'aform/builder'
+require 'aform/errors'
+
+module Aform
+  # Your code goes here...
+end

data/test/errors_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+describe Aform::Errors do
+  #TODO other way for mocking ...
+
+  before do
+    @mock_form = mock("form")
+    @mock_form.stubs(:model).returns(stub(errors: stub(messages: {name: ["can't be blank"]})))
+    @mock_form.stubs(:nested_forms).returns({comments: [
+      stub(model: stub(errors: stub(messages: {message: ["can't be blank"]})),
+           nested_forms: {
+             authors: [stub(model: stub(errors: stub(messages: {name: ["can't be blank"]})), nested_forms: nil)]
+           },
+      ),
+      stub(model: stub(errors: stub(messages: {author: ["can't be blank"]})),
+           nested_forms: nil
+      ),
+    ]})
+  end
+
+  subject { Aform::Errors.new(@mock_form) }
+
+  it "collects form model errors" do
+    subject.messages.must_equal({name: ["can't be blank"], comments: [
+      {message: ["can't be blank"], authors: [{name:["can't be blank"]}]},
+      {author: ["can't be blank"]}
+    ]})
+  end
+end

data/test/form_test.rb

@@ -0,0 +1,201 @@
+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)
+  end
+
+  describe ".param" do
+    subject do
+      Class.new(Aform::Form) do
+        param :name, :count
+        param :size
+      end.new(ar_model, {}, @mock_model_klass, @mock_builder_klass)
+    end
+
+    it "stores params" do
+      subject.params.must_equal([:name, :count, :size])
+    end
+  end
+
+  describe "validation remembering" do
+    subject do
+      Class.new(Aform::Form) do
+        param :name, :count
+        validates_presence_of :name
+        validates :count, presence: true, inclusion: [1..100]
+        validate :custom_validation
+        validate do
+          errors.add(:base, "Must be foo to be a bar")
+        end
+      end.new(ar_model, {}, @mock_model_klass, @mock_builder_klass)
+    end
+
+    it "saves validations" do
+      subject.validations.size.must_be_same_as 4
+    end
+
+    it "saves `validates_presence_of` validation" do
+      subject.validations.must_include({method: :validates_presence_of, options: [:name]})
+    end
+
+    it "saves `validates` validation" do
+      subject.validations.must_include({method: :validates,
+                                        options: [:count, {presence: true, inclusion: [1..100]}]})
+    end
+
+    it "saves `validate` validation" do
+      subject.validations.last[:method].must_be_same_as(:validate)
+      subject.validations.last[:block].wont_be_nil
+    end
+  end
+
+  describe "#valid?" 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 valid? on model" do
+      @mock_model_instance.expects(:valid?)
+      subject.valid?
+    end
+  end
+
+  describe "#save" 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.save" do
+      subject.stubs(:valid?).returns(true)
+      @mock_model_instance.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
+  end
+
+  describe "nested objects" do
+    describe "has_many" do
+      subject do
+        Class.new(Aform::Form) do
+          param :name, :count
+          has_many :comments do
+            param :author, :message
+            validates_presence_of :message, :author
+          end
+        end
+      end
+
+      it "saves params" do
+        subject.comments.params.must_equal([:author, :message])
+      end
+
+      it "saves validations" do
+        subject.comments.validations.must_equal([{method: :validates_presence_of, options: [:message, :author]}])
+      end
+
+      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"}]})
+        end
+
+        context "when `id` is present" do
+          it "finds model for nested form" do
+            model = mock("ar_model")
+            relation = mock("relation")
+            relation.stubs(:build)
+            relation.expects(:find).with(21).times(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"}]})
+          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")
+          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"}]})
+          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"}]})
+          form.valid?
+        end
+      end
+
+      describe "#save" do
+        before do
+          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"}]})
+        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/integration/active_record_test.rb

@@ -0,0 +1,95 @@
+require_relative './integration_helper'
+
+class PostForm < Aform::Form
+  param :title, :author
+  validates_presence_of :title, :author
+
+  has_many :comments do
+    param :message, :author
+    validates_presence_of :message, :author
+  end
+end
+
+describe "ActiveRecord" do
+  #TODO: move to helper in some way
+  after do
+    Comment.delete_all
+    Post.delete_all
+  end
+
+  it "creates records" do
+    post = Post.new
+    attrs = {title: "Cool Post", author: "John Doe",
+             comments: [
+               {message: "Great post man!", author: "Mr. Smith"},
+               {message: "Really?", author: "Vasya"}
+             ]
+    }
+    form = PostForm.new(post, attrs)
+    form.save.must_equal true
+    Post.count.must_equal 1
+    Comment.count.must_equal 2
+    post = Post.first
+    post.title.must_equal("Cool Post")
+    post.author.must_equal("John Doe")
+    comments = post.comments
+    comments.map(&:message).must_equal(["Great post man!", "Really?"])
+    comments.map(&:author).must_equal(["Mr. Smith", "Vasya"])
+  end
+
+  it "updates records" do
+    post = Post.create(title: "Cool Post", author: "John Doe")
+    comment = post.comments.create(message: "Great post man!", author: "Mr. Smith")
+
+    attrs = {title: "Very Cool Post", author: "John Doe",
+             comments: [
+               {id: comment.id, message: "Great post MAN!", author: "Mr. Smith"},
+               {message: "Really?", author: "Vasya"}
+             ]
+    }
+    post.reload
+    form = PostForm.new(post, attrs)
+    form.save.must_equal true
+    Post.count.must_equal 1
+    Comment.count.must_equal 2
+    post = Post.first
+    post.title.must_equal("Very Cool Post")
+    post.author.must_equal("John Doe")
+    comments = post.comments
+    comments.map(&:message).must_equal(["Great post MAN!", "Really?"])
+    comments.map(&:author).must_equal(["Mr. Smith", "Vasya"])
+  end
+
+  it "delete nested records" do
+    post = Post.create(title: "Cool Post", author: "John Doe")
+    comment = post.comments.create(message: "Great post man!", author: "Mr. Smith")
+    post.comments.create(message: "Really?", author: "Vasya")
+    attrs = {title: "Very Cool Post", author: "John Doe",
+             comments: [
+               {id: comment.id, _destroy: true}
+             ]
+    }
+    post.reload
+    form = PostForm.new(post, attrs)
+    form.save.must_equal true
+    Comment.count.must_equal 1
+    post = Post.first
+    comment = post.comments.first
+    comment.message.must_equal("Really?")
+    comment.author.must_equal("Vasya")
+  end
+
+  it "return validation errors" do
+    post = Post.new
+    attrs = {title: "Cool Post",
+             comments: [
+               {message: "Great post man!"},
+               {author: "Vasya"}
+             ]
+    }
+    form = PostForm.new(post, attrs)
+    form.wont_be :valid?
+    form.errors.must_equal({author: ["can't be blank"], comments: [{author: ["can't be blank"]},
+                                                                   {message: ["can't be blank"]}]})
+  end
+end

data/test/integration/integration_helper.rb

@@ -0,0 +1,31 @@
+require_relative "../test_helper"
+
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(
+  :adapter => "sqlite3",
+  :database => "#{Dir.pwd}/database.sqlite3"
+)
+
+#TODO: create task
+#ActiveRecord::Schema.define do
+#  create_table :posts do |t|
+#    t.column :title, :string
+#    t.column :author, :string
+#    t.timestamps
+#  end
+#
+#  create_table :comments do |t|
+#    t.column :message, :string
+#    t.column :author, :string
+#    t.belongs_to :post
+#  end
+#end
+
+class Post < ActiveRecord::Base
+  has_many :comments
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :post
+end

data/test/model_test.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+
+describe Aform::Model do
+  subject { Aform::Builder.new(Aform::Model).build_model_klass(fields, validations) }
+
+  let(:ar_model) { mock("ar_model") }
+
+  context "validations" do
+    context "by type" do
+      let(:fields){ [:name, :full_name] }
+      let(:validations){ [{method: :validates_presence_of, options: [:name]}] }
+
+      it "is not valid" do
+        subject.new(ar_model).wont_be :valid?
+      end
+
+      it "is valid" do
+        subject.new(ar_model, name: "the name").must_be :valid?
+      end
+    end
+
+    context "validate" do
+      let(:fields){ [:name, :count] }
+      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?
+      end
+
+      it "is valid" do
+        subject.new(ar_model, name: "the name", count: 3).must_be :valid?
+      end
+    end
+
+    context "when block is given" do
+      let(:fields){ [:name, :full_name] }
+      let(:validations) do
+        [{method: :validate, block: ->{errors.add(:base, "must be foo")}}]
+      end
+
+      it "is not valid" do
+        skip("not implemented")
+      end
+    end
+
+    context "when marked for destruction" do
+      let(:fields){ [:name, :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
+
+  context "#save" do
+    let(:fields){ [:name, :count] }
+    let(:validations){ [] }
+
+    let(: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)
+      model.save
+    end
+
+    it "calls `save.ar_model`" do
+      ar_model.stubs(:assign_attributes).returns(true)
+      ar_model.expects(:save).returns(true)
+      model.save
+    end
+
+    context "when marked for destruction" do
+      let(:model) { subject.new(ar_model, _destroy: true)}
+      it "removes element" do
+        ar_model.expects(:destroy).returns(true)
+        model.save
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,17 @@
+require 'aform'
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'minitest/pride'
+require 'minitest/emoji'
+require 'mocha/mini_test'
+require 'pry'
+
+I18n.enforce_available_locales = false
+
+module MiniTest
+  class Spec
+    class << self
+      alias_method :context, :describe
+    end
+  end
+end

metadata

@@ -0,0 +1,222 @@
+--- !ruby/object:Gem::Specification
+name: aform
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Anton Versal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-emoji
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Form Object implementation for filling models from JSON with nested arrays
+email:
+- ant.ver@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- aform.gemspec
+- lib/aform.rb
+- lib/aform/builder.rb
+- lib/aform/errors.rb
+- lib/aform/form.rb
+- lib/aform/model.rb
+- lib/aform/version.rb
+- test/errors_test.rb
+- test/form_test.rb
+- test/integration/active_record_test.rb
+- test/integration/integration_helper.rb
+- test/model_test.rb
+- test/test_helper.rb
+homepage: https://github.com/antonversal/aform
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Filling AR models from complex JSON
+test_files:
+- test/errors_test.rb
+- test/form_test.rb
+- test/integration/active_record_test.rb
+- test/integration/integration_helper.rb
+- test/model_test.rb
+- test/test_helper.rb