RubyGems - rack-cookie-monster - Versions diffs - 1.0.0 - Mend

rack-cookie-monster 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

data/README.rdoc +61 -0
data/features/cookie_monster.feature +50 -0
data/features/monster.ru +49 -0
data/features/step_definitions/all_steps.rb +23 -0
data/features/step_definitions/common_celerity.rb +163 -0
data/features/support/celerity_startup.rb +57 -0
data/lib/rack/cookie_monster.rb +104 -0
data/spec/rack/cookie_monster_spec.rb +131 -0
data/spec/spec_helper.rb +15 -0
data/spec/support/stub_helpers.rb +164 -0
metadata +72 -0

data/README.rdoc ADDED

@@ -0,0 +1,61 @@
+= Rack Cookie Monster
+A rack middleware library that allows for cookies to be passed through form parameters. Specifically, it merges the specified
+form parameters into the Cookie header of an http request. It gets around the problem of having a flash application which interacts with a web application that uses cookie based sessions.
+= Contributing
+The environment can be configured by using bundler.
+  gem bundle or rake setup:contrib
+= Usage
+<b>Rails Example:</b>
+  # In rails initializer
+  Rack::CookieMonster.configure do |c|
+    c.eat :_session_id
+    c.eat :user_credentials
+    c.share_with /^(Adobe|Shockwave) Flash/
+    c.share_with "Burt"
+  end
+  Rack::CookieMonster.configure_for_rails
+<b>Rack Example:</b>
+  class CookieMonsterApplication
+    def call(env)
+      cookies = ::Rack::Request.new(env).cookies
+      res = ::Rack::Response.new
+      res.write %{
+        <html>
+          <head>
+            <title>Form</title>
+          </head>
+          <body>
+            <form action="/" method="post">
+              Cookie 1: <input type="text" name="cookie_1" />
+              Cookie 2: <input type="text" name="cookie_2" />
+              Non Cookie: <input type="text" name="non_cookie" />
+              <input type="submit" />
+            </form>
+          </body>
+          #{
+            cookies.map do |k,v|
+              "<p>#{k} - #{v}</p>"
+            end.join("\n")
+          }
+        </html>
+      }
+      res.finish
+    end
+  end
+  Rack::CookieMonster.configure do |c|
+    c.eat :cookie_1
+    c.eat :cookie_2
+  end
+  use Rack::CookieMonster
+  run CookieMonsterApplication.new

data/features/cookie_monster.feature ADDED

@@ -0,0 +1,50 @@
+Feature: Eats Cookies
+Scenario: Browser with user agent that cookie monster shares with
+  Given I go to "/"
+  And I fill in "Cookie 1" for the text field named "cookie_1"
+  And I fill in "Cookie 2" for the text field named "cookie_2"
+  And I fill in "Noncookie" for the text field named "non_cookie"
+  When I press "Submit"
+  Then I should see "cookies" for
+    | name      | value     |
+    | cookie_1  | Cookie 1  |
+    | cookie_2  | Cookie 2  |
+  But I should not see "cookies" for
+    | name        | value       |
+    | non_cookie  | Noncookie   |
+  But I should see "params" for
+    | name        | value       |
+    | non_cookie  | Noncookie   |
+Scenario: User agent does not match cookie monster's share list
+  Given I change my browser to "ie"
+  When I go to "/"
+  And I fill in "Cookie 1" for the text field named "cookie_1"
+  And I fill in "Cookie 2" for the text field named "cookie_2"
+  And I fill in "Noncookie" for the text field named "non_cookie"
+  When I press "Submit"
+  Then I should not see "cookies" for
+    | name      | value     |
+    | cookie_1  | Cookie 1  |
+    | cookie_2  | Cookie 2  |
+  But I should see "params" for
+    | name        | value       |
+    | non_cookie  | Noncookie   |
+    | cookie_1    | Cookie 1    |
+    | cookie_2    | Cookie 2    |
+Scenario: Browser that has existing cookies for domain
+  Given My browser has the following cookies
+    | name    | value   |
+    | session | secrets |
+    | creds   | street  |
+  When I go to "/"
+  And I fill in "Cookie 1" for the text field named "cookie_1"
+  And I press "Submit"
+  Then I should see "cookies" for
+    | name      | value     |
+    | cookie_1  | Cookie 1  |
+    | session   | secrets   |
+    | creds     | street    |

