decanter 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a88b2e53932e63a9351db615b274f997a829bf40
+  data.tar.gz: 4deade7c29aa9321d62600ba8b2fa7da8a207ace
+SHA512:
+  metadata.gz: 3f7aa0df7b97a57191b74a9c8d46572d35fcbf1e1ab2447bb54fbabcb636e5f8274e32480e478bb21e10be846f82643a416f3e39682ad3eda4e4082f0d11055d
+  data.tar.gz: 6fcdc9bfb48de54cfb710a71137285067144b8d639be4ffb6bf939cfd9c8439aae1c70fb247b26990d5d3ce2621c8301ded78c5dbeb0a74772202b87457a0ed6

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,89 @@
+PATH
+  remote: .
+  specs:
+    decanter (0.5.0)
+      activesupport
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (4.2.4)
+      actionview (= 4.2.4)
+      activesupport (= 4.2.4)
+      rack (~> 1.6)
+      rack-test (~> 0.6.2)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    actionview (4.2.4)
+      activesupport (= 4.2.4)
+      builder (~> 3.1)
+      erubis (~> 2.7.0)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    activesupport (4.2.4)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    builder (3.2.2)
+    diff-lcs (1.2.5)
+    erubis (2.7.0)
+    i18n (0.7.0)
+    json (1.8.3)
+    loofah (2.0.3)
+      nokogiri (>= 1.5.9)
+    mini_portile (0.6.2)
+    minitest (5.8.2)
+    nokogiri (1.6.6.2)
+      mini_portile (~> 0.6.0)
+    rack (1.6.4)
+    rack-test (0.6.3)
+      rack (>= 1.0)
+    rails-deprecated_sanitizer (1.0.3)
+      activesupport (>= 4.2.0.alpha)
+    rails-dom-testing (1.0.7)
+      activesupport (>= 4.2.0.beta, < 5.0)
+      nokogiri (~> 1.6.0)
+      rails-deprecated_sanitizer (>= 1.0.1)
+    rails-html-sanitizer (1.0.2)
+      loofah (~> 2.0)
+    railties (4.2.4)
+      actionpack (= 4.2.4)
+      activesupport (= 4.2.4)
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rake (10.4.2)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-rails (3.3.3)
+      actionpack (>= 3.0, < 4.3)
+      activesupport (>= 3.0, < 4.3)
+      railties (>= 3.0, < 4.3)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+    thor (0.19.1)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.9)
+  decanter!
+  rake (~> 10.0)
+  rspec-rails
+
+BUNDLED WITH
+   1.10.6

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 TODO: Write your name
+
+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,370 @@
+ParamsTransformer
+===
+
+Installation
+---
+
+Add Gem:
+
+```ruby
+gem "decanter"
+```
+
+```
+bundle
+```
+
+
+Basic Usage
+---
+
+Create a class to process your form and have it inherit from ParamsTransformer::Base. I typically create the following folder to hold my form classes: app/classes/forms
+
+**app/classes/forms/property.rb**
+
+```ruby
+class Forms::Property < ParamsTransformer::Base
+
+  input :bedrooms, :integer
+  input :price, :float
+  input :has_air_conditioning, :boolean
+  input :has_parking, :boolean
+  input :has_laundry, :boolean
+
+end
+```
+
+In your controller:
+
+```ruby
+  def create
+    @form = Forms::Property.new(params)
+
+    if @form.save
+      redirect_to trips_path
+    else
+      set_index_variables
+      render "index"
+    end
+  end
+```
+
+Inheritance
+---
+
+General pattern:
+
+- forms/property.rb
+- forms/property/create.rb (inherits from forms/property.rb)
+- forms/property/update.rb (inherits from forms/property.rb)
+
+
+```ruby
+# app/classes/forms/property.rb
+class Forms::Property < ParamsTransformer::Base
+
+  input :bedrooms, :integer
+  input :price, :float
+  input :referred_by, :string
+
+end
+
+
+# app/classes/forms/property/create.rb
+class Forms::Property::Create < Forms::Property
+
+  # override any input, validation, or method here
+
+end
+```
+
+class Forms::Property::Update < Forms::Property
+
+  # override any input, validation, or method here
+
+end
+```
+
+Associations
+---
+
+Let's say we are creating a web app where teacher's can create Courses with assignments and resources attached to the courses.
+
+The modeling would look like:
+
+class Course < ActiveRecord::Base
+
+  has_many :assignments
+  has_many :resources
+
+end
+
+
+
+Why a Library for Parsing Forms?
+---
+
+In my humble opinion, Rails is missing a tool for parsing forms on the backend. Currently the process looks something like this:
+
+```html
+# new.html.erb
+<%= form_for @trip do |trip_builder| %>
+  <div class="field">
+    <%= trip_builder.label :miles %>
+    <%= trip_builder.text_field :miles, placeholder: '50 miles' %>
+  </div>
+<% end %>
+```
+
+```ruby
+  # trips_controller
+
+  def create
+    @trip = Trip.new(trip_params)
+
+    if @trip.save
+      redirect_to trips_path, notice: "New trip successfully created."
+    else
+      render "new"
+    end
+  end
+```
+
+The problem with this approach is that there is nothing that processes the user inputs before being saved into the database. For example, if the user types "1,000 miles" into the form, Rails would store 0 instead of 1000 into our "miles" column.
+
+The "Services" concept that many Rails developers favor is on point. Every form should have a corresponding Ruby class whose responsibility is to process the inputs and get the form ready for storage.
+
+However, this "Services" concept does not have a supporting framework. It is repetitive for every developer, for example, to write code to parse a decimal field that comes into our Ruby controller as a string (as in the example above).
+
+Here is how it may be done right now:
+
+```ruby
+class Forms::Trip
+
+  attr_accessor :trip
+
+  def initialize(args = {})
+    @trip = Trip.new
+    @trip.miles = parse_miles(args[:miles)
+  end
+
+  def parse_miles(miles_input)
+    regex = /(\d|[.])/ # only care about numbers and decimals
+    miles_input.scan(regex).join.try(:to_f)
+  end
+
+  def save
+    @trip.save
+  end
+
+end
+```
+
+```ruby
+  # trips_controller.rb
+
+  def create
+    form = Forms::Trip.new(trip_params)
+    @trip = form.trip
+
+    if form.save
+      redirect_to trips_path, notice: "New trip successfully created."
+    else
+      render "new"
+    end
+  end
+```
+
+While this process is not so bad with only one field and one model, it gets more complex with many different fields, types of inputs, and especially with nested attributes.
+
+A better solution is to have the form service classes inherit from a base "form parser" class that can handle the common parsing needs of the community. For example:
+
+```ruby
+class Forms::Trip < FormParse::Base
+
+  input :miles, :float
+
+  def after_init(args)
+    @trip = Trip.new(to_hash)
+  end
+
+end
+```
+
+```ruby
+  # trips_controller.rb
+  # same as above
+
+  def create
+    form = Forms::Trip.new(trip_params)
+    @trip = form.trip
+
+    if form.save
+      redirect_to trips_path, notice: "New trip successfully created."
+    else
+      render "new"
+    end
+  end
+```
+
+The FormParse::Base class that Forms::Trip inherits from by default performs the proper regex as seen in the original Forms::Trip service object above. We need only define the input key and the type of input and the base class takes care of the heavy lifting.
+
+The "to_hash" method takes the inputs and converts the parsed values into a hash, which produces the following in this case:
+
+```ruby
+  { miles: 1000.0 }
+```
+
+A more complex form would end up with a service class like below:
+
+```ruby
+class Forms::Trip
+
+  attr_accessor :trip
+
+  def initialize(args = {})
+    @trip = Trip.new
+    @trip.miles = parse_miles(args[:miles)
+    @trip.origin_city = args[:origin_city]
+    @trip.origin_state = args[:origin_state]
+    @trip.departure_datetime = parse_datetime(args[:departure_datetime])
+    @trip.destination_city = args[:destination_city]
+    @trip.destination_state = args[:destination_state]
+    @trip.arrival_datetime = parse_datetime(args[:arrival_datetime])
+  end
+
+  def parse_miles(miles_input)
+    regex = /(\d|[.])/ # only care about numbers and decimals
+    miles_input.scan(regex).join.try(:to_f)
+  end
+
+  def parse_datetime(datetime_input)
+    Date.strptime(datetime, "%m/%d/%Y")
+  end
+
+  def save
+    @trip.save
+  end
+
+end
+```
+
+With a framework, it would only involve the following:
+
+```ruby
+class Forms::Trip < FormParse::Base
+
+  input :miles, :float
+  input :origin_city, :string
+  input :origin_state, :string
+  input :departure_datetime, :datetime
+  input :destination_city, :string
+  input :destination_state, :string
+  input :arrival_datetime, :datetime
+
+  def after_init(args)
+    @trip = Trip.new(to_hash)
+  end
+
+  # to_hash produces:
+  # {
+  #   miles: 1000.0,
+  #   origin_city: "Chicago",
+  #   origin_state: "IL",
+  #   departure_datetime: # DateTime object
+  #   destination_city: "New York",
+  #   destination_state: "NY",
+  #   arrival_datetime: # DateTime object
+  # }
+
+end
+```
+
+Taking it a step further, if our form inputs are not database backed, we can even validate within our new service object like so:
+
+```ruby
+class FormParse::Base
+  include ActiveModel::Model
+
+  # ... base parsing code
+end
+
+class Form::Trip < FormParse::Base
+
+  input :miles, :float
+  input :origin_city, :string
+  input :origin_city, :string
+  input :destination_city, :string
+  input :destination_state, :string
+
+  validates :miles, :origin_city, :origin_state, :destination_city, :destination_state, presence: true
+
+  def after_init(args)
+    @trip = Trip.new(to_hash)
+  end
+
+  def save
+    if valid? && trip.valid?
+      trip.save
+    else
+      return false
+    end
+  end
+
+end
+```
+
+Of course, the save method could be abstracted to our base class too, assuming we define which object the Form::Trip class is saving like so:
+
+```ruby
+class Form::Trip
+
+  def object
+    trip
+  end
+
+  # ... above code here
+end
+
+class FormParse::Base
+
+  def save
+    if valid? && object.valid?
+      object.save
+    else
+      return false
+    end
+  end
+end
+
+```
+
+But where we really can see benefits from a "framework" for parsing our Rails forms is when we start to use nested attributes. For example, if we abstract the origin and destination fields to a "Location" model, we could build out a separate service class to handle parsing our "Location" form (even if it is in the context of a parent object like Trip).
+
+```ruby
+class Forms::Location < FormParse::Base
+
+  input :city, :string
+  input :state, :string
+  input :departure_datetime, :datetime
+  input :arrival_datetime, :datetime
+
+  validates :city, :state :presence => true
+
+end
+
+class Forms::Trip < FormParse::Base
+
+  input :miles, :float
+  input :origin_attributes, :belongs_to, class: 'location'
+  input :destination_attributes, :belongs_to, class: 'location'
+
+  validates :miles, presence: true
+
+  def after_init(args)
+    @trip = Trip.new(to_hash)
+  end
+end
+```
+
+The FormParse::Base class will recoginze the :belongs_to relationship and utilize the Location service class to parse the part of the params hash that correspond with our destination and origin models. This is great because if there is anywhere that the user can update just the origin or destination of the trip, we could just reuse that Location service object to parse the form.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "decanter"
+
+# 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/decanter.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'decanter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "decanter"
+  spec.version       = Decanter::VERSION
+  spec.authors       = ["Ryan Francis", "Dave Corwin"]
+  spec.email         = ["ryan@launchpadlab.com"]
+
+  spec.summary       = %q{Form Parser for Rails}
+  spec.description   = %q{Decanter aims to reduce complexity in Rails controllers by creating a place for transforming data before it hits the model and database.}
+  spec.homepage      = "https://github.com/launchpadlab/decanter"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  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 "activesupport"
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec-rails"
+end

data/lib/decanter.rb

@@ -0,0 +1,23 @@
+module Decanter
+
+  @@decanters = {}
+
+  def self.register(decanter)
+    @@decanters[decanter.name] = decanter
+  end
+
+  def self.decanter_for(klass_or_sym)
+    name = klass_or_sym.is_a?(Class) ?
+            klass_or_sym.name :
+            klass_or_sym.to_s.singularize.capitalize
+
+    @@decanters["#{name}Decanter"] || (raise NameError.new("unknown decanter #{name}Decanter"))
+  end
+end
+
+require 'decanter/version'
+require 'active_support/inflector'
+require 'decanter/base'
+require 'decanter/core'
+require 'decanter/extensions'
+require 'decanter/value_parser'

data/lib/decanter/base.rb

@@ -0,0 +1,7 @@
+require 'decanter/core'
+
+module Decanter
+  class Base
+    include Core
+  end
+end

data/lib/decanter/core.rb

@@ -0,0 +1,106 @@
+module Decanter
+  module Core
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      Decanter.register(base)
+    end
+
+    module ClassMethods
+
+      def associations
+        @associations ||= {}
+      end
+
+      def inputs
+        @inputs ||= {}
+      end
+
+      def input(name, type, **options)
+        set_input options, {
+          name:    name,
+          options: options.reject { |k| k == :context },
+          type:    type
+        }
+      end
+
+      def set_input(options, input_cfg)
+        set_for_context options, input_cfg, inputs
+      end
+
+      def input_for(name, context)
+        (inputs[context || :default] || {})[name]
+      end
+
+      def has_many(name, **options)
+        set_association options, {
+          key:     options[:key] || "#{name}_attributes".to_sym,
+          name:    name,
+          options: options.reject { |k| k == :context },
+          type:    :has_many
+        }
+      end
+
+      def has_one(name, **options)
+        set_association options, {
+          key:     options[:key] || "#{name}_attributes".to_sym,
+          name:    name,
+          options: options.reject { |k| k == :context },
+          type:    :has_one
+        }
+      end
+
+      def has_many_for(key, context)
+        (associations[context || :default] || {})
+          .detect { |name, assoc| assoc[:type] == :has_many && assoc[:key] == key}
+      end
+
+      def has_one_for(key, context)
+        (associations[context || :default] || {})
+          .detect { |name, assoc| assoc[:type] == :has_one && assoc[:key] == key}
+      end
+
+      def set_association(options, assoc)
+        set_for_context options, assoc, associations
+      end
+
+      def set_for_context(options, arg, hash)
+        context = options[:context] || @context || :default
+        hash[context] = {} unless hash.has_key? context
+        hash[context][arg[:name]] = arg
+      end
+
+      def with_context(context, &block)
+        raise NameError.new('no context argument provided to with_context') unless context
+
+        @context = context
+        block.arity.zero? ? instance_eval(&block) : block.call(self)
+        @context = nil
+      end
+
+      def decant(args={}, context=nil)
+        Hash[
+          args.map { |name, value| handle_arg(name, value, context) }.compact
+        ]
+      end
+
+      def handle_arg(name, value, context)
+        case
+        when input_cfg = input_for(name, context)
+          [name, parse(input_cfg[:type], value)]
+        when assoc = has_one_for(name, context)
+          [assoc.pop[:key], Decanter::decanter_for(assoc.first).decant(value, context)]
+        when assoc = has_many_for(name, context)
+          decanter = Decanter::decanter_for(assoc.first)
+          [assoc.pop[:key], value.map { |val| decanter.decant(val, context) }]
+        else
+          context ? nil : [name, value]
+        end
+      end
+
+      def parse(type, val)
+        ValueParser.value_parser_for(type).parse(val)
+      end
+    end
+  end
+end

data/lib/decanter/extensions.rb

@@ -0,0 +1,34 @@
+module Decanter
+  module Extensions
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def decant_update(args={}, context=nil)
+      self.attributes = self.decant(args, context)
+      self.save(context: context)
+    end
+
+    def decant_update!(args={}, context=nil)
+      self.attributes = self.decant(args, context)
+      self.save!(context: context)
+    end
+
+    module ClassMethods
+
+      def decant_create(args={}, context=nil)
+        self.new(decant(args, context)).save(context: context)
+      end
+
+      def decant_create!(args={}, context=nil)
+        self.new(decant(args, context)).save!(context: context)
+      end
+
+      def decant(args, context)
+        decanter_for(self).decant(args, context)
+      end
+    end
+  end
+end
+ActiveRecord::Base.include(Decanter::Extensions) if defined? ActiveRecord

data/lib/decanter/value_parser.rb

@@ -0,0 +1,18 @@
+module Decanter
+  module ValueParser
+    @@value_parsers = {}
+
+    def self.register(value_parser)
+      @@value_parsers[value_parser.name] = value_parser
+    end
+
+    def self.value_parser_for(sym)
+      @@value_parsers["#{sym.to_s.capitalize}Parser"] || (raise NameError.new("unknown value parser #{sym.to_s.capitalize}Parser"))
+    end
+  end
+end
+
+require_relative 'value_parser/base'
+require_relative 'value_parser/core'
+require_relative 'value_parser/boolean_parser'
+require_relative 'value_parser/string_parser'

data/lib/decanter/value_parser/base.rb

@@ -0,0 +1,8 @@
+module Decanter
+  module ValueParser
+    class Base
+      include Core
+    end
+  end
+end
+

data/lib/decanter/value_parser/boolean_parser.rb

@@ -0,0 +1,16 @@
+module Decanter
+  module ValueParser
+    class BooleanParser < Base
+      def self.parse(val)
+        case val
+        when nil
+          nil
+        when 1, '1', true, 'true'
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/decanter/value_parser/core.rb

@@ -0,0 +1,16 @@
+module Decanter
+  module ValueParser
+    module Core
+      def self.included(base)
+        base.extend(ClassMethods)
+        ValueParser.register(base)
+      end
+
+      module ClassMethods
+        def parse(val)
+          val
+        end
+      end
+    end
+  end
+end

data/lib/decanter/value_parser/date_parser.rb

@@ -0,0 +1,13 @@
+module Decanter
+  module ValueParser
+    class DateParser < Base
+      def self.parse(val, options = {})
+        parse_format = options.fetch(:parse_format, '%m/%d/%Y')
+        return input_value unless input_value.present?
+        return input_value if input_value.is_a?(Date)
+        ::Date.strptime(input_value, parse_format)
+      end
+    end
+  end
+end
+

data/lib/decanter/value_parser/string_parser.rb

@@ -0,0 +1,9 @@
+module Decanter
+  module ValueParser
+    class StringParser < Base
+      def self.parse(val)
+        val && val.respond_to?(:to_s) ? val.to_s : nil
+      end
+    end
+  end
+end

data/lib/decanter/version.rb

@@ -0,0 +1,3 @@
+module Decanter
+  VERSION = '0.5.0'
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: decanter
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Ryan Francis
+- Dave Corwin
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-02-13 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: 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: rspec-rails
+  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: Decanter aims to reduce complexity in Rails controllers by creating a
+  place for transforming data before it hits the model and database.
+email:
+- ryan@launchpadlab.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- decanter.gemspec
+- lib/decanter.rb
+- lib/decanter/base.rb
+- lib/decanter/core.rb
+- lib/decanter/extensions.rb
+- lib/decanter/value_parser.rb
+- lib/decanter/value_parser/base.rb
+- lib/decanter/value_parser/boolean_parser.rb
+- lib/decanter/value_parser/core.rb
+- lib/decanter/value_parser/date_parser.rb
+- lib/decanter/value_parser/string_parser.rb
+- lib/decanter/version.rb
+homepage: https://github.com/launchpadlab/decanter
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+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: Form Parser for Rails
+test_files: []