vulcanize 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 462824bb0ed48d86a0dd6eb81d85a14959a77f4c
+  data.tar.gz: 43adbd9afbd615f43658ba3611dc00cdff919047
+SHA512:
+  metadata.gz: 9af8b2b4cf35288cbf6c4e5f5b9819d08cba4e69b34d68cd635f4c33da3f806f7591ae735fcd42146fb2d5bfffeb1588d275ba6c2147131dcdadf984e210fb62
+  data.tar.gz: e86a618092527ff2a320ea9afb9c7aaad857a5360eb9cf983c0036a3fd9fb7b2c0d27d586056f9d092af45c1d04ad0ac492a232ebfa3d631f477df0814db3712

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Peter Saxton
+
+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,280 @@
+# Vulcanize
+
+Form objects to handle coercing user input.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'vulcanize'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install vulcanize
+
+## Usage
+
+Forms consist of one or more attributes that are defined with a name, type and optional named parameters. Types are used to coerce the raw input and should be responsible for deciding a given inputs validity. If we have a `Name` domain object we can use it in a vulcanize form as follows. *Notes below on creating domain object*
+
+```rb
+class Form < Vulcanize::Form
+  attribute :name, Name
+end
+```
+
+The default behavior of an attribute is to coerce the input when it is valid, return `nil` when there is no input and to raise an error for invalid input.
+
+```rb
+# Create a form with a valid name
+form = Form.new :name => 'Peter'
+
+form.valid?
+# => true
+
+form.email
+# => #<Name:0x00000002a579e8 @value="Peter">
+```
+
+```rb
+# Create a form with a null name
+form = Form.new :name => nil
+
+form.valid?
+# => true
+
+form.email
+# => nil
+```
+
+```rb
+# Create a form with an invalid name
+form = Form.new :name => '<DANGER!!>'
+
+form.valid?
+# => false
+
+form.email
+# !! ArgumentError
+```
+
+### Error Handling
+
+Forms are designed to offer flexible error handling while limiting the ways that invalid can pass through to the core program. Each attribute method raises an error if the coercion fails or if raw input is missing from an attribute that was required. If a block is passed to the method then instead of failing the block will be called with the raw value and the error that would have been raised. This allows several different ways to handle bad input.
+
+Usecase 1: return raw input and error so the user can edit the raw value.
+
+```rb
+form = Form.new :name => '<DANGER!!>'
+
+value = form.email { |raw, _| raw }
+error = form.email { |_, error| error }
+```
+
+Usecase 2: return a default value and error which a user may use.
+
+```rb
+form = Form.new :start_date => 'bad input'
+
+value = form.start_date { |raw, _| DateTime.now }
+error = form.start_date { |_, error| error }
+```
+### Note
+
+All Ruby methods can take a block, this allows you to use the form in place of a domain object.
+
+```rb
+user.email { |raw, error| #Never called, user email method does not use a block }
+```
+
+### Default attribute
+Attributes may have a default value that will be returned instead of nil when the raw value is nil or empty.
+
+```rb
+class NullName
+  def value
+    'No name'
+  end
+end
+
+class DefaultForm < Vulcanize::Form
+  attribute :name, Name, :default => NullName.new
+end
+
+form = DefaultForm.new :name => ''
+
+form.valid?
+# => true
+
+form.name
+# => #<NullName:0x00000002aafb98>
+```
+
+### Required attribute
+Attributes can be specified as being required. When the raw value is nil or empty retrieving the attribute vale will raise an `AttributeRequired` error and the form will be invalid.
+
+```rb
+class RequiredForm < Vulcanize::Form
+  attribute :name, Name, :required => true
+end
+
+form = RequiredForm.new :name => ''
+
+form.valid?
+# => false
+
+form.name
+# !! Vulcanize::AttributeRequired
+```
+
+### Private attribute
+Sometimes input needs to be coerced or validated but should not be available outside the form. The classic example is password confirmation in a form.
+
+```rb
+class PasswordForm < Vulcanize::Form
+  attribute :password, Password, :required => true
+  attribute :password_confirmation, Password, :private => true
+
+  def valid?
+    unless password == password_confirmation
+      return false
+    end
+    super
+  end
+end
+```
+
+### Renamed attribute
+Vulcanize can also be used to handle any input that can be cast as a hash. JSON data for example. It may be that input fields need renaming. That can be done with the 'from' parameter.
+
+```rb
+class RenameForm < Vulcanize::Form
+  attribute :name, Name, :from => 'display_name'
+end
+
+form = RenameForm.new 'display_name' => 'Peter'
+
+form.valid?
+# => true
+
+form.values
+# => {:name => #<Name:0x00000002a579e8 @value="Peter">}
+```
+
+> Possible extension symbol option. if set true recases to symbol. if not leaves as input. default true. from could as be called field.
+
+### Domain objects
+
+The first step is to create your domain object. It should throw an ArgumentError if initialized with invalid arguments.
+
+As an example here is a very simple implementation of a name object which has these conditions.
+- It will always be capitalized
+- It must be between 2 and 20 characters
+
+```rb
+class Name
+  def initialize(raw)
+    section = raw[/^\w{2,20}$/]
+    raise ArgumentError unless section
+    @value = section.capitalize
+  end
+
+  attr_reader :value
+end
+```
+### Check boxes
+A common requirement is handling check boxes in HTML forms. There are two distinct requirements when handling these inputs. They are the 'optional check box' and the 'agreement check box'. Vulcanize provides a `CheckBox` coercer to handle these inputs.
+
+#### Optional check box
+With this check box the user is indicating true when it is checked and false when it is left unchecked. This can be achieved sing the default option
+
+```rb
+class OptionForm < Vulcanize::Form
+  attribute :recieve_mail, Vulcanize::Checkbox, :default => false
+end
+
+form = OptionForm.new
+
+form.recieve_mail
+# => false
+
+form.valid?
+# => true
+```
+
+#### Agreement checkbox
+This check box a user must select to continue. The check box checked should return a value of true. The check box left unchecked should invalidate the form.
+
+```rb
+class AgreementForm < Vulcanize::Form
+  attribute :agree_to_terms, Vulcanize::Checkbox, :required => true
+end
+
+form = AgreementForm.new
+
+form.agree_to_terms?
+# !! #<Vulcanize::AttributeRequired: is not present>
+
+form.valid?
+# => false
+```
+
+#### Note on Checkbox
+*`Vulcanize::CheckBox` returns true for an input of `'on'`. For all other values it raises an `ArgumentError`. This is to help debug if fields are incorrectly named.*
+
+## Standard types
+**NOT IMPLEMENTED**
+Vulcanize encourages using custom domain objects over ruby primitives. it is often miss-guided to use the primitives. I.e. 12 June 2030 is not a valid D.O.B for your users and '<|X!#' is not valid article body. However sometimes it is appropriate or prudent to use the basic types and for that reason you can specify the following as types of attributes.
+
+- String
+- Integer
+- Float
+
+##### Note on using standard types
+Often a reason to use standard types is because domain limitations on an input have not yet been defined. Instead of staying with strings consider using this minimal implementation.
+
+```rb
+class ArticleBody < String
+end
+```
+## TODO
+- section on testing
+- actual api docs, perhaps formatted as in [AllSystems](https://github.com/CrowdHailer/AllSystems#user-content-docs)
+- Handling collections, not necessary if always using custom collections
+- question mark methods
+- Pretty printing
+- equality
+- docs
+form.each { |attribute, value| puts "#{attribute}, #{value}" }
+# => :name, #<Name:0x00000002a579e8 @value="Peter">
+- symbolize input
+
+## Questions
+- Form object with required and default might make sense if default acts as null object?
+- Form object should have overwritable conditions on empty
+- Check out virtus Array and Hash they might need to be included in awesomeness
+  - There is no need for and array or hash type if Always defining collections
+  - general nesting structure checkout useuful music batch
+
+## Change log
+
+Developed using Documentation Driven Development.
+Few notes on Documentation Driven Development.
+- [one](http://tom.preston-werner.com/2010/08/23/readme-driven-development.html)
+- [two](http://24ways.org/2010/documentation-driven-design-for-apis)
+
+**[Pull request for block errors](https://github.com/CrowdHailer/vulcanize/pull/1)**
+
+## Contributing
+There is no code here yet. So at the moment feel free to contribute around discussing these docs. pull request with your suggestion sounds perfect.
+
+1. Fork it ( https://github.com/[my-github-username]/vulcanize/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,9 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+# Setup task for complete test suit
+desc "Run application test suite"
+Rake::TestTask.new("test") do |test|
+  test.pattern = "test/**/*_test.rb"
+  test.verbose = true
+end

data/lib/vulcanize.rb

@@ -0,0 +1,6 @@
+require "vulcanize/version"
+require "vulcanize/form"
+require "vulcanize/check_box"
+
+module Vulcanize
+end

data/lib/vulcanize/check_box.rb

@@ -0,0 +1,13 @@
+module Vulcanize
+  # Used to coerce input from <input type="checkbox" name="name">
+  # which by befault will send the following
+  #     checked:   {'name' => 'on'}
+  #     unchecked: {}
+  
+  CheckBox = Object.new
+
+  def CheckBox.new(raw)
+    return true if raw == 'on'
+    fail ArgumentError
+  end
+end

data/lib/vulcanize/form.rb

@@ -0,0 +1,63 @@
+module Vulcanize
+  AttributeRequired = Class.new(ArgumentError)
+  class Form
+    def self.attributes
+      @attributes ||= {}
+    end
+
+    def self.attribute(attribute_name, type, required: false, default: nil, from: nil, private: false)
+      attributes[attribute_name] = private
+
+      from = from || attribute_name
+
+      define_method attribute_name do |&block|
+        raw = input[from]
+
+        missing = raw.nil? || raw.empty?
+
+        fail AttributeRequired if required and missing
+        return default if missing
+
+        begin
+          return type.new raw
+        rescue ArgumentError => err
+          return block.call raw, err if block
+          raise
+        end
+      end
+      tmp_attributes = attributes
+      private attribute_name if private
+
+      define_method :attributes do
+        tmp_attributes
+      end
+    end
+
+    def initialize(input={})
+      input.keys.each do |key|
+        input[(key.to_sym rescue key) || key] = input.delete(key)
+      end
+      @input = input
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      attributes.each do |attribute, private|
+        unless private
+          yield attribute, public_send(attribute)
+        end
+      end
+    end
+
+    def valid?
+      attributes.keys.each(&method(:send))
+      true
+    rescue
+      false
+    end
+
+    attr_reader :input
+
+  end
+end

data/lib/vulcanize/version.rb

@@ -0,0 +1,3 @@
+module Vulcanize
+  VERSION = "0.1.0"
+end

data/test/check_box_test.rb

@@ -0,0 +1,17 @@
+require_relative './test_config'
+
+module Vulcanize
+  class CheckBoxTest < MiniTest::Test
+
+    def test_returns_true_for_checked_input
+      value = CheckBox.new 'on'
+      assert_equal true, value
+    end
+
+    def test_raises_argument_error_for_invalid_input
+      assert_raises ArgumentError do
+        CheckBox.new 'bad'
+      end
+    end
+  end
+end

data/test/default_attribute_test.rb

@@ -0,0 +1,32 @@
+require_relative './test_config'
+
+module Vulcanize
+  class DefaultAttributeTest < MiniTest::Test
+
+    def klass
+      return @klass if @klass
+      klass = Class.new Form
+      klass.attribute :item, TestType, :default => :default
+      @klass = klass
+    end
+
+    def teardown
+      @klass = nil
+    end
+
+    def test_attribute_returns_default_for_missing_input
+      form = klass.new
+      assert_equal :default, form.item
+    end
+
+    def test_attribute_returns_default_for_nil_input
+      form = klass.new :item => nil
+      assert_equal :default, form.item
+    end
+
+    def test_attribute_returns_default_for_blank_input
+      form = klass.new :item => ''
+      assert_equal :default, form.item
+    end
+  end
+end

data/test/private_attribute_test.rb

@@ -0,0 +1,30 @@
+require_relative './test_config'
+
+module Vulcanize
+  class PrivateAttributeTest < MiniTest::Test
+
+    def klass
+      return @klass if @klass
+      klass = Class.new Form
+      klass.attribute :item, TestType, :private => true
+      @klass = klass
+    end
+
+    def teardown
+      @klass = nil
+    end
+
+    def test_attribute_method_is_private
+      form = klass.new :item => 'valid'
+      assert_raises NoMethodError do
+        form.item
+      end
+    end
+
+    def test_private_attributes_do_not_show_up_in_each
+      form = klass.new :item => 'valid'
+      enumerator = form.each
+      assert_equal 0, enumerator.count
+    end
+  end
+end

data/test/renamed_attribute_test.rb

@@ -0,0 +1,22 @@
+require_relative './test_config'
+
+module Vulcanize
+  class RenamedAttributeTest < MiniTest::Test
+
+    def klass
+      return @klass if @klass
+      klass = Class.new Form
+      klass.attribute :item, TestType, :from => :other
+      @klass = klass
+    end
+
+    def teardown
+      @klass = nil
+    end
+
+    def test_attribute_is_fetched_from_optional_from_parameter
+      form = klass.new :other => 'valid'
+      assert_equal TestType, form.item.class
+    end
+  end
+end

data/test/required_attribute_test.rb

@@ -0,0 +1,53 @@
+require_relative './test_config'
+
+module Vulcanize
+  class RequiredAttributeTest < MiniTest::Test
+
+    def klass
+      return @klass if @klass
+      klass = Class.new Form
+      klass.attribute :item, TestType, :required => true
+      @klass = klass
+    end
+
+    def teardown
+      @klass = nil
+    end
+
+    def test_attribute_raises_exception_for_missing_input
+      form = klass.new
+      assert_raises Vulcanize::AttributeRequired do
+        form.item
+      end
+    end
+
+    def test_form_is_invalid_for_missing_input
+      form = klass.new
+      assert_equal false, form.valid?
+    end
+
+    def test_attribute_raises_exception_for_nil_input
+      form = klass.new :item => nil
+      assert_raises Vulcanize::AttributeRequired do
+        form.item
+      end
+    end
+
+    def test_form_is_invalid_for_nil_input
+      form = klass.new :item => nil
+      assert_equal false, form.valid?
+    end
+
+    def test_attribute_raises_exception_for_blank_input
+      form = klass.new :item => ''
+      assert_raises Vulcanize::AttributeRequired do
+        form.item
+      end
+    end
+
+    def test_form_is_invalid_for_blank_input
+      form = klass.new :item => ''
+      assert_equal false, form.valid?
+    end
+  end
+end

data/test/standard_attribute_test.rb

@@ -0,0 +1,98 @@
+require_relative './test_config'
+
+module Vulcanize
+  class StandardAttributeTest < MiniTest::Test
+
+    def klass
+      return @klass if @klass
+      klass = Class.new Form
+      klass.attribute :item, TestType
+      @klass = klass
+    end
+
+    def valid_form
+      @valid_form ||= klass.new :item => 'valid'
+    end
+
+    def invalid_form
+      @invalid_form ||= klass.new :item => 'invalid'
+    end
+
+    def teardown
+      @klass = nil
+      @valid_form = nil
+      @invalid_form = nil
+    end
+
+    def test_attribute_returns_coerced_item_for_valid_input
+      assert_equal TestType, valid_form.item.class
+    end
+
+    def test_form_is_valid_with_valid_input
+      assert_equal true, valid_form.valid?
+    end
+
+    def test_passes_attribute_name_and_attribute_value_to_each_block
+      array = []
+      valid_form.each { |name, value| array << name << value.class }
+      assert_equal [:item, TestType], array
+    end
+
+    def test_returns_an_enumerable_for_each_value
+      enumerator = valid_form.each
+      attribute_name, attribute_value = enumerator.next
+      assert_equal :item, attribute_name
+      assert_equal TestType, attribute_value.class
+    end
+
+    def test_attribute_returns_coerced_item_for_valid_input_from_string_key
+      form = klass.new 'item' => 'valid'
+      assert_equal TestType, form.item.class
+    end
+
+    def test_attribute_raises_error_if_input_was_invalid
+      assert_raises ArgumentError do
+        invalid_form.item
+      end
+    end
+
+    def test_attribute_with_invalid_input_passes_error_to_block
+      raw, error = invalid_form.item { |r, e| return r, e }
+      assert_equal ArgumentError.new, error
+    end
+
+    def test_attribute_with_invalid_input_passes_raw_value_to_block
+      raw, error = invalid_form.item { |r, e| return r, e }
+      assert_equal 'invalid', raw
+    end
+
+    def test_form_is_invalid_with_invalid_input
+      assert_equal false, invalid_form.valid?
+    end
+
+    def test_attribute_returns_nil_for_missing_input
+      form = klass.new
+      assert_equal nil, form.item
+    end
+
+    def test_attribute_returns_nil_for_nil_input
+      form = klass.new :item => nil
+      assert_equal nil, form.item
+    end
+
+    def test_attribute_returns_nil_for_blank_input
+      form = klass.new :item => ''
+      assert_equal nil, form.item
+    end
+
+    def test_attribute_name_can_be_defined_as_a_string
+      # This test is not necessary. In fact removing the symbolize coercion would allow any setup.
+      # klass = Class.new Form
+      # klass.attribute 'item', TestType
+      # form = klass.new :item => 'valid'
+      # puts form.attributes
+      # assert_equal TestType, valid_form.item.class
+    end
+
+  end
+end

data/test/test_config.rb

@@ -0,0 +1,14 @@
+require 'vulcanize'
+require 'minitest/autorun'
+require 'minitest/reporters'
+
+reporter_options = {color: true, slow_count: 5}
+Minitest::Reporters.use! [Minitest::Reporters::DefaultReporter.new(reporter_options)]
+
+module Vulcanize
+  class TestType
+    def initialize(value)
+      fail ArgumentError unless value == 'valid'
+    end
+  end
+end

data/vulcanize.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vulcanize/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "vulcanize"
+  spec.version       = Vulcanize::VERSION
+  spec.authors       = ["Peter Saxton"]
+  spec.email         = ["vulcanize@workshop14.io"]
+  spec.summary       = %q{Form objects for coercing user input to domain specific objects}
+  spec.description   = %q{Forms consist of one or more attributes that are defined with a name, type and optional parameters. Plain ruby classes are used to represent attribute type and should be responsible for coercing the raw input and deciding an inputs validity.}
+  spec.homepage      = "https://github.com/CrowdHailer/vulcanize"
+  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_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.4"
+  spec.add_development_dependency "minitest-reporters", "~> 1.0"
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: vulcanize
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Peter Saxton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Forms consist of one or more attributes that are defined with a name,
+  type and optional parameters. Plain ruby classes are used to represent attribute
+  type and should be responsible for coercing the raw input and deciding an inputs
+  validity.
+email:
+- vulcanize@workshop14.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/vulcanize.rb
+- lib/vulcanize/check_box.rb
+- lib/vulcanize/form.rb
+- lib/vulcanize/version.rb
+- test/check_box_test.rb
+- test/default_attribute_test.rb
+- test/private_attribute_test.rb
+- test/renamed_attribute_test.rb
+- test/required_attribute_test.rb
+- test/standard_attribute_test.rb
+- test/test_config.rb
+- vulcanize.gemspec
+homepage: https://github.com/CrowdHailer/vulcanize
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Form objects for coercing user input to domain specific objects
+test_files:
+- test/check_box_test.rb
+- test/default_attribute_test.rb
+- test/private_attribute_test.rb
+- test/renamed_attribute_test.rb
+- test/required_attribute_test.rb
+- test/standard_attribute_test.rb
+- test/test_config.rb