data/features/monster.ru ADDED

@@ -0,0 +1,49 @@
+class CookieMonsterApplication
+  def call(env)
+    request = ::Rack::Request.new(env)
+    cookies = request.cookies
+    params = request.params
+    res = ::Rack::Response.new
+    res.write %{
+      <html>
+        <head>
+          <title>Form</title>
+        </head>
+        <body>
+          <p>#{env.inspect}</p>
+          <form action="/" method="post">
+            Cookie 1: <input type="text" name="cookie_1" />
+            Cookie 2: <input type="text" name="cookie_2" />
+            Non Cookie: <input type="text" name="non_cookie" />
+            <input type="submit" value="Submit" />
+          </form>
+          <div id="cookies">
+          #{
+            cookies.map do |k,v|
+              "<p>#{k} - #{v}</p>"
+            end.join("\n")
+          }
+          </div>
+          <div id="params">
+          #{
+            params.map do |k,v|
+              "<p>#{k} - #{v}</p>"
+            end.join("\n")
+          }
+          </div>
+        </body>
+      </html>
+    }
+    res.finish
+  end
+end
+Rack::CookieMonster.configure do |c|
+  c.eat :cookie_1
+  c.eat :cookie_2
+  c.share_with /firefox/i
+end
+use Rack::CookieMonster
+run CookieMonsterApplication.new

data/features/step_definitions/all_steps.rb ADDED

@@ -0,0 +1,23 @@
+And %r{I change my browser to "(\w+)"} do |browser|
+  $browser = Culerity::RemoteBrowserProxy.new $server, {:browser => browser}
+  $browser.extend BrowserExtensions
+end
+And %r{^I should( not)? see "([^"]+)" for$} do |not_see, container_id, table|
+  table.hashes.each do |h|
+    container = $browser.div(:id, container_id)
+    if not_see
+      lambda {
+        container.p(:text, "#{h['name']} - #{h['value']}").text
+      }.should raise_error(/unable to locate/i)
+    else
+      container.p(:text, "#{h['name']} - #{h['value']}").text.should_not be_nil
+    end
+  end
+end
+Given "My browser has the following cookies" do |table|
+  table.hashes.each do |h|
+    $browser.add_cookie("localhost", h["name"], h["value"])
+  end
+end

data/features/step_definitions/common_celerity.rb ADDED

