monkey_forms 0.0.15

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+bin
+*.rbc

data/BUGS

@@ -0,0 +1 @@
+- Forms that inherit from other forms don't seem have their form_name set correctly (according to Rails, anyways).

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+gem "deep_merge", 
+    '0', 
+    :git => "git://github.com/joevandyk/deep_merge.git", 
+    :ref => "a244fdd2d3a633743b054857b43f1ee4cacad9ff"
+
+# Specify your gem's dependencies in monkey_forms.gemspec
+gemspec

data/NOTES

@@ -0,0 +1,4 @@
+ActiveModel::Validator seems to depend on 
+ActiveSupport::Callbacks? 
+Got undefined method `extlib_inheritable_reader'
+when I included ActiveModel into a class.

data/README.md

@@ -0,0 +1,154 @@
+NOTE!  If you use the cookie serialization feature, you 
+need to use this version of deep_merge for now.
+https://github.com/joevandyk/deep_merge
+
+
+MonkeyForms::Form is an ActiveModel-compliant interface
+between your controllers and models (or whatever you are 
+saving the data to).
+
+MonkeyForms supports multi-page wizards and validation groups.
+
+    class OrderForm
+      include MonkeyForms::Form
+      form_name 'cart'
+      form_attributes :name, :address, :city, :state, :zip 
+      
+      validates :name, :presence => true
+
+      # Save the data however you want.
+      def save
+        address = Address.new(:street => address, :city => city, :state => state, :zip => zip)
+        OrderService.place_order(:the_name => name, :address => address)
+      end
+    end
+
+
+    In your controller:
+      def new
+        @cart = OrderForm.new
+      end
+      def create
+        @cart = OrderForm.new(:form => params[:cart])
+        if @cart.valid?
+          @cart.save
+          redirect_to "/thanks"
+        else
+          render :action => 'new'
+        end
+      end
+    end
+
+    In your view:
+      = form_for @cart do |f|
+        = f.text_field :name
+        = f.text_field :address
+        = f.text_field :city
+        = # etc
+        = f.submit
+
+
+A more complex multi-page order process.
+State is remembered in a cookie; the form params are merged into the cookie's state on each request.
+
+    class OrderForm
+      include MonkeyForms::Form
+
+      # Declares a few attributes on the form.
+      form_attributes :name, :email, :city, :state, :line_items
+      custom_attributes :user_id
+      form_name :cart
+
+      # This form serializes the submit into a gzip'd cookie with a name
+      # of 'order_cookie'.
+      set_form_storage(
+        MonkeyForms::Serializers::GzipCookie.new(
+          :name => 'order_cookie',
+          :domain => 'test.domain.com',
+          :secure => true,
+          :httponly => true))
+
+      after_initialize :set_default_state
+
+      # We must submit an email address for the form to validate.
+      validates :email, :presence => true
+
+      validation_group :cart do
+        # Scope some of the validation checks
+        validates :name, :presence => true
+      end
+
+      validation_group :address do
+        validates :city,  :presence => true
+        validates :state, :presence => true
+      end
+
+      # This is a method that uses some form attributes.
+      def person
+        "#{ name } <#{ email }>"
+      end
+
+      private
+
+      def set_default_state
+        if state.blank?
+          self.state = "WA"
+        end
+      end
+    end
+
+
+    class Controller
+      before_filter :load_cart
+      # Name / Email
+      def page1
+        if request.post?
+          if group.valid?(:name)
+            redirect_to "/page2"
+          end
+        end
+      end
+
+      # Address
+      def page2
+        if request.post?
+          if group.valid?(:address)
+            # whatever..
+          end
+        end
+      end
+
+      private
+
+      def load_cart
+        @cart = OrderForm::Form.new(:form => params[:cart]
+      end
+    end
+
+
+The validation_group code is modified from 
+https://github.com/adzap/grouped_validations
+
+
+This is pretty similar to the Presenter Pattern as described
+by Jay Fields, by the way. http://blog.jayfields.com/2007/03/rails-presenter-pattern.html
+
+
+
+There is a sample sinatra application in test/sinatra.  Run with:
+cd test/sinatra
+rackup config.ru
+
+
+
+??? WHY ???
+
+Moving the form logic to a separate class has a ton of advantages:
+
+* Keeps the controller really simple.  
+* Makes it easier to test. You can write tests directly against the form handling class.
+* Classes should do one thing.
+* You can have complex validations.
+* Your ActiveRecord models can probably become simpler.
+* Since the form handling logic is encapsulated into one class, you can use inheritance, modules, etc.
+* You want to move away from ActiveRecord? It's no problem -- just change how the form values are saved in the #save method.

data/Rakefile

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'bundler/setup'
+
+Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+end
+
+task :default => :test

data/lib/monkey_forms/serializers/active_record_session.rb

@@ -0,0 +1,12 @@
+# Saves form as cookie as json+gzip
+class MonkeyForms::Serializers::ActiveRecordSesssion
+  def initialize options={}
+    @cookie_name = options[:name]
+  end
+
+  def load options={}
+  end
+
+  def save options = {}
+  end
+end

data/lib/monkey_forms/serializers/gzip_cookie.rb

@@ -0,0 +1,34 @@
+# encoding: UTF-8
+require 'zlib'
+
+# Saves form as cookie as json+gzip
+class MonkeyForms::Serializers::GzipCookie
+  def initialize options={}
+    @cookie_name = options[:name]
+    @domain      = options[:domain]
+    @secure      = options[:secure]
+    @httponly    = options[:httponly]
+  end
+
+  def load options={}
+    request = options[:request]
+    result = ActiveSupport::HashWithIndifferentAccess.new
+    return result if request.blank?
+    cookie = request.cookies[@cookie_name]
+    return result if cookie.nil? or cookie.empty?
+    result.merge!(ActiveSupport::JSON.decode(Zlib::Inflate.inflate(cookie)).stringify_keys)
+  end
+
+  def save options = {}
+    attributes = options[:attributes]
+    response   = options[:response]
+
+    cookie_json = ActiveSupport::JSON.encode(attributes)
+    cookie_json = Zlib::Deflate.deflate(cookie_json, Zlib::BEST_COMPRESSION)
+    cookie_hash = { :value    => cookie_json,
+                    :httponly => @httponly,
+                    :secure   => @secure,
+                    :domain   => @domain }
+    response.set_cookie(@cookie_name, cookie_hash)
+  end
+end

data/lib/monkey_forms/serializers/message_pack_json.rb

@@ -0,0 +1,32 @@
+require 'msgpack'
+
+# Saves form as cookie as json+gzip
+class MonkeyForms::Serializers::MessagePackJson
+  def initialize options={}
+    @cookie_name = options[:name]
+    @domain      = options[:domain]
+    @secure      = options[:secure]
+    @httponly    = options[:httponly]
+  end
+
+  def load options={}
+    request = options[:request]
+    result = ActiveSupport::HashWithIndifferentAccess.new
+    return result if request.blank?
+    cookie = request.cookies[@cookie_name]
+    return result if cookie.blank?
+    result.merge!(ActiveSupport::JSON.decode(MessagePack.unpack(cookie)).stringify_keys)
+  end
+
+  def save options = {}
+    attributes = options[:attributes]
+    response   = options[:response]
+
+    cookie_json = ActiveSupport::JSON.encode(attributes).to_msgpack
+    cookie_hash = { :value    => cookie_json,
+                    :httponly => @httponly,
+                    :secure   => @secure,
+                    :domain   => @domain }
+    response.set_cookie(@cookie_name, cookie_hash)
+  end
+end

data/lib/monkey_forms/serializers.rb

@@ -0,0 +1,7 @@
+
+module MonkeyForms
+  module Serializers
+    autoload :GzipCookie, 'monkey_forms/serializers/gzip_cookie'
+    autoload :MessagePackJson, 'monkey_forms/serializers/message_pack_json'
+  end
+end

data/lib/monkey_forms/version.rb

@@ -0,0 +1,3 @@
+module MonkeyForms
+  VERSION = "0.0.15"
+end

data/lib/monkey_forms.rb

@@ -0,0 +1,146 @@
+module MonkeyForms
+  require 'monkey_forms/serializers'
+  require 'active_model'
+  require 'active_support/hash_with_indifferent_access'
+  require 'active_support/core_ext/object/try'
+  require 'grouped_validations'
+  require 'deep_merge'
+
+  module Form
+
+    def self.included base
+      base.send :include, ActiveModel::Validations
+      base.send :extend,  ActiveModel::Callbacks
+      base.send :include, InstanceMethods
+      base.send :extend,  ClassMethods
+      base.instance_eval do
+        define_model_callbacks :initialize
+      end
+      base.send :include, ActiveModel::Validations
+    end
+
+    module InstanceMethods
+      attr_reader :attributes
+
+      def persisted?
+        false
+      end
+
+      # TODO not sure what's best here
+      def html_error_messages
+        errors.full_messages.join("<br />")
+      end
+
+      def to_model
+        self
+      end
+
+      def to_param
+        nil
+      end
+
+      def to_key
+        nil
+      end
+
+      def initialize options = {}
+        _run_initialize_callbacks do
+          form_params = options.delete(:form) || {}
+          @options    = options
+
+          @options.each do |key, value|
+            instance_variable_set "@#{key}", value
+          end
+
+          # Load the saved form from storage
+          @attributes =
+            if self.class.form_storage
+              self.class.form_storage.load(@options)
+            else
+              ActiveSupport::HashWithIndifferentAccess.new
+            end
+
+          # Merge in this form's params
+          DeepMerge.deep_merge!(form_params, @attributes)
+
+          self.class.attributes.each do |a|
+            @attributes[a] ||= ""
+          end
+        end
+      end
+
+      def save_to_storage!
+        @options[:attributes] = @attributes
+        self.class.form_storage.save(@options)
+      end
+
+    end
+
+    module ClassMethods
+      attr_reader :form_storage
+
+      def attributes
+        @attributes ||= {}
+      end
+
+      # Compatibility with ActiveModel::Naming
+      def model_name
+        if !defined?(@_model_name)
+          # EWWWW
+          @_model_name = (@_form_name.try(:to_s) ||
+                          superclass.instance_variable_get(:@_form_name).try(:to_s) ||
+                          name.underscore).try(:underscore)
+          %w( singular human i18n_key partial_path plural ).each do |method|
+            @_model_name.class_eval do
+              define_method method do
+                self
+              end
+            end
+          end
+        end
+        @_model_name
+      end
+
+      def form_name name
+        @_form_name = name
+      end
+
+      def set_form_storage storage_object
+        @form_storage = storage_object
+      end
+
+      def set_form_attribute_human_names options
+        @_form_attribute_names ||= {}
+        @_form_attribute_names.merge!(options)
+      end
+
+      def human_attribute_name name, *options
+        @_form_attribute_names ||= {}
+        @_form_attribute_names[name] || super
+      end
+
+      def form_attributes *attrs
+        @attributes ||= []
+        attrs.each do |attr|
+          @attributes << attr
+
+          # Defines public method
+          define_method attr do
+            @attributes[attr.to_s]
+          end
+          define_method "#{attr}=" do |value|
+            @attributes[attr.to_s] = value
+          end
+        end
+      end
+
+      def custom_attributes *attrs
+        attrs.each do |attr|
+          instance_eval do
+            attr_reader attr
+          end
+        end
+      end
+    end
+  end
+end

data/monkey_forms.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "monkey_forms/version"
+
+Gem::Specification.new do |s|
+  s.name        = "monkey_forms"
+  s.version     = MonkeyForms::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Joe Van Dyk"]
+  s.email       = ["joe@tanga.com"]
+  s.homepage    = "https://github.com/joevandyk/monkey_forms"
+  s.summary     = %q{Helps make complex forms}
+  s.description = %q{Helps make complex forms}
+  s.rubyforge_project = "monkey_forms"
+
+  s.add_dependency('activemodel')
+  s.add_dependency('deep_merge')
+
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'sinatra'
+  s.add_development_dependency 'rack-test'
+  s.add_development_dependency 'shotgun'
+  s.add_development_dependency 'haml'
+  s.add_development_dependency('msgpack')
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/forms/basic_form.rb

@@ -0,0 +1,8 @@
+require 'monkey_forms'
+
+class BasicForm
+  include MonkeyForms::Form
+  form_attributes :name
+  validates :name, :presence => true
+end
+

data/test/forms/order_form.rb

@@ -0,0 +1,54 @@
+require 'monkey_forms'
+
+class OrderForm
+  include MonkeyForms::Form
+  attr_reader :an_attribute
+
+  # Declares a few attributes on the form.
+  form_attributes :name, :email, :city, :state, :line_items
+  custom_attributes :user_id
+  form_name :cart
+
+  # This form serializes the submit into a gzip'd cookie with a name
+  # of 'order_cookie'.
+  set_form_storage(
+    MonkeyForms::Serializers::GzipCookie.new(
+      :name => 'order_cookie',
+      :domain => 'test.domain.com',
+      :secure => true,
+      :httponly => true))
+
+  after_initialize :set_attribute, :set_default_state
+
+  # We must submit an email address for the form to validate.
+  validates :email, :presence => true
+
+  set_form_attribute_human_names :name => "Your Name"
+
+  validation_group :cart do
+    # Scope some of the validation checks
+    validates :name, :presence => true
+  end
+
+  validation_group :address do
+    validates :city,  :presence => true
+    validates :state, :presence => true
+  end
+
+  # This is a method that uses some form attributes.
+  def person
+    "#{ name } <#{ email }>"
+  end
+
+  private
+
+  def set_attribute
+    @an_attribute = true
+  end
+
+  def set_default_state
+    if state.blank?
+      self.state = "WA"
+    end
+  end
+end

data/test/forms/order_form_child.rb

@@ -0,0 +1,4 @@
+require 'monkey_forms'
+class OrderFormChild < OrderForm
+  form_attributes :child
+end

data/test/sinatra/config.ru

@@ -0,0 +1,5 @@
+require 'bundler'
+require 'bundler/setup'
+
+require 'sample_sinatra'
+run SampleSinatra

data/test/sinatra/sample_sinatra.rb

@@ -0,0 +1,50 @@
+require 'sinatra/base'
+require 'forms/order_form'
+
+class SampleSinatra < Sinatra::Base
+  #set :show_exceptions, false
+
+  before do
+    load_form
+  end
+
+  get "/" do
+    @page = 1
+    haml :form
+  end
+
+  get "/2" do
+    @page = 2
+    haml :form
+  end
+
+  get "/3" do
+    @page = 3
+    haml :form
+  end
+
+  post "/haml_form" do
+    # We could probably do something with the form object here, maybe
+    # Tells the form to serialize itself.
+    @form.save_to_storage!
+    redirect "/"
+  end
+
+  # Only used in unit tests
+  post "/form" do
+    # Tells the form to serialize itself.
+    @form.save_to_storage!
+
+    # Renders something (used in tests)
+    @form.person
+  end
+
+  private
+
+  def load_form
+    @form = OrderForm.new(:form     => request.params["form"],
+                          :request  => request,
+                          :response => response)
+  end
+end
+

data/test/sinatra/views/form.haml

@@ -0,0 +1,25 @@
+%h1 Welcome to Monkey Forms Page #{ @page }
+
+%h3
+  %a{:href => "/"} Page 1
+  |
+  %a{:href => "/2"} Page 2
+  |
+  %a{:href => "/3"} Page 3
+
+%h3 Form Values
+= @form.attributes.inspect
+
+%p
+  As you click from page to page, note that your form
+  values are saved. They are saved in a cookie!
+
+%form{:action => '/haml_form', :method => 'post'}
+  - @form.class.attributes.each do |name|
+    %input{:type => 'text', :id => "form_#{name}", :name => "form[#{name}]", :value => @form.send(name)}
+    %label{:for => "form_#{name}"}= name
+
+    %br
+
+  %input{:type => 'submit'}
+

data/test/test_monkey_forms.rb

@@ -0,0 +1,182 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'rack/test'
+
+require 'sinatra/sample_sinatra'
+require 'forms/order_form'
+require 'forms/order_form_child'
+require 'forms/basic_form'
+
+# I want to ensure this library works fine with all of ActiveSupport loaded
+require 'active_support/all'
+
+class TestMonkeyForms < MiniTest::Unit::TestCase
+  include Rack::Test::Methods
+
+  def app
+    SampleSinatra.new
+  end
+
+  def test_form_post_with_cookie
+    post "https://test.domain.com/form", :form => { :name => "Joe" }
+    assert_equal "Joe <>", last_response.body
+    post "https://test.domain.com/form", :form => { :email => "joe@tanga.com" }
+    assert_equal "Joe <joe@tanga.com>", last_response.body
+  end
+
+  def test_attribute_name
+    o = OrderForm.new
+    o.valid?
+    assert o.errors.full_messages.include?("Your Name can't be blank")
+  end
+
+  def test_form_works_without_human_names_set
+    o = BasicForm.new
+    o.valid?
+    assert o.errors.full_messages.include?("Name can't be blank")
+  end
+
+  def test_form_cookie
+    submit_form :name => "joe"
+    # TODO figure out how to get test the cookie stuff properly
+    assert last_response.headers["Set-Cookie"].include?("HttpOnly")
+    assert last_response.headers["Set-Cookie"].include?("secure")
+    assert last_response.headers["Set-Cookie"].include?("test.domain.com")
+  end
+
+  def test_setters_from_inside_form
+    a = submit_form :name => 'joe'
+    assert_equal 'WA', a[:state]
+  end
+
+  def test_child_form
+    o = OrderFormChild.new :form => { :child => 'new', :name => 'joe' }
+    assert_equal 'new',  o.child
+    assert_equal 'joe',  o.name
+
+    assert_equal 'cart', o.class.model_name
+  end
+
+  def test_basic
+    o = OrderForm.new :form => { :name => "Joe", :email => "joe@tanga.com" }
+    assert_equal "Joe", o.name
+    assert_equal "joe@tanga.com", o.email
+    assert_equal "", o.city
+    assert_equal 5, o.attributes.size
+    assert_equal "Joe", o.attributes[:name]
+    assert_equal "Joe", o.attributes["name"]
+  end
+
+  def test_validation
+    o = OrderForm.new :form => { :name => "Joe" }
+    o.valid?
+    assert_equal ["can't be blank"], o.errors[:email]
+  end
+
+  def test_validation_before_valid_called
+    o = OrderForm.new
+    assert_equal [], o.errors[:name]
+    assert_equal [], o.errors[:email]
+  end
+
+  def test_html_errors
+    o = OrderForm.new
+    o.valid?
+    assert o.html_error_messages.include?("City can't be blank")
+  end
+
+  def test_validation_scope_after_valid_called
+    o = OrderForm.new
+    refute o.valid?
+    assert ["can't be blank"], o.errors[:name]
+    assert ["can't be blank"], o.errors[:email]
+  end
+
+  def test_group_validation
+    o = OrderForm.new
+    refute o.group_valid?(:cart)
+    assert_equal ["can't be blank"], o.errors[:name]
+    assert_equal [], o.errors[:email]
+
+    o.valid?
+    assert_equal ["can't be blank"],  o.errors[:email]
+  end
+
+  def test_after_initialize
+    o = OrderForm.new
+    assert o.an_attribute
+  end
+
+  def test_set_custom_attributes
+    o = OrderForm.new :user_id => 1
+    assert_equal 1, o.user_id
+  end
+
+  def test_can_access_attributes
+    o = OrderForm.new :form => { :email => "joe@tanga.com" , :name => "Joe" }
+    assert_equal "Joe <joe@tanga.com>", o.person
+  end
+
+  def test_array
+    submit_form(:line_items => [ {:id => "previous"}])
+    attributes = submit_form(:line_items => [ {:id => "new"}])
+
+    assert_equal 2, attributes[:line_items].size
+    assert_equal "previous", attributes[:line_items].first[:id]
+    assert_equal "new",      attributes[:line_items].last[:id]
+  end
+
+  def test_array_update
+    submit_form(:line_items => [ {:id => "first", :quantity => 1}])
+    attributes = submit_form(:line_items => [ {:id => "first", :quantity => 3}])
+    assert_equal "3", attributes[:line_items].last[:quantity]
+  end
+
+  def test_submit_blank
+    a = submit_form(:name => "Joe", :city => "Seattle")
+    assert_equal "Joe", a[:name]
+
+    a = submit_form(:name => "", :city => "Seattle")
+    assert_equal "", a[:name]
+  end
+
+
+  def extract_attributes request
+    serializer = MonkeyForms::Serializers::GzipCookie.new(:name => "order_cookie")
+    serializer.load(:request => request)
+  end
+
+  def submit_form attributes
+    post "https://test.domain.com/form", :form => attributes
+    post "https://test.domain.com/form", :form => {} # not sure why the cookies don't get set in last_request without this
+    extract_attributes last_request
+  end
+end
+
+class TestMonkeyFormsActiveModelLint < MiniTest::Unit::TestCase
+  include ActiveModel::Lint::Tests
+
+  def setup
+    @model = OrderForm.new
+  end
+
+  def test_form_name
+    assert_equal "cart", @model.class.model_name
+  end
+end
+
+class TestMonkeyFormsBasic < MiniTest::Unit::TestCase
+  include ActiveModel::Lint::Tests
+
+  def setup
+    @model = BasicForm.new
+  end
+
+  def test_form_name
+    assert_equal "basic_form", @model.class.model_name
+  end
+
+  def test_attributes
+    assert_equal @model.attributes, {"name" => ""}
+  end
+end

metadata

@@ -0,0 +1,179 @@
+--- !ruby/object:Gem::Specification
+name: monkey_forms
+version: !ruby/object:Gem::Version
+  version: 0.0.15
+  prerelease: 
+platform: ruby
+authors:
+- Joe Van Dyk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-07-03 00:00:00.000000000 -07:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: &2165026280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2165026280
+- !ruby/object:Gem::Dependency
+  name: deep_merge
+  requirement: &2165025680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2165025680
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &2165025120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2165025120
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2165024680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2165024680
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: &2165024140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2165024140
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: &2165023560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2165023560
+- !ruby/object:Gem::Dependency
+  name: shotgun
+  requirement: &2165022960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2165022960
+- !ruby/object:Gem::Dependency
+  name: haml
+  requirement: &2162564820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2162564820
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  requirement: &2162564280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2162564280
+description: Helps make complex forms
+email:
+- joe@tanga.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- BUGS
+- Gemfile
+- NOTES
+- README.md
+- Rakefile
+- lib/monkey_forms.rb
+- lib/monkey_forms/serializers.rb
+- lib/monkey_forms/serializers/active_record_session.rb
+- lib/monkey_forms/serializers/gzip_cookie.rb
+- lib/monkey_forms/serializers/message_pack_json.rb
+- lib/monkey_forms/version.rb
+- monkey_forms.gemspec
+- test/forms/basic_form.rb
+- test/forms/order_form.rb
+- test/forms/order_form_child.rb
+- test/sinatra/config.ru
+- test/sinatra/sample_sinatra.rb
+- test/sinatra/views/form.haml
+- test/test_monkey_forms.rb
+has_rdoc: true
+homepage: https://github.com/joevandyk/monkey_forms
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2757128949908824304
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2757128949908824304
+requirements: []
+rubyforge_project: monkey_forms
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Helps make complex forms
+test_files:
+- test/forms/basic_form.rb
+- test/forms/order_form.rb
+- test/forms/order_form_child.rb
+- test/sinatra/config.ru
+- test/sinatra/sample_sinatra.rb
+- test/sinatra/views/form.haml
+- test/test_monkey_forms.rb