params_transformer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ca2ee806c79e9da2902e579ace95f197a7ef3196
+  data.tar.gz: 9705896c5e98c95f851fb2e7788653a208dd3ab7
+SHA512:
+  metadata.gz: 45833176a07027ea42df957c0064ac4fc346182f733902eb08fb57bd0fcf7a923f43ab27b39e60dc3c980014532f558de73e58275f17a61245eb6c5e317d615a
+  data.tar.gz: 865aef3d52e8d98b19fb9e18e012e13c86e9af73cc80a0c28ed8bae3ce243e542ecec0398e6ec4e9c660f8a8aeff51804216656cc8e6d5a6c6e93ab72f036b6f

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,17 @@
+PATH
+  remote: .
+  specs:
+    params_transformer (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (10.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.9)
+  params_transformer!
+  rake (~> 10.0)

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 "params_transformer"
+```
+
+```
+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 "params_transformer"
+
+# 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/lib/params_transformer/directory_parser.rb

@@ -0,0 +1,21 @@
+module ParamsTransformer
+  class DirectoryParser
+    attr_reader :current_class_name, :relevant_classes
+
+    def initialize(args = {})
+      @current_class_name = args[:current_class_name]
+      @relevant_classes = set_relevant_classes
+    end
+
+    def set_relevant_classes
+      relevant_classes = [current_class_name]
+      classes = current_class_name.split("::")
+      while classes.present?
+        classes.pop
+        possibility = classes.join("::")
+        relevant_classes << possibility unless possibility.exclude?("::")
+      end
+      return relevant_classes
+    end
+  end
+end

data/lib/params_transformer/input.rb

@@ -0,0 +1,40 @@
+module ParamsTransformer
+  class Input
+
+    attr_accessor :current_instance, :name, :default, :input_value, :type, :variable_name, :options
+
+    def initialize(current_instance, name, type, input_value, options = {})
+      @current_instance = current_instance
+      @name = name
+      @default = perform_default(options[:default])
+      @input_value = input_value || @default
+      @type = type || input_value.class
+      @variable_name = options[:variable_name] || @name
+      @options = options
+    end
+
+    def value_parser
+      @value_parser ||= "ParamsTransformer::ValueParser::#{type.to_s.classify}".constantize.new(options.merge({
+        input_value: input_value,
+        variable_name: variable_name
+      }))
+    end
+
+    def parsed_value
+      @parsed_value ||= value_parser.parse
+    end
+
+    def perform_default(default_value)
+      if default_value.is_a?(Symbol)
+        current_instance.send(default_value)
+      else
+        default_value
+      end
+    end
+
+    def association?
+      [:has_many, :belongs_to, :has_one].include?(type)
+    end
+
+  end
+end

data/lib/params_transformer/transformer.rb

@@ -0,0 +1,68 @@
+module ParamsTransformer
+  class Transformer
+    attr_reader :params, :inputs
+    attr_accessor :inputs
+
+    def initialize(args)
+      @params = Rails.version[0].to_i > 4 ? args.to_h.with_indifferent_access : HashWithIndifferentAccess.new(args)
+      @inputs = set_inputs
+      after_init(@params)
+    end
+
+    def transform
+      hash = {}
+      inputs.each do |input|
+        value = instance_variable_get("@#{input.variable_name}")
+
+        # only set values to nil when they are intended to be nil
+        next if value.nil? && (input.association? || params.keys.exclude?(input.name.to_s))
+
+        hash[input.variable_name] = value
+      end
+      hash
+    end
+
+    def self.input(name, type = nil, options = {})
+      @@input_definitions ||= {}
+      array = @@input_definitions[self.name].present? ? @@input_definitions[self.name] : []
+      array << [name, type, options]
+      @@input_definitions[self.name] = array
+    end
+
+    def self.input_definitions
+      @@input_definitions
+    end
+
+    private
+
+      def set_inputs
+        setter = ParamsTransformer::DirectoryParser.new(current_class_name: self.class.name)
+        all_inputs = []
+        ParamsTransformer::Transformer.input_definitions.each do |class_name, form_inputs|
+          next unless setter.relevant_classes.include?(class_name)
+          form_inputs.each do |form_input|
+            all_inputs << set_input(form_input)
+          end
+        end
+        all_inputs
+      end
+
+      def set_input(form_input)
+        name = form_input[0]
+        type = form_input[1]
+        options = form_input[2]
+        input_value = params[name]
+        input = ParamsTransformer::Input.new(self, name, type, input_value, options)
+        self.class.__send__(:attr_accessor, input.variable_name)
+        instance_variable_set("@#{input.variable_name.to_s}", input.parsed_value)
+        return input
+      end
+
+      # METHODS FOR CHILDREN
+      def after_init(args)
+        # this method is optionally implemented by children to
+        # override default initialization behavior
+      end
+  end
+end
+

data/lib/params_transformer/value_parser/attachment.rb

@@ -0,0 +1,9 @@
+module ParamsTransformer
+  class ValueParser
+    class Attachment < ValueParser
+      def parse
+        return input_value
+      end
+    end
+  end
+end

data/lib/params_transformer/value_parser/belongs_to.rb

@@ -0,0 +1,12 @@
+module ParamsTransformer
+  class ValueParser
+    class BelongsTo < ValueParser
+      include ParamsTransformer::ValueParser::Relationship
+
+      def parse
+        return input_value unless input_value.present?
+        transformer.new(input_value).transform
+      end
+    end
+  end
+end

data/lib/params_transformer/value_parser/boolean.rb

@@ -0,0 +1,14 @@
+module ParamsTransformer
+  class ValueParser
+    class Boolean < ValueParser
+      def parse
+        return nil if input_value.nil?
+        return nil if input_value == "on"
+        return true if input_value == "1"
+        return true if input_value == true
+        return true if input_value == "true"
+        return false
+      end
+    end
+  end
+end

data/lib/params_transformer/value_parser/date.rb

@@ -0,0 +1,19 @@
+module ParamsTransformer
+  class ValueParser
+    class Date < ValueParser
+
+      attr_reader :parse_format
+
+      def after_init(args)
+        @parse_format = args[:parse_format] || "%m/%d/%Y"
+      end
+
+      def parse
+        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/params_transformer/value_parser/datetime.rb

@@ -0,0 +1,17 @@
+module ParamsTransformer
+  class ValueParser
+    class DateTime < ValueParser
+      attr_reader :input_format
+
+      def after_init(args)
+        @input_format = args[:input_format] || "%m/%d/%Y"
+      end
+
+      def parse
+        return input_value unless input_value.present?
+        return input_value if input_value.is_a?(DateTime)
+        ::Date.strptime(input_value, input_format)
+      end
+    end
+  end
+end

data/lib/params_transformer/value_parser/float.rb

@@ -0,0 +1,13 @@
+module ParamsTransformer
+  class ValueParser
+    class Float < ValueParser
+      REGEX = /(\d|[.])/
+
+      def parse
+        return input_value unless input_value.present?
+        return input_value if ["Float", "Fixnum"].include?(input_value.class.name)
+        input_value.scan(REGEX).join.try(:to_f)
+      end
+    end
+  end
+end

data/lib/params_transformer/value_parser/has_many.rb

@@ -0,0 +1,40 @@
+module ParamsTransformer
+  class ValueParser
+    class HasMany < ValueParser
+      include ParamsTransformer::ValueParser::Relationship
+
+      # should return a pattern like...
+      # {
+      #   loads_attributes: {
+      #     "0" => {
+      #       pays_fuel_surcharge: true,
+      #       pickup_datetime: #datetime_object
+      #     }
+      #   }
+      # }
+      def parse
+        return input_value unless input_value.present?
+        parse_hash if input_value.is_a?(Hash)
+        parse_array if input_value.is_a?(Array)
+      end
+
+      def parse_hash
+        hash = {}
+        input_value.each do |index, obj_hash|
+          object_hash = transformer.new(obj_hash).transform
+          hash[index] = object_hash
+        end
+        hash
+      end
+
+      def parse_array
+        hash = {}
+        input_value.each_with_index do |obj_hash, index|
+          object_hash = transformer.new(obj_hash).transform
+          hash[index] = object_hash
+        end
+        hash
+      end
+    end
+  end
+end

data/lib/params_transformer/value_parser/has_one.rb

@@ -0,0 +1,19 @@
+module ParamsTransformer
+  class ValueParser
+    class HasOne < ValueParser
+      include ParamsTransformer::ValueParser::Relationship
+
+      # should return a pattern like...
+      # {
+      #   document_attributes: {
+      #     name: "Name of doc",
+      #     date: #datetime_object
+      #   }
+      # }
+      def parse
+        return input_value unless input_value.present?
+        transformer.new(input_value).transform
+      end
+    end
+  end
+end

data/lib/params_transformer/value_parser/integer.rb

@@ -0,0 +1,14 @@
+module ParamsTransformer
+  class ValueParser
+    class Integer < ValueParser
+      REGEX = /(\d|[.])/
+
+      def parse
+        return 0 unless input_value.present?
+        return input_value if input_value.is_a?(Fixnum)
+        return input_value.to_i if input_value.is_a?(Float)
+        input_value.scan(REGEX).join.try(:to_i)
+      end
+    end
+  end
+end

data/lib/params_transformer/value_parser/nil_class.rb

@@ -0,0 +1,9 @@
+module ParamsTransformer
+  class ValueParser
+    class NilClass < ValueParser
+      def parse
+        input_value
+      end
+    end
+  end
+end

data/lib/params_transformer/value_parser/phone.rb

@@ -0,0 +1,13 @@
+module ParamsTransformer
+  class ValueParser
+    class Phone < ValueParser
+      REGEX = /(\d|[.])/
+
+      def parse
+        return nil unless input_value.present?
+        return input_value if input_value.is_a?(Fixnum)
+        input_value.scan(REGEX).join.try(:to_s)
+      end
+    end
+  end
+end

data/lib/params_transformer/value_parser/relationship.rb

@@ -0,0 +1,12 @@
+module ParamsTransformer
+  class ValueParser
+    module Relationship
+      attr_reader :transformer
+
+      def after_init(args = {})
+        @transformer = args[:transformer]
+        raise "An associated transformer class is required for #{self.class.name} input" unless @transformer.present?
+      end
+    end
+  end
+end

data/lib/params_transformer/value_parser/string.rb

@@ -0,0 +1,9 @@
+module ParamsTransformer
+  class ValueParser
+    class String < ValueParser
+      def parse
+        input_value.try(:to_s)
+      end
+    end
+  end
+end

data/lib/params_transformer/value_parser/zip.rb

@@ -0,0 +1,10 @@
+module ParamsTransformer
+  class ValueParser
+    class Zip < ValueParser
+      def parse
+        return nil unless input_value.present?
+        input_value.try(:to_s)
+      end
+    end
+  end
+end

data/lib/params_transformer/value_parser.rb

@@ -0,0 +1,35 @@
+require 'params_transformer/value_parser/relationship'
+require 'params_transformer/value_parser/attachment'
+require 'params_transformer/value_parser/belongs_to'
+require 'params_transformer/value_parser/boolean'
+require 'params_transformer/value_parser/date'
+require 'params_transformer/value_parser/datetime'
+require 'params_transformer/value_parser/float'
+require 'params_transformer/value_parser/has_many'
+require 'params_transformer/value_parser/has_one'
+require 'params_transformer/value_parser/integer'
+require 'params_transformer/value_parser/nil_class'
+require 'params_transformer/value_parser/phone'
+require 'params_transformer/value_parser/string'
+require 'params_transformer/value_parser/zip'
+
+module ParamsTransformer
+  class ValueParser
+
+    attr_accessor :input_value
+
+    def initialize(args = {})
+      @input_value = args[:input_value]
+      after_init(args)
+    end
+
+    def parse
+      # implemented by child classes
+    end
+
+    def after_init(args)
+      # optionally implemented by child classes
+    end
+
+  end
+end

data/lib/params_transformer/version.rb

@@ -0,0 +1,3 @@
+module ParamsTransformer
+  VERSION = '0.0.1'
+end

data/lib/params_transformer.rb

@@ -0,0 +1,9 @@
+module ParamsTransformer
+
+end
+
+require 'params_transformer/version'
+require 'params_transformer/value_parser'
+require 'params_transformer/input'
+require 'params_transformer/directory_parser'
+require 'params_transformer/transformer'

data/params_transformer.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'params_transformer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "params_transformer"
+  spec.version       = ParamsTransformer::VERSION
+  spec.authors       = ["Ryan Francis"]
+  spec.email         = ["ryan.p.francis@gmail.com"]
+
+  spec.summary       = %q{Rails form parser}
+  spec.description   = %q{Framework for intuitively parsing Rails forms}
+  spec.homepage      = "https://github.com/francirp/params_transformer"
+  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_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: params_transformer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ryan Francis
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-02-12 00:00:00.000000000 Z
+dependencies:
+- !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'
+description: Framework for intuitively parsing Rails forms
+email:
+- ryan.p.francis@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/params_transformer.rb
+- lib/params_transformer/directory_parser.rb
+- lib/params_transformer/input.rb
+- lib/params_transformer/transformer.rb
+- lib/params_transformer/value_parser.rb
+- lib/params_transformer/value_parser/attachment.rb
+- lib/params_transformer/value_parser/belongs_to.rb
+- lib/params_transformer/value_parser/boolean.rb
+- lib/params_transformer/value_parser/date.rb
+- lib/params_transformer/value_parser/datetime.rb
+- lib/params_transformer/value_parser/float.rb
+- lib/params_transformer/value_parser/has_many.rb
+- lib/params_transformer/value_parser/has_one.rb
+- lib/params_transformer/value_parser/integer.rb
+- lib/params_transformer/value_parser/nil_class.rb
+- lib/params_transformer/value_parser/phone.rb
+- lib/params_transformer/value_parser/relationship.rb
+- lib/params_transformer/value_parser/string.rb
+- lib/params_transformer/value_parser/zip.rb
+- lib/params_transformer/version.rb
+- params_transformer.gemspec
+homepage: https://github.com/francirp/params_transformer
+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: Rails form parser
+test_files: []