@@ -0,0 +1,163 @@
+module BrowserExtensions
+  def current_html
+    div(:xpath => "/.").html
+  end
+end
+Then %r{^I eval:?(.*)} do |code|
+  eval code
+end
+When %r{^I (am curious|debug)} do |what|
+  require 'ruby-debug'
+  debugger
+end
+And "I pass out" do
+  sleep
+end
+Then /I should be redirected to "(.*)"/ do |url|
+  $browser.url.should == url
+end
+When /I press "(.*)"/ do |button|
+  $browser.button(:text, button).click
+  assert_successful_response
+end
+When /I follow "(.*)"/ do |link|
+  $browser.link(:text, /#{link}/).click
+  assert_successful_response
+end
+When %r{^I browse to "([^"]+)"$} do |url|
+  $browser.goto url
+end
+When %r{^I refresh$} do
+  $browser.refresh
+end
+When /I fill in "(.*)" for "(.*)"/ do |value, field|
+  $browser.text_field(:id, find_label(field).for).set(value)
+end
+And %r{^I select file "([^"]*)" for "([^"]*)"$} do |file, field|
+  $browser.file_field(:id, find_label(field).for).set(test_file(file))
+end
+When %r{^I fill in "([^"]*)" for the text field named "([^"]*)"$} do |value, field|
+  $browser.text_field(:name, field).set(value)
+end
+When "I go back" do
+  $browser.back
+end
+When /I check "(.*)"/ do |field|
+  $browser.check_box(:id, find_label(field).for).set(true)
+end
+When /^I uncheck "(.*)"$/ do |field|
+  $browser.check_box(:id, find_label(field).for).set(false)
+end
+When /I select "(.*)" from "(.*)"/ do |value, field|
+  $browser.select_list(:id, find_label(field).for).select value
+end
+When /I select "(.*)" from select field "(.*)"/ do |value, field|
+  $browser.select_list(:name => field).select value
+end
+When /I choose "(.*)"/ do |field|
+  $browser.radio(:id, find_label(field).for).set(true)
+end
+When /I go to "(.+)"/ do |path|
+  $browser.goto @host + path
+  assert_successful_response
+end
+When /I wait for the (AJAX|restful).*/ do |what|
+  $browser.wait
+end
+When %r{I wait (\d+) seconds} do |seconds|
+  sleep seconds.to_i
+end
+Then %r{^I should see "([^"]+)"$} do |text|
+  $browser.current_html.should match(text)
+end
+When /I puts/ do ||
+  puts $browser.current_html
+end
+Then %r{^I should not see "([^"]+)"$} do |text|
+  $browser.current_html.should_not match(text)
+end
+Then %r{^I change "([^"]+)" to "([^"]+)"$} do |field, value|
+  $browser.text_field(:id, find_label(field).for).set(value)
+end
+Then %r{^I should see "([^\"]*)" with value "([^\"]*)"$} do |field_selector, value|
+  doc = Nokogiri.HTML($browser.current_html)
+  node = doc.at("//*[@id = //label[contains(.,'#{field_selector}')]/@for]")
+  node ||= doc.at("##{field_selector}")
+  node ||= doc.at("*[@name = '#{field_selector}']")
+  case node.name
+  when "input"
+    node["value"].should include(value)
+  when 'textarea'
+    node.text.should include(value)
+  else
+    raise "Bad field type: don't know how to check value of a node of type #{node.name}. You should add support!"
+  end
+end
+Then %r{^I should see the radio buttons with these settings$} do |table|
+  table.raw.each do |label, state|
+    radio = $browser.radio(:id, find_label(label).for)
+    case state
+    when "checked"
+      radio.should be_checked
+    when "unchecked"
+      radio.should_not be_checked
+    end
+  end
+end
+Then %r{^I should see the "([^"]+)" form$} do |form|
+  $browser.current_html.should have_selector("form##{form}_form")
+end
+When %r{^I browse$} do ||
+  page = $browser.current_html
+  puts page
+end
+def find_label(text)
+  $browser.label :text, text
+end
+def assert_successful_response(allow_bad_response=false)
+  status = $browser.page.web_response.status_code
+  if(status == 302 || status == 301)
+    location = $browser.page.web_response.get_response_header_value('Location')
+    puts "Being redirected to #{location}"
+    $browser.goto location
+    assert_successful_response
+  elsif status != 200 and !allow_bad_response
+    raise "Browser returned Response Code #{$browser.page.web_response.status_code}"
+  end
+end
+def fill_in_textfield(field, value)
+  $browser.text_field(:id, find_label(field).for).set(value)
+end

data/features/support/celerity_startup.rb ADDED

