levee 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ac51414d35dc2d20439b9b06d0d7f82b84594fc2
+  data.tar.gz: 5a8172b7e1bd55767a34ebbb498cb832469d7a1f
+SHA512:
+  metadata.gz: 6493cba2bbe24d3b5364e0c784aeeb4c789ba7bf329fba3622c2d0e5d84fc5f2e664b8f2f22f5465549ca269a964f548dd69d709c25f6c84452c36c4f38e00f4
+  data.tar.gz: ac03887aac3e66fbf540e6a6121323e39bbe30b78316b5b7b6b9a7066dafcb009e1ef1c46c6131940af19972e35830bd46e179131bce968bd97532cf657131dc

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 levee.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Mike Martinson
+
+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,328 @@
+# Levee
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'levee'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install levee
+
+## Usage
+
+Overview
+------------------------
+
+The abstract builder and validator classes are abstract classes for concrete builder classes to inherit from. They will be extracted to a gem once they are imporved and generalized through this project.
+
+The purpose of the builder object is to create a layer of abstraction between the controller and models in a Rails application. The builder is particularly useful for receiving complex post and put requests with multiple parameters, but is lightweight enough to use for simple writes when some filtering or parameter combination validation might be useful before writing to the database. Since it wraps the entire write action to mulitple models in a single transaction, any failure in the builder will result in the entire request being rolled back. 
+
+
+Features
+----------------------
+
+
+- Entire build action wrapped in transaction by default
+- Automatic rollback if errors present
+- Lightwight, flexible DSL that can be easily overridden or extended
+- Macro-style validators
+- Transaction-level callbacks
+- Automatic generation of errors object
+- Mass-assignment protection, parameter whitelisting outside of controller
+- Find-or-instantiate based on class name inference
+
+
+
+The TL;DR copy & paste version:
+---------------------------------
+
+
+Save this somewhere in your app directory. Maybe in a builders folder?
+
+
+      class PostBuilder < BaseBuilder
+        #matches the class name
+
+        #make sure you list all params that are passed in (you can skip id if you want)
+        attributes :title,
+                   :content,
+                   :tweet_required,
+                   :author,
+                   :comment
+
+        #list as many before_save and after_save callbacks as you want
+        after_save :tweet_post
+
+        #choose a validator class to run automatically (must be a legit base validator)
+        validator PostParamsValidator
+
+        #access the model using #object
+        #this method is completely redundant
+        #it is what is called if you don't define a method for a listed attribute
+        def title(data)
+          object.title = data
+        end
+
+        #override the automatic writer so it doesn't try to set it on object
+        #needs to take exactly one parameter
+        def tweet_required(data); end
+
+
+        #use #delayed_save be be sure the object is saved after the parent object
+        def comment(data)
+          comment = Comment.new(content: data, author: current_user)
+          object.comments << comment
+          delayed_save!(comment)
+        end
+
+        private
+
+        #get data that you passed in in the builder_options hash
+        def current_user
+          @current_user ||= User.find(builder_options[:user_id])
+        end
+
+        #access the params you passed in anywhere you need to 
+        def tweet_post
+          TwitterMachine.spam(object) if params[:tweet_required]
+        end
+      end
+
+
+######These are the methods you have access to inside the builder:
+
+      :params
+      :errors                  #Array
+      :object                  #ActiveRecord::Base
+      :permitted_attributes    #Array
+      :requires_save           #Boolean
+      :builder_options         #Hash
+
+    
+
+
+The Full Deets on What is Going on Here:
+------------------------------------
+
+
+The API is for the builder is intended to closely resemble that of ActiveModel::Serializers, as the builder is used in a way similar way but for parsing data into instead of serializing data out of Rails models. 
+
+
+
+Creating a Builder
+==================================
+
+
+Each builder class inherits from BaseBuilder and maps directly onto one ActiveRecord model. The model name is inferred from the builder name, so for a Post model builder must be named PostBuilder. Class inference works with namespaced builders as well, leveraging the magic of regex voodoo. Currently there is no way to use a builder with a non-matching model. 
+
+
+###Attribute Mapping and Whitelisting
+
+
+All parameters that are used within the builder must be explicitly whitelisted as attributes. This can either provide super-reduntant mass-assignment protection on top of the Rails strong params or can be used in place of them to stop param whitelisting from ruining your short controller zen. Because the builder iteratively assigns each parmeter using the attribute writers you can pass paremters from the controller without whitelisting them there if you prefer. See 'Using the Builder' below for more on how to work with the rails params hash. 
+
+By default, the builder will attempt to map every parameter onto the attribute writer on the target model with the same name. If parameters are passed that are not whitelisted an exception will be raised. In order to implement custom behaviour for certain parmeters, methods written inside the class will be called when they match the name of whitelisted attribute that receives data from the params. These overwriter methods must take one parameter, which will hold the value of the submitted parameter. When an automatic attribute method is overridden by a custom method, the return value of the method does not map to the matching attribute writer
+
+
+Let me say that again. The return value of custom methods does not automatically map to the matchiang attribute writer. Anytime a default mapping is overridden, you are left with full flexibility to do what you want with the parameter value, including throw it away. This allows to builder to utilize parameters that were never intended to be written straight as model data. For parameter values that you want to throw away or handle elsewhere inside the builder, simply define a for the parameter key name that does nothing. To make it explicit that it is intentionally empty, write in like this: ``def parameter_key_name(value); end``
+
+
+#####A note on :id
+
+The id key is the only key in the params hash that does not need to be whitelisted and will not be mapped by default. It can still be overridden if you want to catch the id and do someting with it, or if you want to cue some other action just before the attribute mapping executes.
+
+
+###The object Object
+
+
+As in ActiveModel::Serializers, the builder makes use of the object object within the class. This allows for code that easily reusable between create and update requests. Behind the scenes the base builder uses the id the the params hash to look up the existing object form the inferred model and represents it as object. If no :id parameter exists a new empty object of that class is instantiated and assigned to object. Buidler methods then don't need to know or care about whether object is new or existing and can treat it the same. In the cases where this might be important, you are of course free to dig into object and ask it all sorts of ActiveRecord questions about its state inside your overwriter methods. 
+
+
+Just like you use object in your serializer methods to query things about the object. Use object in your builder methods to call methods on objects or set values. This can be super useful when you want to so something like initiate changes to a state machine while maintaining a RESTful web interface. Changes to state can be included in an update action, then the builder can check for the paremeters used for initiating a state change and call methods on object (or anywhere else really). Once again, the return values of the builder methods are thrown away and are completely unimportant. 
+
+
+Using the Builder
+======================================
+
+
+Currently the builder name is not inferred from the controller name and it msut be called explicitly in the controller. On initialization the builder takes the params as a mandatory first argument for parmas, a number of optional keyword arguments and an optional block. The block is used to quickly assign a single :after_save callback from data that is available in the controller. 
+
+The builder does not expect to get the entire params hash in the controller but instead wants a hash or array with no root node. When making a new post, for example, you would call ``PostBuilder.new(params[:post])``. This means that you have the choice of whether you whitelist in the controller using Rails strong params or pass the raw params in. The builder will force you to whitelist them inside regardless. 
+
+The builder will throw an exception on initialization if you pass it something besides an array or hash as the params, or if the params have a root node matching the class name. It won't creating the regular errors hash, because the client shouldn't be exposed to this error message. Any extra stuff in the params should be filtered out by the controller. 
+
+
+
+###The Builder#build method
+
+
+The build method fires the the entire builder for both create and update. Two other public methods are also available. #build_nested will perform the build without saving. In doing so it completely skips the callbacks so use it carefully. #update is used for explicitly passing in :object_id at initialization that will take precedence over any id value that is included in the parameters. This can be used if you watch to ensure that an id from the query string params is used instead of the request body. 
+
+
+The build method returns either the ActiveRecord object or an errors hash. Expected errors will be rescued and added to the errors hash, where unexpected errors will be raised. In both cases the entire build transaction will be rolled back. 
+
+
+
+
+Moar Features
+======================================
+
+
+###Callbacks
+
+
+You can list macro-style callbacks inside the class just like in your ActiveRecord models. 
+
+      class PostBuilder
+
+        attributes :title,
+                   :content,
+                   :author
+
+        before_save :update_state
+
+        after_save :add_email_job,
+                   :count_records
+
+        def update_state
+        end
+
+        def add_email_job
+        end
+
+        #you get the idea
+
+      end
+
+Just be sure you define the methods you list somewhere within the class, otherwise you get an explosion. An important point to remember is that callbacks ARE NOT CALLED EVER if you use the #build_nested instead of the #build method. 
+
+
+### #delayed_save(object)
+
+
+
+The builder implements #delayed_saved(object) to be used inside a builder class. This is a shortcut for calling save! on any object as part of the after save callbacks. It is useful for when you are creating nested objects inside a builder and you want to be sure that the parent object is saved first, as is the case with associations where you need to be sure the parent has all attributes in place to pass validattion before the child forces a save. Note that delayed_save callbacks fire before the rest of the after_save callbacks.
+
+
+      class PostBuilder
+
+        attributes :title,
+                   :content,
+                   :author
+                   :comment
+
+        def comment(data)
+          new_comment = Comment.new(content: data)
+          object.comments < new_comment
+          delayed_save!(new_comment)
+        end
+      end      
+
+
+###Builder Options
+
+
+You probably have situations where you want to get stuff from the controller inside the builder that doesn't come in the params. You can include any number of keyword arguments after the parameters argument at initialization that will be available inside the builder in the ``builder options`` hash. 
+
+
+When you make the builder like this in the contoller: ``PostBuilder.new(params[:post], user: current_user).build``
+
+
+Inside the builder you can get the current user by calling ``builder_options[:current_user]``
+
+
+This way you can easily pass in any extra query string stuff you get in the params. It's recommended that you perform any lookups inside a method in the builder instead of in the controller when you don't need to reuse them for anything out there. For example, if you only need the current user in the builder, pass in the user_id from the query string params and define a method like this in your builder:
+
+
+      def user
+        @user ||= User.find(builder_options[:user_id])
+      end
+
+
+That way the controller stays nice and snappy and the builder has a reusable method that's not 30 chars long.
+
+
+###Validator
+
+
+You can make a validator class to be used with your builder. It's a good place to do validations that check for certain combinations of parameters, especially if they affect multiple models and therefore don't really make sense to have in one model class or the other. The validator uses only a tiny bit of custom syntax, and it's really just there to make your life easier. 
+
+
+#####Make the validator:
+
+
+Make the class like this. You can put it anywhere in the app directory, but it feels very at home in a folder called validations. It doesn't use class inference so you can call it whatever
+
+
+      class UltraSweetValidator < BaseValidator
+    
+        validations :first_method,
+                    :other_method
+
+        def first_method
+          if params[:a_thing]
+            return true if params[:that_other_thing_that_has_to_be_there]
+          else
+            message "You can't do that"
+            add_invalid_request_error(message)
+          end          
+        end
+
+        def other_method
+          #return value doesn't matter
+        end
+      end
+
+
+Just list all the validation methods you want at the top and then define them below. The builder knows how to call them. The validator has access to two useful objects and has one useful custom method. You can, obviously, access the params that you passed into the builder (not the ones in the controller), and you can also access the errors hash. 
+
+
+When you find something you don't like, you can either use the super userful #add_invalid_request_error(message) method, or you can just add whatever you want to the errors hash. If the errors hash is anyting but completely empty the buidler transaction will roll back and return whatever is in there to the controller. The method just adds your message there is a nice formatted way and includes a 400 'bad request' status code. If you want to skip the the rest of the validations as soon as one fails just add a bang (!) to the end of the method. Don't add it after the message argument, that would obviously be wrong.
+
+
+#####Use the validator:
+
+
+Call the validator inside the builder by listing the class name 
+
+
+      class PostBuilder < BaseBuilder
+
+        attributes :title,
+                   :content,
+                   :author
+                   :comment
+
+        validator UltraSweetValidator
+
+      end
+
+
+That's it. The validator is called at the very beginning of the build method (and the other similar ones) and if it snags any errors in the errors hash it will return them instead of trying to run the rest of the build action. If all goes well, this will give you a way to stop your builder from exploding because it's missing data it expects to be there. The validators are there to keep messy error handling out of the builders. You should definitely use them. 
+
+
+Don't bother validating simple params in your validator that map straight onto the model attributes. The builder always calls #save! instead of #save and then catches the errors so you can jsut use your regular old ActiveRecord validators and still have a errors hash at the end. 
+
+
+
+
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/levee/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,2 @@
+require "bundler/gem_tasks"
+

