on_form 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b6aada85f9b13d5b28592d880d3cfebd1f5ef8e4
+  data.tar.gz: 9d15cc5152cb460307365fe91dadb63c8ca72370
+SHA512:
+  metadata.gz: ab8c256758e5eebecf4e3f2fd2f93ab85c763fed8924e61629cd3e7765a12527f911c22341d484bacdacc0347de62804f06c8ff20ecc3a52aac85b0e6f539d4e
+  data.tar.gz: 43ee6c65289f1194bb92076c517a28fcdd10733517c8dc0d4e3dd702f625d8bbe629659d047f3b887b4e25154c64880db85a3b29e619e517a8dd751a09b02022

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+test/test.db

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Powershop New Zealand Limited
+
+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,237 @@
+# OnForm
+
+A pragmatism-first library to help Rails applications migrate from complex nested attribute models to tidy form objects.
+
+Our goal is that you can migrate large forms to OnForm incrementally, without having to refactor large amounts of code in a single release.
+
+Data and validations flow back and forward from the model layer automatically once you've defined which model attributes should be exposed.
+
+Forms backed by multiple models are supported natively, with no concept of a single main model.
+
+ActiveModel/ActiveRecord idioms such as validations and callbacks can be used directly in the form object.
+
+Whereever possible, the terminology and experience should be familiar to Rails developers, to minimize relearning time.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'on_form', '~> 1.0'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install on_form
+
+## Usage
+
+This version of OnForm should work with Rails 5.0 and 4.2.
+
+This version of OnForm depends on both the `activemodel` and `activerecord` gems.  Rails 5.0 has refactored some of the necessary ActiveRecord code across to ActiveModel, so the `activerecord` dependency may be dropped once Rails 4.2 support is dropped.
+
+### Simple example of wrapping a model
+
+Let's say you have a big fat legacy model called `Customer`, and you have a preferences controller:
+
+	class PreferencesController
+	  def show
+	    @customer = Customer.find(params[:id])
+	  end
+
+	  def update
+	    @customer = Customer.find(params[:id])
+	    @customer.update!(params[:customer].permit(:name, :email, :phone_number)
+	    redirect_to preferences_path(@customer)
+	  rescue ActiveRecord::RecordInvalid
+	    render :show
+	  end
+	end
+
+Let's wrap the customer object in a form object.  Ideally we'd call this `@customer_form`, but you may not feel you have time to go and update all your view code, so in this example we'll keep calling it `@customer`.
+
+	class PreferencesController
+	  def show
+	    @customer = PreferencesForm.new(Customer.find(params[:id]))
+	  end
+
+	  def update
+	    @customer = PreferencesForm.new(Customer.find(params[:id]))
+	    @customer.update!(params[:customer])
+	  rescue ActiveRecord::RecordInvalid
+	    render :show
+	  end
+	end
+
+Now we need to make our form object.  At this point we need to tell the form object which attributes on the model we want to expose.  (In this example we have just one model and a couple of attributes, but you wouldn't bother using this library if this was all you had.)
+
+	class PreferencesForm < OnForm::Form
+	  expose :customer => %i(name email phone_number)
+
+	  def initialize(customer)
+	    @customer = customer
+	  end
+	end
+
+The form object responds to the usual persistance methods like `email`, `email=`, `save`, `save!`, `update`, and `update!`.  
+
+It will automatically write those exposed attributes back onto the models, and *it exposes any validation errors from those fields on the form object itself* - you don't have to copy them back manually or move your field validation code over to get started.  It'll also expose any errors on base on the models whose attributes you exposed.
+
+### A multi-model form
+
+You aren't limited to having one primary model - if your form is made up of multiple models pass more than one key to `expose`, or call it multiple times if you prefer.  They'll automatically be saved in the same order you declared them.
+
+In this example, the new models we're exposing are associated with the first one, so we don't need to pass them in to the constructor.
+
+	class HouseListingForm < OnForm::Form
+	  expose :house => %i(street_number street_name city),
+	         :vendor => %i(name phone_number)
+
+	  def initialize(house)
+	    @house = house
+	    @vendor = house.vendor
+	  end
+	end
+
+Transactions will automatically be started so that _all_ database updates will be rolled back if _any_ record fails to save (for example, due to a validation error).
+
+Note that the keys are the name of the methods on the form object which return the records, not the class names.  In this example, vendor might actually be an instance of our `Customer` model from the earlier examples.
+
+### Model accessor methods
+
+In the previous example, the constructor set `@house` and `@vendor` because these variables correspond to the names passed to `expose`.  `expose` will automatically add an `attr_reader` for each key it's given, meaning you only need to set the instance variables.
+
+But if you prefer, you can define a method with the same name yourself, for example using delegation.  `expose` won't run `attr_reader` if you've already defined the method, and there's no requirement to set an instance variable.
+
+	class HouseListingForm < OnForm::Form
+	  delegate :vendor, :to => :house
+
+	  expose :house => %i(street_number street_name city),
+	         :vendor => %i(name phone_number)
+
+	  def initialize(house)
+	    @house = house
+	  end
+	end
+
+You can also define your own method over the top of the `attr_reader`.  Just remember it will be called more than once, so it should be idempotent.
+
+### Validations
+
+Validations on the underlying models not only get used, but their validation errors show up on the form's `errors` object directly when you call `valid?` or any of the save/update methods.
+
+But you can also declare validations on the form object itself, which is useful when you have business rules applicable to this form that aren't intrinsic to the domain model.
+
+	class AddEmergencyContactForm < OnForm::Form
+	  expose :customer => %i(next_of_kin_name next_of_kin_phone_number)
+
+	  validates_presence_of :next_of_kin_name, :next_of_kin_phone_number
+
+	  def initialize(customer)
+	    @customer = customer
+	  end
+	end
+
+Note that when you call `save!`, `update!`, or `update_attributes!` on the form object, validation errors from records will still raise `ActiveRecord::RecordInvalid`, but validation errors from validations defined on the form itself will raise `ActiveModel::ValidationError`.  You will usually want to rescue both.
+
+### Callbacks
+
+You can also use the `before_validation`, `before_save`, `after_save`, and `around_save` validations.  Like ActiveRecord, these will run inside the database transaction when you're calling one of the save or update methods, which is especially useful if you need to take locks on parent records.
+
+	class NewBranchForm < OnForm::Form
+	  expose :branch => %w(bank_id branch_number branch_name)
+
+	  before_save :lock_bank
+
+	protected
+	  def lock_bank
+	    branch.bank.lock!
+      end
+	end
+
+Note that model save calls are nested inside the form save calls, which means that although form validation takes place before form save starts, model validation takes place after form saving begins.
+
+    form before_validation
+    form validate (validations defined on the form itself)
+    form before_save
+    form around_save begins
+      model before_validation
+      model validate (validations defined on the model)
+      model before_save
+      model around_save begins
+        model saved
+      model around_save ends
+      model after_save
+    form around_save ends
+    form after_save
+
+### Reusing and extending forms
+
+You can descend form classes from other form classes and expose additional models or additional attributes on existing models.
+
+	class AdminHouseListingForm < HouseListingForm
+	  expose :house => %i(listing_approved)
+	end
+
+This works well for some use cases, but can quickly become cumbersome if you have a lot of partial form reuse, and it may not be obvious to other developers that the parent form is also used to derive the other forms.  Consider breaking your form parts into reuseable modules, and defining each form separately.
+
+You can use standard Ruby hooks for this:
+
+	module AccountFormComponent
+	  def self.included(form)
+	    form.expose :customer => %i(email phone_number)
+	  end
+	end
+
+	class NewAccountForm < OnForm::Form
+	  include AccountFormComponent
+
+	  expose :customer => %i(name)
+
+	  def initialize(customer)
+	    @customer = customer
+	  end
+	end
+
+	class EditAccountForm < OnForm::Form
+	  include AccountFormComponent
+
+	  delegate :name, to: :customer
+
+	  def initialize(customer)
+	    @customer = customer
+	  end
+	end
+
+In this example the initialize method could actually be moved to the module as well, but that makes it harder to compose forms from multiple modules.
+
+If you prefer, you can use the Rails `included` block syntax in the module instead of `def self.included`.
+
+## Development
+
+After checking out the repo, pick the rails version you'd like to run tests against, and run:
+
+	RAILS_VERSION=5.0.0.1 bundle update
+
+You should then be able to run the test suite:
+
+	bundle exec rake
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/powershop/on_form.
+
+## Roadmap
+
+* For version 2, the author is looking into support for declaring attributes on the form.  (You can use plain old Ruby object `attr_accessor` for untyped attributes in the meantime.)
+* After that we'll need to tackle the other use cases for ActiveRecord nested attributes, such as one-to-many associations and auto-building/deleting associated records.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+Copyright &copy; Powershop New Zealand Limited, 2016

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+end
+
+desc "Run tests"
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "on_form"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/on_form/attributes.rb

@@ -0,0 +1,64 @@
+module OnForm
+  module Attributes
+    # the individual attribute methods are introduced by the expose_attribute class method.
+    # here we introduce some methods used for the attribute set as a whole.
+
+    def [](attribute_name)
+      send(attribute_name)
+    end
+
+    def []=(attribute_name, attribute_value)
+      send("#{attribute_name}=", attribute_value)
+    end
+
+    def read_attribute_for_validation(attribute_name)
+      send(attribute_name)
+    end
+
+    def write_attribute(attribute_name, attribute_value)
+      send("#{attribute_name}=", attribute_value)
+    end
+
+    def attribute_names
+      self.class.exposed_attributes.values.reduce(:+).collect(&:to_s)
+    end
+
+    def attributes
+      attribute_names.each_with_object({}) do |attribute_name, results|
+        results[attribute_name] = self[attribute_name]
+      end
+    end
+
+    def attributes=(attributes)
+      # match ActiveRecord #attributes= behavior on nil, scalars, etc.
+      raise ArgumentError, "When assigning attributes, you must pass a hash as an argument." unless attributes.is_a?(Hash)
+
+      multiparameter_attributes = {}
+      attributes.each do |attribute_name, attribute_value|
+        attribute_name = attribute_name.to_s
+        if attribute_name.include?('(')
+          multiparameter_attributes[attribute_name] = attribute_value
+        else
+          write_attribute(attribute_name, attribute_value)
+        end
+      end
+      assign_multiparameter_attributes(multiparameter_attributes)
+    end
+
+  private
+    def backing_model(backing_model_name)
+      send(backing_model_name)
+    end
+
+    def backing_models
+      self.class.exposed_attributes.keys.collect { |backing_model_name| backing_model(backing_model_name) }
+    end
+
+    def backing_object_for_attribute(attribute_name)
+      self.class.exposed_attributes.each do |backing_model_name, attribute_names|
+        return backing_model(backing_model_name) if attribute_names.include?(attribute_name.to_sym)
+      end
+      nil
+    end
+  end
+end

data/lib/on_form/errors.rb

@@ -0,0 +1,22 @@
+module OnForm
+  module Errors
+    def errors
+      @errors ||= ActiveModel::Errors.new(self)
+    end
+
+  private
+    def reset_errors
+      @errors = nil
+    end
+
+    def collect_errors
+      self.class.exposed_attributes.each do |backing_model_name, exposed_attributes_on_backing_model|
+        backing_model(backing_model_name).errors.each do |backing_attribute, attribute_errors|
+          if backing_attribute == :base || exposed_attributes_on_backing_model.include?(backing_attribute)
+            Array(attribute_errors).each { |error| errors[backing_attribute] << error }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/on_form/form.rb

@@ -0,0 +1,48 @@
+module OnForm
+  class Form
+    include ActiveModel::Validations
+    include ActiveModel::Validations::Callbacks
+
+    include Attributes
+    include MultiparameterAttributes
+    include Errors
+    include Saving
+
+    def self.exposed_attributes
+      @exposed_attributes ||= Hash.new { |h, k| h[k] = [] }
+    end
+
+    class << self
+      def inherited(child)
+        exposed_attributes.each { |k, v| child.exposed_attributes[k].concat(v) }
+      end
+    end
+
+    def self.expose(backing_models_and_attribute_names)
+      backing_models_and_attribute_names.each do |backing_model_name, attribute_names|
+        backing_model_name = backing_model_name.to_sym
+        expose_backing_model(backing_model_name)
+        attribute_names.each do |attribute_name|
+          expose_attribute(backing_model_name, attribute_name)
+        end
+      end
+    end
+
+    def self.expose_backing_model(backing_model_name)
+      unless instance_methods.include?(backing_model_name)
+        attr_reader backing_model_name
+      end
+    end
+
+    def self.expose_attribute(backing_model_name, attribute_name)
+      exposed_attributes[backing_model_name] << attribute_name.to_sym
+
+      [attribute_name, "#{attribute_name}_before_type_cast", "#{attribute_name}?"].each do |attribute_method|
+        define_method(attribute_method) { backing_model(backing_model_name).send(attribute_method) }
+      end
+      ["#{attribute_name}="].each do |attribute_method|
+        define_method(attribute_method) { |arg| backing_model(backing_model_name).send(attribute_method, arg) }
+      end
+    end
+  end
+end

data/lib/on_form/multiparameter_attributes.rb

@@ -0,0 +1,67 @@
+# unlike the rest of this library, which is new code, the code in this source file is from ActiveRecord, and
+# is used to provide compatibility wrappers with different versions of ActiveRecord.  please keep it separate
+# so we can see where everything came from and what may need to be kept in sync with ActiveRecord refactors.
+module OnForm
+  module MultiparameterAttributes
+    # Instantiates objects for all attribute classes that needs more than one constructor parameter. This is done
+    # by calling new on the column type or aggregation type (through composed_of) object with these parameters.
+    # So having the pairs written_on(1) = "2004", written_on(2) = "6", written_on(3) = "24", will instantiate
+    # written_on (a date type) with Date.new("2004", "6", "24"). You can also specify a typecast character in the
+    # parentheses to have the parameters typecasted before they're used in the constructor. Use i for Integer and
+    # f for Float. If all the values for a given attribute are empty, the attribute will be set to +nil+.
+    def assign_multiparameter_attributes(pairs)
+      execute_callstack_for_multiparameter_attributes(
+        extract_callstack_for_multiparameter_attributes(pairs)
+      )
+    end
+
+    def execute_callstack_for_multiparameter_attributes(callstack)
+      errors = []
+      callstack.each do |name, values_with_empty_parameters|
+        begin
+          if defined?(ActiveRecord::AttributeAssignment::MultiparameterAttribute)
+            # ActiveRecord 4.2 and below: you must use MultiparameterAttribute to construct the attribute value.
+            # we therefore have to look up which model the attribute actually lives on.
+            send("#{name}=", ActiveRecord::AttributeAssignment::MultiparameterAttribute.new(backing_object_for_attribute(name), name, values_with_empty_parameters).read_value)
+          else
+            # ActiveRecord 5.0+: you can assign the indexed hash to the column and it will construct the value for you.
+            if values_with_empty_parameters.each_value.all?(&:nil?)
+              values = nil
+            else
+              values = values_with_empty_parameters
+            end
+            send("#{name}=", values)
+          end
+        rescue => ex
+          errors << ActiveRecord::AttributeAssignmentError.new("error on assignment #{values_with_empty_parameters.values.inspect} to #{name} (#{ex.message})", ex, name)
+        end
+      end
+      unless errors.empty?
+        error_descriptions = errors.map(&:message).join(",")
+        raise ActiveRecord::MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes [#{error_descriptions}]"
+      end
+    end
+
+    def extract_callstack_for_multiparameter_attributes(pairs)
+      attributes = {}
+
+      pairs.each do |(multiparameter_name, value)|
+        attribute_name = multiparameter_name.split("(").first
+        attributes[attribute_name] ||= {}
+
+        parameter_value = value.empty? ? nil : type_cast_attribute_value(multiparameter_name, value)
+        attributes[attribute_name][find_parameter_position(multiparameter_name)] ||= parameter_value
+      end
+
+      attributes
+    end
+
+    def type_cast_attribute_value(multiparameter_name, value)
+      multiparameter_name =~ /\([0-9]*([if])\)/ ? value.send("to_" + $1) : value
+    end
+
+    def find_parameter_position(multiparameter_name)
+      multiparameter_name.scan(/\(([0-9]*).*\)/).first.first.to_i
+    end
+  end
+end

data/lib/on_form/saving.rb

@@ -0,0 +1,79 @@
+module OnForm
+  module Saving
+    def self.included(base)
+      base.define_model_callbacks :save
+    end
+
+    def transaction(&block)
+      with_transactions(backing_models, &block)
+    end
+
+    def invalid?
+      !valid?
+    end
+
+    def save!
+      reset_errors
+      transaction do
+        reset_errors
+        unless run_validations!(backing_model_validations: false)
+          raise ActiveModel::ValidationError, self
+        end
+        run_callbacks :save do
+          begin
+            backing_models.each { |backing_model| backing_model.save! }
+          rescue ActiveRecord::RecordInvalid, ActiveModel::ValidationError
+            collect_errors
+            raise
+          end
+        end
+      end
+      true
+    end
+
+    def save
+      save!
+    rescue ActiveRecord::RecordInvalid, ActiveModel::ValidationError
+      false
+    end
+
+    def update(attributes)
+      transaction do
+        self.attributes = attributes
+        save
+      end
+    end
+
+    def update!(attributes)
+      transaction do
+        self.attributes = attributes
+        save!
+      end
+    end
+
+    alias :update_attributes :update
+    alias :update_attributes! :update!
+
+  private
+    def with_transactions(models, &block)
+      if models.empty?
+        block.call
+      else
+        models.shift.transaction do
+          with_transactions(models, &block)
+        end
+      end
+    end
+
+    def run_validations!(backing_model_validations: true)
+      super()
+      run_backing_model_validations if backing_model_validations
+      errors.empty?
+    end
+
+    def run_backing_model_validations
+      backing_models.collect { |backing_model| backing_model.valid? }
+      collect_errors
+    end
+  end
+end

data/lib/on_form/version.rb

@@ -0,0 +1,3 @@
+module OnForm
+  VERSION = "1.0.0"
+end

data/lib/on_form.rb

@@ -0,0 +1,8 @@
+require "active_model"
+require "active_record"
+require "on_form/version"
+require "on_form/attributes"
+require "on_form/multiparameter_attributes"
+require "on_form/errors"
+require "on_form/saving"
+require "on_form/form"

data/on_form.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'on_form/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "on_form"
+  spec.version       = OnForm::VERSION
+  spec.authors       = ["Will Bryant"]
+  spec.email         = ["will.bryant@gmail.com"]
+
+  spec.summary       = %q{A pragmatism-first library to help Rails applications migrate from complex nested attribute models to tidy form objects.}
+  spec.description   = %q{Our goal is that you can migrate large forms to OnForm incrementally, without having to refactor large amounts of code in a single release.}
+  spec.homepage      = "https://github.com/powershop/on_form"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activemodel",  ENV["RAILS_VERSION"]
+  spec.add_dependency "activerecord", ENV["RAILS_VERSION"]
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "sqlite3"
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: on_form
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Will Bryant
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-09-17 00:00:00.000000000 Z
+dependencies:
+- !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: activerecord
+  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.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.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: Our goal is that you can migrate large forms to OnForm incrementally,
+  without having to refactor large amounts of code in a single release.
+email:
+- will.bryant@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/on_form.rb
+- lib/on_form/attributes.rb
+- lib/on_form/errors.rb
+- lib/on_form/form.rb
+- lib/on_form/multiparameter_attributes.rb
+- lib/on_form/saving.rb
+- lib/on_form/version.rb
+- on_form.gemspec
+homepage: https://github.com/powershop/on_form
+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.5.1
+signing_key: 
+specification_version: 4
+summary: A pragmatism-first library to help Rails applications migrate from complex
+  nested attribute models to tidy form objects.
+test_files: []