@@ -0,0 +1,57 @@
+require 'culerity'
+SERVER_PID = "server.pid"
+$port = 9292
+$host = "http://localhost:#{$port}"
+Before do
+  $browser = Culerity::RemoteBrowserProxy.new $server, {:browser => :firefox}
+  module BrowserExtensions; end
+  $browser.extend BrowserExtensions
+  @host = $host
+  @port = $port
+end
+def kill_test_server
+  if File.exist?(SERVER_PID)
+    test_server_pid = File.read(SERVER_PID).to_i
+    puts "Killing #{test_server_pid}"
+    Process.kill "KILL", test_server_pid
+    File.delete SERVER_PID
+  end
+end
+def host_listening_on_port?(host, port, timeout=0)
+  start_time = Time.now
+  begin
+    socket = TCPSocket.open(host, port)
+    socket.close
+    return true
+  rescue Errno::ECONNREFUSED
+    if Time.now - start_time < timeout
+      # try to connect again
+      sleep 0.25
+      retry
+    else
+      return false
+    end
+  end
+end
+if host_listening_on_port? "localhost", $port
+  puts "Server already running on test port. Killing it..."
+  kill_test_server
+end
+%x(bin/rackup --require lib/rack/cookie_monster --require vendor/gems/environment --daemon --pid #{SERVER_PID} --server webrick features/monster.ru)
+raise "Couldn't start server" unless host_listening_on_port? "localhost", $port, 10
+$server ||= Culerity::run_server
+at_exit do
+  kill_test_server
+  $browser.exit
+  $server.close
+end

data/lib/rack/cookie_monster.rb ADDED

@@ -0,0 +1,104 @@
+module Rack
+  class CookieMonster
+    class Hungry < StandardError; end
+    class<<self
+      def configure
+        @config ||= CookieMonsterConfig.new
+        yield(@config)
+        @configured = true
+      end
+      def snackers
+        ensure_monster_configured!
+        @config.snackers
+      end
+      def cookies
+        ensure_monster_configured!
+        @config.cookies
+      end
+      def configure_for_rails
+        ensure_monster_configured!
+        ActionController::Dispatcher.middleware.insert_before(
+          ActionController::Base.session_store,
+          self
+        )
+      end
+      private
+      def ensure_monster_configured!
+        raise Hungry.new("Cookie Monster has not been configured") unless @configured
+      end
+    end
+    def initialize(app)
+      @app = app
+    end
+    def call(env)
+      shares_with(env["HTTP_USER_AGENT"]) do
+        request = ::Rack::Request.new(env)
+        eat_cookies!(env, request)
+      end
+      @app.call(env)
+    end
+    private
+    def shares_with(agent)
+      yield if self.class.snackers.empty?
+      any_matches = self.class.snackers.any? do |snacker|
+        case snacker
+        when String
+          snacker == agent
+        when Regexp
+          snacker.match(agent) != nil
+        end
+      end
+      yield if any_matches
+    end
+    def eat_cookies!(env, request)
+      cookies = request.cookies
+      new_cookies = {}
+      self.class.cookies.each do |cookie_name|
+        value = request.params[cookie_name.to_s]
+        if value
+          cookies.delete(cookie_name.to_s)
+          new_cookies[cookie_name.to_s] = value
+        end
+      end
+      new_cookies.merge!(cookies)
+      env["HTTP_COOKIE"] = new_cookies.map do |k,v|
+        "#{k}=#{v}"
+      end.compact.join("; ").freeze
+    end
+  end
+  class CookieMonsterConfig
+    attr_reader :cookies, :snackers
+    def initialize
+      @cookies = []
+      @snackers = []
+    end
+    def eat(cookie)
+      @cookies << cookie.to_sym
+    end
+    def share_with(snacker)
+      @snackers << snacker
+    end
+  end
+end

data/spec/rack/cookie_monster_spec.rb ADDED

@@ -0,0 +1,131 @@
+require 'spec_helper'
+require 'rack/cookie_monster'
+require 'action_controller'
+describe Rack::CookieMonster do
+  subject { Class.new(described_class) }
+  describe ".configure" do
+    it "specifies what cookies are to be eaten" do
+      subject.configure do |c|
+        c.eat :_session_id
+        c.eat :user_credentials
+      end
+      subject.cookies.should == [:_session_id, :user_credentials]
+    end
+    it "turns the cookie keys into symbols" do
+      subject.configure do |c|
+        c.eat "burt"
+      end
+      subject.cookies.should == [:burt]
+    end
+    it "specifies what user agents can snack" do
+      subject.configure do |c|
+        c.share_with "MSIE 6.0"
+        c.share_with /safari \d+/
+      end
+      subject.snackers.should == ["MSIE 6.0", /safari \d+/]
+    end
+    it "raises an error if it is not configured" do
+      lambda { subject.cookies }.should raise_error(Rack::CookieMonster::Hungry, /not been configured/i)
+      lambda { subject.snackers }.should raise_error(Rack::CookieMonster::Hungry, /not been configured/i)
+      lambda { subject.configure_for_rails }.should raise_error(Rack::CookieMonster::Hungry, /not been configured/i)
+    end
+  end
+  describe ".configure_for_rails" do
+    it "injects itself into the rails request stack" do
+      subject.configure {}
+      subject.configure_for_rails
+      ActionController::Dispatcher.middleware[2].should == subject
+      ActionController::Dispatcher.middleware[3].should == ActionController::Session::CookieStore
+    end
+  end
+  describe "#call" do
+    before do
+      @target = subject.new(stub_instance(:app))
+      @environment = {
+        "HTTP_COOKIE" => "",
+        "QUERY_STRING" => "oatmeal_cookie=delicious&chocolate_cookie=yummy&burt=ernie&oats=honey",
+        "REQUEST_METHOD" => "PUT"
+      }
+      subject.configure do |c|
+        c.eat :oatmeal_cookie
+        c.eat :chocolate_cookie
+      end
+      @app.stubs(:call)
+    end
+    it "builds cookie string from environment params" do
+      @app.expects(:call).with do |env|
+        env["HTTP_COOKIE"].should == "chocolate_cookie=yummy; oatmeal_cookie=delicious"
+        env["HTTP_COOKIE"].should be_frozen
+      end
+      @target.call(@environment)
+    end
+    it "will play nice with existing cookies" do
+      @environment["HTTP_COOKIE"] = "oatmeal_cookie=gross; peanutbutter_cookie=good"
+      @app.expects(:call).with do |env|
+        env["HTTP_COOKIE"].should == "peanutbutter_cookie=good; chocolate_cookie=yummy; oatmeal_cookie=delicious"
+      end
+      @target.call(@environment)
+    end
+    it "will not append an empty cookie" do
+      @environment["QUERY_STRING"] = ""
+      @app.expects(:call).with do |env|
+        env["HTTP_COOKIE"].should == ""
+        env["HTTP_COOKIE"].should be_frozen
+      end
+      @target.call(@environment)
+    end
+    describe "optional user agents" do
+      before do
+        subject.configure do |c|
+          c.share_with /^(Adobe|Shockwave) Flash/
+          c.share_with "MSIE 6.0"
+        end
+        @cookies = "chocolate_cookie=yummy; oatmeal_cookie=delicious"
+      end
+      it "will match against regular expressions" do
+        @app.expects(:call).with(has_entry("HTTP_COOKIE", @cookies)).twice
+        @app.expects(:call).with(has_entry("HTTP_COOKIE", "")).once
+        @environment["HTTP_USER_AGENT"] = "Shockwave Flash"
+        @target.call(@environment.dup)
+        @environment["HTTP_USER_AGENT"] = "Adobe Flash"
+        @target.call(@environment.dup)
+        @environment["HTTP_USER_AGENT"] = "Flash"
+        @target.call(@environment.dup)
+      end
+      it "will exact match against strings" do
+        @app.expects(:call).with(has_entry("HTTP_COOKIE", @cookies)).once
+        @app.expects(:call).with(has_entry("HTTP_COOKIE", "")).once
+        @environment["HTTP_USER_AGENT"] = "MSIE 6.0"
+        @target.call(@environment.dup)
+        @environment["HTTP_USER_AGENT"] = "MSIE"
+        @target.call(@environment.dup)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb ADDED

@@ -0,0 +1,15 @@
+here = File.expand_path(File.dirname(__FILE__))
+require File.join(here, "..", "vendor/gems/environment")
+require File.join(here, "..", "init")
+require 'spec/autorun'
+require 'mocha'
+require 'active_support'
+require 'rack'
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+Spec::Runner.configure do |config|
+  config.include(SpecInstanceHelpers)
+  config.mock_with :mocha
+end

data/spec/support/stub_helpers.rb ADDED

@@ -0,0 +1,164 @@
+module SpecInstanceHelpers
+  def stub_instance_hash(*instance_names)
+    hash = {}
+    instance_names.each do |instance_name|
+      hash[instance_name] = stub_instance(instance_name)
+    end
+    hash
+  end
+  def stub_string_hash(*instance_names)
+    hash = {}
+    instance_names.each do |instance_name|
+      hash[instance_name] = stub_string(instance_name)
+    end
+    hash
+  end
+  def create_array_of_stubs(instance, count, stubbings)
+    stub_array = stub_array_instance(instance, count, instance.to_s.singularize)
+    stub_array.each do |stub|
+      stubbings.each do |key, value_lambda|
+        stub.stub!(key).and_return(value_lambda.call)
+      end
+    end
+  end
+  def stub_instance(var_name, options={})
+    var_name = var_name.to_s.gsub(/[\?!]/, "")
+    the_stub = stub(var_name.to_s.humanize, options)
+    instance_variable_set("@#{var_name}", the_stub)
+    the_stub
+  end
+  def stub_array_instance(ivar_sym, count, label=nil)
+    label ||= ivar_sym.to_s.singularize
+    array = stub_array(count, label)
+    instance_variable_set("@#{ivar_sym}", array)
+    array
+  end
+  def stub_array(count, label)
+    array = []
+    1.upto(count) do |i|
+      array << stub("#{label} #{i}")
+    end
+    array
+  end
+  def stub_instances(*var_names)
+    var_names.map do |var_name|
+      stub_instance var_name
+    end
+  end
+  def stub_params(*param_names)
+    @params = {}
+    param_names.each do |param_name|
+      instance_variable_set("@#{param_name}", "param #{param_name}")
+      @params[param_name.to_s] = "param #{param_name}"
+    end
+    @params
+  end
+  def stub_partial(partial, options={})
+    options = _prepare_stub_partial_options(partial, options)
+    template.stub!(:render).with(options).and_return(%|<p id="#{partial.gsub(/\//,'_')}_partial"></p>|)
+  end
+  def stub_partials(*partials)
+    partials.each &method(:stub_partial)
+  end
+  def stub_string(sym)
+    the_stub = sym.to_s.humanize
+    instance_variable_set("@#{sym}", the_stub)
+    the_stub
+  end
+  def stub_strings(*syms)
+    syms.each &method(:stub_string)
+  end
+  def stub_for_view(name, field_names)
+    the_stub = stub_instance(name)
+    _stub_methods_for_view(the_stub, field_names)
+    the_stub
+  end
+  def expect_and_render_partial(partial,options={})
+    options = _prepare_stub_partial_options(partial, options)
+    template.should_receive(:render).with(options).and_return(%|<p id="#{partial.gsub(/\//,'_')}_partial"></p>|)
+  end
+  def _stub_methods_for_view(the_stub, field_names)
+    field_names.each do |fname|
+      case fname
+      when String, Symbol
+        field_name = fname.to_sym
+        field_value = block_given?  ? yield(fname) : "The #{fname.to_s.humanize}"
+        the_stub.stub!(field_name).and_return(field_value)
+      when Hash
+        fname.each do |k,v|
+          the_stub.stub!(k.to_sym).and_return(v)
+        end
+      end
+    end
+  end
+  def _prepare_stub_partial_options(partial, options)
+    options.reverse_merge!(:partial => partial)
+    if options[:locals] == false
+      options.delete(:locals)
+    else
+      options.reverse_merge!(:locals => anything)
+    end
+    options
+  end
+  def stub_array_for_view(count, name_base, field_names)
+    the_array = []
+    count.times do |i|
+      i = i + 1 # one-based numbering
+      name = "#{name_base.to_s.singularize}#{i}"
+      the_stub = stub_instance(name)
+      _stub_methods_for_view(the_stub, field_names) do |fname|
+        "The #{fname.to_s.humanize} #{i}"
+      end
+      the_array << the_stub
+    end
+    instance_variable_set("@#{name_base}", the_array)
+    the_array
+  end
+end
+class NilClass
+  # Mocha:
+  def expects(*args)
+    raise "Don't expects(#{args.inspect}) on nil"
+  end
+  def stubs(*args)
+    raise "Don't stubs(#{args.inspect}) on nil"
+  end
+  # RSpec mocks:
+  #
+  def stub!(*args)
+    raise "Don't stub! on nil."
+  end
+  def should_receive(*args)
+    raise "Don't should_receive on nil."
+  end
+  def should_not_receive(*args)
+    raise "Don't should_not_receive on nil."
+  end
+end

metadata ADDED

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: rack-cookie-monster
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Justin DeWind
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2009-12-15 00:00:00 -05:00
+default_executable:
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  type: :runtime
+  version_requirement:
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    version:
+description: A rack middleware library that allows cookies to be passed through forms
+email: dewind@atomicobject.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- lib/rack/cookie_monster.rb
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/dewind/rack-cookie-monster
+licenses: []
+post_install_message:
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: "0"
+  version:
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: "0"
+  version:
+requirements: []
+rubyforge_project:
+rubygems_version: 1.3.5
+signing_key:
+specification_version: 3
+summary: A rack middleware library that allows cookies to be passed through forms
+test_files:
+- spec/rack/cookie_monster_spec.rb
+- spec/spec_helper.rb
+- spec/support/stub_helpers.rb
+- features/cookie_monster.feature
+- features/monster.ru
+- features/step_definitions/all_steps.rb
+- features/step_definitions/common_celerity.rb
+- features/support/celerity_startup.rb