formant 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0ef99a58902f6fdda0ef94e433385faa28d6d45d
+  data.tar.gz: 90212569c9a2edc2f82f6f1723fad875a8d36e3c
+SHA512:
+  metadata.gz: f1a28c65af280f5b1b98c0dcfd4a931dca84efd2d827756c163913a1f066af2b5ec609ebc4a45af80efc75d383dc9f98250fdcf660b5fa513e517411a99ad003
+  data.tar.gz: ced2edd67ec3e4334be521f228e5445f8d0e8d7a0f09248171a4aef492d494b7ee2572f47436d85a0da33ea91ad19b3600cac4f9358883d3197a554904237fa7

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+cache: bundler
+
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1
+  - 2.2.2
+  - jruby
+  - rbx-2
+
+before_install: gem install bundler -v 1.10.6
+script: 'bundle exec rake'

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## 0.1.1 2015-08-17
+[changed] Make phony_rails gem a runtime dependency.
+[changed] Internal test changes, switch to use activeSupport::TestCase.
+[changed] Set random US timezone in test helper to help flush out timezone bugs.
+
+## 0.1.1 2015-08-17
+[changed] Updated dependencies in gemspec.
+
+## 0.1.0 2015-08-17
+Initial release.

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Anthony Garcia
+
+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,329 @@
+# Formant
+
+[![Build Status](https://travis-ci.org/polypressure/formant.svg?branch=master)](https://travis-ci.org/polypressure/formant)
+[![Test Coverage](https://codeclimate.com/github/polypressure/formant/badges/coverage.svg)](https://codeclimate.com/github/polypressure/formant/coverage)
+[![Code Climate](https://codeclimate.com/github/polypressure/formant/badges/gpa.svg)](https://codeclimate.com/github/polypressure/formant)
+[![security](https://hakiri.io/github/polypressure/formant/master.svg)](https://hakiri.io/github/polypressure/formant/master)
+[![Dependency Status](https://gemnasium.com/polypressure/formant.svg)](https://gemnasium.com/polypressure/formant)
+
+
+
+Formant is a tiny library that provides a simplified, minimalistic form object implementation for Rails applications. A form object is a simple, (mostly) plain-old Ruby object, separate from your ActiveRecord models, that lets you collect and validate input. A bit more specifically, Formant helps you to keep any input parsing, normalization, validation, and formatting logic related to form processing out of your ActiveRecord models, ensuring that they stay lean and focused on persistence.
+
+Form objects also simplify the collection of input from complicated forms. With form objects, when collecting input that involves multiple ActiveRecord models, you can avoid having to use something like `accepts_nested_attributes_for`. Instead, you define a single form object containing all the necessary fields spanning multiple models. You use this single form object in place of the multiple ActiveRecord models within your view, form, and controller. You can then parse, normalize, and validate that input in one place, and pass/distribute the form field values to whatever number of model objects are required by your business logic.
+
+With Formant, you can declaratively specify any special parsing and normalization logic to apply to the form field values upon input (i.e. right before validation). Some built-in examples of parsing/normalizing input include:
+
+* Stripping leading and trailing whitespace, and squishing internal whitespace.
+* Parsing date/time strings using the current timezone.
+* Normalizing phone numbers into a consistent internal format, e.g. "+13125551212" for storage in the database.
+* Normalizing and parsing currency strings into a BigDecimal.
+
+Once parsed and normalized, Formant then applies any validation rules that you've specified, using the standard validation macros provided by ActiveRecord. These can be invoked as usual, i.e. with the `valid?`, `invalid?`, or `validate` methods.
+
+Formant also lets you specify special formatting rules on fields upon output (typically, when redisplaying forms). Some built-in examples of formatting output include:
+
+* Rendering date/time values using localized string formats.
+* Displaying phone numbers in a standard format, e.g. "(312) 555-1212"
+* Formatting a BigDecimal value as a currency/price string.
+* Formatting a number delimited with commas and decimal points.
+
+
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'formant'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install formant
+
+
+### Configuration
+
+Add the following to your `config/application.rb`:
+
+```ruby
+module MyApplication
+  class Application < Rails::Application
+    ...
+    config.autoload_paths << Rails.root.join('forms')
+  end
+end
+```
+
+You can create a locale file containing date/time formats named `time_formats.en.yml`. In a standard Rails application, this file would go in the `config/locales` directory, and would look something like this:
+
+```ruby
+en:
+  time:
+    formats:
+      day_date_time: '%a, %b %e, %l:%M %p'
+      time_day_date: '%l:%M %p - %a %b %e'
+      fullday_date_time: '%A, %B %e, %l:%M %p'
+
+```
+
+## Usage
+
+Define your form as a subclass of `Formant::FormObject`, specify the fields using `attr_accessor`, then specify parsing, validation, and formatting rules. Your form objects should go in the app/forms directory:
+
+```ruby
+class AppointmentForm < FormObject
+
+  attr_accessor(
+    :starts_at,
+    :first_name, :last_name,
+    :phone, :email,
+    :monthly_revenue,
+    :some_big_number
+  )
+
+  #
+  # Rules for any special parsing/transformation upon input…
+  #
+
+  # This parses datetime strings using the current Time.zone
+  # into a ActiveSupport::TimeWithZone object:
+  parse :starts_at, as: :datetime
+
+  # This normalizes phone numbers into a consistent internal format
+  # (with no dashes, dots, or other separators, and a leading "+1").
+  # For example, if the user passes in a phone number in the format
+  # "312-555-1212" or "(312)555.1212", it will be normalized
+  # into the format "+13125551212":
+  parse :phone, as: :phone_number
+
+  # This normalizes and parses a string price (possibly containing
+  # currency symbols, commas, and decimal points) into a BigDecimal
+  # value:
+  parse :monthly_revenue, as: :currency
+
+
+  # This strips leading and trailing whitespace from the field values:
+  parse :last_name, to: :strip_whitespace
+  parse :email, to: :strip_whitespace
+  # This also collapses multiple consecutive internal spaces into a single space:
+  parse :first_name, to: :strip_whitespace, squish: true
+
+
+  #
+  # Rules for any special formatting/transformation upon output
+  # or redisplay of the form. These will be triggered by invoking
+  # the FormObject#reformatted! method…
+  #
+
+  # This reformats the datetime in the :starts_at field using the
+  # format specified by the :day_date_time key, which can be defined
+  # in config/locales/time_formats.en.yml file:
+  reformat :starts_at, as: :datetime, format: :day_date_time
+
+  # This reformats the phone number in the :phone field into a
+  # standard format for the 'US'. For a phone number normalized
+  # to "+13125551212", the reformatted number is "(312) 555-1212":
+  reformat :phone, as: :phone_number, country_code: 'US'
+
+  # This reformats the BigDecimal in the :monthly_revenue field
+  # into a string, eg. "$10,252.32". You can pass it options as
+  # defined in http://api.rubyonrails.org/classes/ActionView/Helpers/NumberHelper.html#method-i-number_to_currency
+  reformat :monthly_revenue, as: :currency
+
+  # This reformats the number in the :some_big_number field into
+  # string delimited with commas and decimal points, e.g.
+  # "25,123.08". You can pass it options as # defined in
+  # http://api.rubyonrails.org/classes/ActionView/Helpers/NumberHelper.html#method-i-number_with_delimiter
+  reformat :some_big_number, as: :number_with_delimiter
+
+  #
+  # Validation rules, as usual:
+  #
+  validates :starts_at, presence: true
+  validate :in_future
+
+  validates :first_name, presence: true
+  validates :last_name, presence: true
+
+  validates_plausible_phone :phone, presence: true
+  validates :email, presence: true, email: true
+
+  def in_future
+    errors.add(:starts_at, "must be in the future") if starts_at && starts_at.past?
+  end
+
+end
+```
+
+In your controller, instantiate a FormObject by passing it the request params, then validate the input params by calling either `valid?` or `invalid?`. If validation succeeds, you can then pass the form field values to any models or business-logic objects. If validation fails, you can redisplay the form as usual, passing the form object (rather than the model object) to the view—just as you would with an ActiveRecord model:
+
+```ruby
+class AppointmentsController < ApplicationController
+
+  def create
+    appointment_form = AppointmentForm.new(appointment_params)
+
+    #
+    # Ideally, this should be in a separate business-logic object,
+    # we're showing this logic inline within the controller for
+    # the sake of simplicity:
+    #
+    if appointment_form.invalid?
+      @appointment_form = appointment_form.reformatted!
+      render :new and return
+    end
+
+    client = Client.new(
+      first_name: appointment_form.first_name,
+      last_name: appointment_form.last_name,
+      phone: appointment_form.phone,
+      email: appointment_form.email
+    )  
+
+    appointment = Appointment.new(
+      starts_at: appointment_form.starts_at
+    )
+
+    client.save!
+    appointment.save!
+
+    redirect_to appointments_path, notice: "Your appointment has been booked."
+  end
+
+end
+```
+
+Your form looks just as it normally would, but rather than using your ActiveRecord models directly, you use the form object instead. Here's an example written in the Slim templating language:
+
+```ruby
+h4 Make an appointment
+
+= form_for(@appointment_form, url: appointments_url) do |f|
+  = render "shared/validation_errors", errors: @appointment_form.errors
+
+  .row.collapse
+    .small-2.columns
+      = f.text_field :starts_at, placeholder: 'Date/Time', required: true
+    .small-2.columns
+      = f.text_field :first_name, placeholder: 'First Name', required: true
+    .small-2.columns
+      = f.text_field :last_name, placeholder: 'Last Name', required: true
+    .small-2.columns
+      = f.text_field :phone, placeholder: 'Phone', required: true
+    .small-2.columns
+      = f.text_field :email, placeholder: 'Email', required: true, type: 'email'
+
+  .row
+    .small-12.columns
+      = f.button 'Submit'
+```
+You can see that you can access the fields and the validation errors as you usually would with an ActiveRecord model.
+
+### Other stuff
+
+You can get a params hash of all the form object's attribute by calling `to_params`.
+
+You can register callbacks to be invoked before and after validation:
+
+```ruby
+class MyForm < Formant::FormObject
+  ...
+
+  before_validation :do_stuff_before_validation
+  after_validation  :do_stuff_after_validation
+
+  ...
+
+  def do_stuff_before_validation
+    # Some pre-validation logic.
+  end
+
+  def do_stuff_after_validation
+    # Some post validation logic.
+  end
+
+end
+
+```
+
+## Additional parsing and reformatting rules
+
+Parsing and formatting rules can be added trivially. Here is an example for how you would add rules for converting a blank string into a nil:
+
+```ruby
+#
+#
+module BlankAsNil
+
+  #
+  # All parse rule methods must have a name beginning with
+  # the prefix "parse_" and ending with the parse rule type.
+  # In this example, the parse rule type is "slug".
+  #
+  # The method signature should always be as follows: the first
+  # argument is field_value, in which Formant passes the unparsed
+  # value of the form field/attribute. The second argument
+  # contains a hash of any options required by your parse rule
+  # logic.
+  #
+  # Your parse method should return the parsed value of course.
+  # Formant takes care of assigning it to the field attribute.
+  #
+  def parse_blank_into_nil(field_value, options={})
+    field_value.nil? || (field_value.is_a?(String) && field_value !~ /\S/) ? nil : field_value
+  end
+
+
+  #
+  # For a reformatting rule, it's pretty much the same thing,
+  # except you replace the "parse_" prefix in the method name
+  # with "format_".
+  #
+  # This is an example for formatting numbers with a delimiter,
+  # assuming Formant didn't already provide this:
+  #
+  def format_number_with_delimiter(field_value, options={})
+    number_with_delimiter(field_value, options)
+  end
+
+end
+
+#
+# You can then specify that the parse rule can be used as normal
+# with the parse macro/directive:
+#
+class MyForm < Formant::FormObject
+  include MoreParsingAndFormattingRules
+
+  attr_accessor :title, :some_number
+
+  parse :title, as: :blank_into_nil
+  format :some_number, as: :number_with_delimiter
+end
+
+
+
+```
+
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/polypressure/formant/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'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = "test/*_test.rb"
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "formant"
+
+# 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,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/formant.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'formant/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "formant"
+  spec.version       = Formant::VERSION
+  spec.authors       = ["Anthony Garcia"]
+  spec.email         = ["polypressure@outlook.com"]
+
+  spec.summary       = "Minimalist form object implementation."
+  spec.homepage      = "https://github.com/polypressure/formant"
+  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_runtime_dependency 'phony_rails', '~> 0.12.9'
+  
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "activemodel", "~>4.0"
+  spec.add_development_dependency "activesupport", "~>4.0"
+  spec.add_development_dependency "actionview", "~>4.0"
+  spec.add_development_dependency "minitest", "~> 5.5"
+  spec.add_development_dependency 'm', '~> 1.3', '>= 1.3.1'
+  spec.add_development_dependency 'minitest-reporters', '~> 1.0', '>= 1.0.19'
+  spec.add_development_dependency "codeclimate-test-reporter", '~> 0.4.7'
+
+end

data/lib/formant.rb

@@ -0,0 +1,186 @@
+require "formant/version"
+
+require 'active_model'
+require 'active_support/all'
+require 'action_view'
+require 'phony_rails'
+
+
+module Formant
+  include ActionView::Helpers::NumberHelper
+
+  #
+  # Base class for Form objects.
+  #
+  # See https://www.reinteractive.net/posts/158-form-objects-in-rails
+  # (among others) for more info on form objects for more details.
+  #
+  # This is a simplified implementation of form objects that focuses
+  # on collecting input in a PORO, specifying any special parsing
+  # and transformation on fields upon input (i.e., before validation),
+  # and special formatting/transformation on fields for display/output
+  # and redisplay of forms.
+  #
+  class FormObject
+
+    include ActiveModel::Model
+    include ActiveModel::Validations::Callbacks
+
+    before_validation :parse_fields!
+
+    class << self
+      attr_accessor :parse_fields, :format_fields
+    end
+
+    #
+    # Directive to add a parse rule for the specified attribute.
+    # Parse rules let you apply any special parsing/transformation
+    # logic on the form's attributes upon input. The parsing rules
+    # are applied automatically prior to validation.
+    #
+    # Usage example:
+    #
+    # class MyForm < FormObject
+    #   ...
+    #   parse :appointment_time, as: :datetime
+    #   parse :phone, as: :phone_number
+    #   parse :price, as: :currency
+    #   parse :email, to: :strip_whitespace
+    #   ...
+    # end
+    #
+    # The above example specifies that the appointment_time attribute
+    # should be parsed with the parse_datetime method (which converts
+    # the datetime string into an ActiveSupport::TimeWithZone object),
+    # and that the # phone attribute should be parsed with the
+    # parse_phone_number method (which normalizes the phone number into
+    # a standard format).
+    #
+    def self.parse(field_name, options={})
+      self.parse_fields ||= []
+      parse_type = options[:as] || options[:to]
+      raise "no parse type provided" if parse_type.blank?
+      self.parse_fields << [ field_name, "parse_#{parse_type}", options ]
+    end
+
+    #
+    # Directive to add a reformat rule for the specified attribute.
+    # These let you apply any special formatting/normalization
+    # logic on the form's attributes upon output. Typically you want
+    # to do this when you have to redisplay a form.
+    #
+    # The format rules are triggered when the FormObject#reformatted!
+    # method is invoked, which modifies the attribute in place.
+    #
+    # Usage example:
+    #
+    # class MyForm < FormObject
+    #   ...
+    #   reformat :appointment_time, as: :datetime, format: :day_date_time
+    #   reformat :phone, as: :phone_number, country_code: 'US'
+    #   ...
+    # end
+    #
+    # The above example specifies that the appointment_time attribute
+    # should be reformatted with the format_datetime method (using the format
+    # specified in the locale file with the :day_date_time key), and that
+    # the phone attribute should be parsed with the parse_phone_number
+    # method, and a fixed country_code of 'US'
+    #
+    def self.reformat(field_name, options={})
+      self.format_fields ||= []
+      self.format_fields << [ field_name, "format_#{options[:as]}", options ]
+    end
+
+    #
+    # Triger any formatting rules specified with the reformat directive.
+    # The attributes are reformatted and mutated in place.
+    #
+    # Returns an instance of the form object.
+    #
+    def reformatted!
+      self.class.format_fields.each do |field_name, format_method, options|
+        formatted_value = send(format_method, get_field(field_name), options)
+        set_field(field_name, formatted_value)
+      end
+      self
+    end
+
+    #
+    # Return all the attributes as a params hash.
+    #
+    def to_params
+      attrs = Hash.new
+      instance_variables.each do |ivar|
+        name = ivar[1..-1]
+        attrs[name.to_sym] = instance_variable_get(ivar) if respond_to? "#{name}="
+      end
+      attrs
+    end
+
+
+    private
+
+    def parse_datetime(field_value, options={})
+      Time.zone.parse(field_value || '')
+    end
+
+    def parse_phone_number(field_value, options={})
+      cc = options[:country_code] || 'US'
+      PhonyRails.normalize_number(field_value, country_code: cc)
+    end
+
+    def parse_currency(field_value, options={})
+      if field_value.is_a?(String)
+        field_value.gsub(/[^0-9\.]+/, '').to_d
+      elsif field_value.is_a?(Numeric)
+        field_value.to_d
+      else
+        field_value
+      end
+    end
+
+    def parse_strip_whitespace(field_value, options={})
+      return field_value unless field_value.is_a?(String)
+      options[:squish] ? field_value.squish : field_value.strip if field_value
+    end
+
+    def format_datetime(field_value, options={})
+      I18n.l(field_value, options).squish if field_value
+    end
+
+    def format_phone_number(field_value, options={})
+      field_value.phony_formatted(options) if field_value
+    end
+
+    def format_currency(field_value, options={})
+      ActionView::Base.new.number_to_currency(field_value, options) if field_value
+    end
+
+    def format_number_with_delimiter(field_value, options={})
+      ActionView::Base.new.number_with_delimiter(field_value, options)
+    end
+
+    def parse_fields!
+      self.class.parse_fields.each do |field_name, parse_method, options|
+        parsed_value = send(parse_method, get_field(field_name), options)
+        set_field(field_name, parsed_value)
+      end
+      true
+    end
+
+    def get_field(field_name)
+      instance_variable_get(as_sym(field_name))
+    end
+
+    def set_field(field_name, value)
+      instance_variable_set(as_sym(field_name), value)
+    end
+
+    def as_sym(field_name)
+      field = "@#{field_name}".to_sym
+    end
+
+  end
+
+end

data/lib/formant/version.rb

@@ -0,0 +1,3 @@
+module Formant
+  VERSION = "0.1.2"
+end

metadata

@@ -0,0 +1,209 @@
+--- !ruby/object:Gem::Specification
+name: formant
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Anthony Garcia
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-08-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: phony_rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.9
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !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: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+- !ruby/object:Gem::Dependency
+  name: m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.19
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.19
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.7
+description: 
+email:
+- polypressure@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- formant.gemspec
+- lib/formant.rb
+- lib/formant/version.rb
+homepage: https://github.com/polypressure/formant
+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.8
+signing_key: 
+specification_version: 4
+summary: Minimalist form object implementation.
+test_files: []