data/levee.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'levee/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "levee"
+  spec.version       = Levee::VERSION
+  spec.authors       = ["Mike Martinson"]
+  spec.email         = ["mike.j.martinson@gmail.com"]
+  spec.summary       = %q{Flexible builder template for mapping complex rails post params onto ActiveRecord models}
+  spec.description   = Levee.gem_description
+  spec.homepage      = ""
+  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_runtime_dependency 'activerecord', '~> 4.0'
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end
+
+

data/lib/levee/builder.rb

@@ -0,0 +1,230 @@
+module Levee
+  class Builder
+
+    attr_accessor :params, 
+                  :errors, 
+                  :object, 
+                  :nested_objects_to_save, 
+                  :permitted_attributes, 
+                  :requires_save, 
+                  :builder_options
+
+    def initialize(params, options={}, &blk)
+      self.params                 = params
+      validate_params
+      self.errors                 = []
+      self.nested_objects_to_save = []
+      self.permitted_attributes   = [:id]
+      self.requires_save          = true
+      self.builder_options        = options
+      @callback_blocks            = [*blk]
+    end
+
+    def build
+      unless params.is_a? Array
+        self.object = object_class.find_by(id: params[:id]) || object_class.new
+      end
+      assign_parameters_in_transaction
+    end
+
+    def build_nested(parent_object: nil, parent_builder: nil)
+      self.requires_save = false
+      build
+    end
+
+    def update(object_id:)
+      self.object = object_class.find_by_id(object_id)
+      return {error_status: 404, errors:[{status: 404, code: 'record_not_found'}]} unless object
+      assign_parameters_in_transaction
+    end
+
+    def permitted_attributes
+      self.class._permitted_attributes || []
+    end  
+
+    def validator
+      return nil unless self.class._validator
+      @validator ||= self.class._validator.new(params)
+    end
+
+    private
+
+    def assign_parameters_in_transaction
+      ActiveRecord::Base.transaction do
+        begin
+          perform_in_transaction
+        rescue => e
+          raise_error = -> { raise e }
+          rescue_errors(e) || raise_error.call
+        ensure
+          self.errors = (errors << validator.errors).flatten if validator
+          raise ActiveRecord::Rollback unless errors.flatten.empty?
+        end  
+      end
+      Rails.logger.error "Builder Errors:"
+      Rails.logger.error errors.to_yaml
+      self.object = object.reload if errors.empty? && object.try(:persisted?)
+      errors.empty? ? object : {errors: errors, error_status: errors.first[:status]}
+    end
+
+    def perform_in_transaction
+      self.errors += validator.validate_params.errors if validator
+      return false if errors.any?
+      self.object = top_level_array || call_setter_for_each_param_key
+      return true unless requires_save && !top_level_array
+      before_save_callbacks.each { |callback| send(callback) }
+      [*object].each(&:save!)
+      nested_objects_to_save.flatten.each(&:save!)
+      @callback_blocks.each_with_object(object, &:call)
+      after_save_callbacks.each { |callback| send(callback) }
+    end
+
+    def call_setter_for_each_param_key
+      params.each do |key, value|
+        send_if_key_included_in_attributes(key.to_sym, value)
+      end
+      object
+    end
+
+    def send_if_key_included_in_attributes(key, value)
+      if permitted_attributes.include?(key)
+        self.send(key, value)
+      else
+        errors << {status: 400, message: "Unpermitted parameter key #{key}"}
+        raise ActiveRecord::Rollback
+      end
+    end
+
+    def top_level_array
+      return false unless params.is_a?(Array)
+      @top_level_array ||= params.map do |param_object|
+        self.class.new(param_object, builder_options).build_nested
+      end
+    end
+
+    #need to use attributes to handle errors that aren't meant to be model methods
+    def method_missing(method_name, *args)
+      return super unless permitted_attributes.include?(method_name)
+      begin
+        object.send(:"#{method_name}=", args.first)
+      rescue => e
+        if params.has_key?(method_name)
+          message = "Unable to process value for :#{method_name}, no attribute writer. Be sure to override the automatic setters for all params that do not map straight to a model attribute."
+          self.errors << {status: 422, message: message}
+        else
+          raise e
+        end
+      end
+    end
+
+    def delayed_save!(nested_object)
+      self.nested_objects_to_save  = (nested_objects_to_save << nested_object).uniq
+    end
+
+    def object_class
+      klass = self.class.to_s
+      start_position = (/::\w+$/ =~ klass).try(:+,2)
+      klass = klass[start_position..-1] if start_position
+      suffix_position = klass =~ /Builder$/
+      if suffix_position
+        try_constant = klass[0...suffix_position]
+        begin
+          try_constant.constantize
+        rescue
+          raise NameError.new "#{try_constant} does not exist. Builder class name must map the the name of an existing class"
+        end
+      else
+        raise "#{self.class} must be named ModelNameBuilder to be used as a builder class"
+      end
+    end
+
+    def rescue_errors(rescued_error)
+      raise_if_validation_error(rescued_error)    
+      raise_if_argument_error(rescued_error)
+      raise_if_unknown_attribute_error(rescued_error)
+    end
+
+    def raise_if_validation_error(rescued_error)
+      if rescued_error.is_a? ActiveRecord::RecordInvalid
+        self.errors << { status: 422, code: 'validation_error', message: object.errors.full_messages, record: rescued_error.record }
+        raise ActiveRecord::Rollback
+      end  
+    end
+
+    def raise_if_argument_error(rescued_error)
+      if rescued_error.is_a? ArgumentError
+        message = "All methods on the builder that override attribute setters must accept one argument to catch the parameter value"
+        self.errors << { status: 500, code: 'builder_error', message: message }
+        raise ArgumentError.new message
+      end
+    end
+
+    def raise_if_unknown_attribute_error(rescued_error)
+      if rescued_error.is_a? ActiveRecord::UnknownAttributeError
+        self.errors << { status: 400, code: 'unknown_attribute_error', message: rescued_error.message, record: rescued_error.record }
+        raise ActiveRecord::Rollback
+      end
+    end
+
+    def self.attributes(*args)
+      @permitted_attributes ||= []
+      args.each { |a| @permitted_attributes << a unless @permitted_attributes.include?(a) }
+    end
+    
+    def self._permitted_attributes
+      @permitted_attributes
+    end
+    
+    def validate_params
+      message =  "Params passed to builder must be a hash or top level array"
+      raise message unless params.respond_to?(:fetch)
+      return true if params.is_a? Array
+      message = "Params passed to builder must not have a root node"
+      key = params.keys.first
+      raise message if key && key.to_s.camelize == object_class.to_s
+    end
+
+    #used so that id setter is not called by default
+    def id(data)
+      true
+    end
+
+    #######################
+    ## callbacks       
+    ###########################
+
+    def self.before_save(*args)
+      @before_save_callbacks ||= []
+      args.each { |a| @before_save_callbacks << a unless @before_save_callbacks.include?(a) }
+    end
+    
+    def self._before_save_callbacks
+      @before_save_callbacks
+    end
+    
+    def self._after_save_callbacks
+      @after_save_callbacks
+    end
+    
+    def self.after_save(*args)
+      @after_save_callbacks ||= []
+      args.each { |a| @after_save_callbacks << a unless @after_save_callbacks.include?(a) }
+    end
+    
+    def before_save_callbacks
+      self.class._before_save_callbacks || []
+    end
+    
+    def after_save_callbacks
+      self.class._after_save_callbacks || []
+    end
+
+    def self.validator(validator)
+      @validator = validator
+    end
+
+    def self._validator
+      @validator
+    end
+  end
+end

