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

rack-cookie-monster 1.0.0

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