data/lib/levee/version.rb

@@ -0,0 +1,9 @@
+module Levee
+  extend self
+
+  VERSION = "0.0.1"
+
+  def gem_description
+    %Q(The purpose of the builder object is to create a layer of abstraction between the controller and models in a Rails application. The builder is particularly useful for receiving complex post and put requests with multiple parameters, but is lightweight enough to use for simple writes when some filtering or parameter combination validation might be useful before writing to the database. Since it wraps the entire write action to mulitple models in a single transaction, any failure in the builder will result in the entire request being rolled back.)
+  end
+end

data/lib/levee.rb

@@ -0,0 +1,3 @@
+require "levee/version"
+require "levee/builder"
+

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: levee
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Mike Martinson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !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'
+description: The purpose of the builder object is to create a layer of abstraction
+  between the controller and models in a Rails application. The builder is particularly
+  useful for receiving complex post and put requests with multiple parameters, but
+  is lightweight enough to use for simple writes when some filtering or parameter
+  combination validation might be useful before writing to the database. Since it
+  wraps the entire write action to mulitple models in a single transaction, any failure
+  in the builder will result in the entire request being rolled back.
+email:
+- mike.j.martinson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- levee.gemspec
+- lib/levee.rb
+- lib/levee/builder.rb
+- lib/levee/version.rb
+homepage: ''
+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: Flexible builder template for mapping complex rails post params onto ActiveRecord
+  models
+test_files: []
+has_rdoc: