rack-session-file 0.3.0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2012 ITO Nobuaki
+Copyright (c) 2011 Uchio Kondo
+Copyright (c) 2010 Jonathan Rudenberg
+
+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,72 @@
+# Rack::Session::File
+
+Rack session store on plain file system.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rack-session-file', :git =>
+  'git://github.com/dayflower/rack-session-file.git'
+```
+
+And then execute:
+
+    $ bundle install
+
+## Usage
+
+```ruby
+use Rack::Session::File, :storage => ENV['TEMP'],
+                         :expire_after => 1800
+```
+
+### Options
+
+#### File storage directory (`:storage`)
+
+Default is `Dir.tmpdir`.
+
+#### Backend serializer (`:driver`)
+
+You can specify backend serializer via `:driver` option.
+
+```ruby
+use Rack::Session::File, :driver => :YAML
+```
+
+Bundled drivers are:
+
+* `:PStore` (default)
+* `:YAML`
+* `:Marshal` (discouraged to use)
+
+Also you can `use` backend driver class explicitly.
+
+```ruby
+use Rack::Session::File::YAML
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Acknowledgement
+
+Most of main code and test codes are derived from
+titanous's [mongo-store](https://github.com/titanous/mongo-store)
+and udzura's [rack-session-dbm](https://github.com/udzura/rack-session-dbm).
+
+## Copyright and license
+
+Copyright © 2012 ITO Nobuaki.  
+Copyright © 2011 Uchio Kondo. (as the author of
+  [rack-session-dbm](https://github.com/udzura/rack-session-dbm) )  
+Copyright © 2010 Jonathan Rudenberg. (as the author of
+  [mongo-store](https://github.com/titanous/mongo-store) )  
+See LICENSE for details (MIT License).

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/rack-session-file.rb

@@ -0,0 +1 @@
+require File.expand_path(File.dirname(__FILE__) + '/rack/session/file')

data/lib/rack/session/file.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+
+module Rack
+  module Session
+    module File
+      VERSION = '0.3.0'
+
+      autoload :Marshal, 'rack/session/file/marshal'
+      autoload :PStore, 'rack/session/file/pstore'
+      autoload :YAML, 'rack/session/file/yaml'
+
+      def self.new(app, options = {})
+        mapping = {
+          :pstore  => :PStore,
+          :yaml    => :YAML,
+          :marshal => :Marshal,
+        }
+
+        driver = options.delete(:driver) || :pstore
+        driver = mapping[driver.to_s.downcase.to_sym] || driver if driver.is_a?(Symbol)
+        if ! driver.is_a?(Class)
+          require autoload?(driver) if autoload?(driver)
+          driver = const_get(driver)
+        end
+
+        return driver.new(app, options)
+      end
+    end
+  end
+end

data/lib/rack/session/file/abstract.rb

@@ -0,0 +1,168 @@
+# coding: utf-8
+require 'rubygems'
+require 'rack/session/abstract/id'
+
+module Rack
+  module Session
+    module File
+      class Abstract < Rack::Session::Abstract::ID
+        DEFAULT_OPTIONS = Rack::Session::Abstract::ID::DEFAULT_OPTIONS.merge({
+          :storage             => Dir.tmpdir,
+          :clear_expired_after => 30 * 60,
+        })
+
+        def initialize(app, options = {})
+          super
+
+          @storage               = @default_options.delete(:storage)
+          @recheck_expire_period = @default_options.delete(:clear_expired_after).to_i
+
+          @next_expire_period = nil
+
+          @transaction_options = {
+            :storage => @storage,
+          }
+        end
+
+        def get_session(env, sid)
+          new_transaction(env).with_lock do |transaction|
+            session = find_session(env, sid) if sid
+            unless sid and session
+              env['rack.errors'].puts("Session '#{sid}' not found, initializing...")  if $VERBOSE and not sid.nil?
+              session = {}
+              sid = new_sid(env)
+              transaction.save_session(sid)
+            end
+            session.instance_variable_set('@old', {}.merge(session))
+            session.instance_variable_set('@sid', sid)
+            return [sid, session]
+          end
+        end
+
+        def set_session(env, sid, new_session, options)
+          new_transaction(env).with_lock do |transaction|
+            expires = Time.now + options[:expire_after]  if ! options[:expire_after].nil?
+            session = find_session(env, sid) || {}
+
+            if options[:renew] or options[:drop]
+              transaction.delete_session(sid)
+              return false  if options[:drop]
+              sid = new_sid(env)
+              #transaction.save_session(sid, session, expires)
+            end
+
+            old_session = new_session.instance_variable_defined?('@old') ? new_session.instance_variable_get('@old') : {}
+            session = merge_sessions(sid, old_session, new_session, session)
+            transaction.save_session(sid, session, expires)
+            return sid
+          end
+        end
+
+        def destroy_session(env, sid, options)
+          new_transaction(env).with_lock do |transaction|
+            transaction.delete_session(sid)
+            new_sid(env)  unless options[:drop]
+          end
+        end
+
+        private
+
+        def new_transaction(env)
+          raise '#new_transaction not implemented'
+        end
+
+        def new_sid(env)
+          loop do
+            sid = generate_sid()
+            break sid unless find_session(env, sid)
+          end
+        end
+
+        def find_session(env, sid)
+          transaction = new_transaction(env)
+
+          time = Time.now
+          if @recheck_expire_period != -1 && (@next_expire_period.nil? || @next_expire_period < time)
+            @next_expire_period = time + @recheck_expire_period
+            transaction.expire_sessions(time)
+          end
+
+          transaction.find_session(sid)
+        end
+
+        def merge_sessions(sid, old, new, current = nil)
+          current ||= {}
+          unless Hash === old and Hash === new
+            warn 'Bad old or new sessions provided.'
+            return current
+          end
+
+          # delete keys that are not in common
+          deletes = current.keys - (new.keys & current.keys)
+          warn "//@#{sid}: dropping #{deletes*','}"  if $DEBUG and not deletes.empty?
+          deletes.each { |k| current.delete(k) }
+
+          updates = new.keys.select { |k| ! current.has_key?(k) || new[k] != current[k] || new[k].kind_of?(Hash) || new[k].kind_of?(Array) }
+          warn "//@#{sid}: updating #{updates*','}"  if $DEBUG and not updates.empty?
+          updates.each { |k| current[k] = new[k] }
+
+          return current
+        end
+
+        class Transaction
+          def initialize(env, options = {})
+            @env = env
+            @storage = options[:storage]
+            @mutex = Mutex.new if want_thread_safe?
+          end
+
+          def with_lock
+            @mutex.lock if want_thread_safe?
+            begin
+              yield(self)
+            ensure
+              @mutex.unlock if want_thread_safe?
+            end
+          end
+
+          def find_session(sid)
+            session = load_session(sid)
+
+            if session && session[:expires] != nil && session[:expires] < Time.now
+              delete_session(sid)
+              session = nil
+            end
+
+            return session ? session[:data] : nil
+          end
+
+          def save_session(sid, session = {}, expires = nil)
+            store_session(sid, { :data => session, :expires => expires })
+          end
+
+          def store_session(sid, data)
+            raise '#store_session not implemented'
+          end
+
+          def load_session(sid)
+            raise '#load_session not implemented'
+          end
+
+          def delete_session(sid)
+            raise '#delete_session not implemented'
+          end
+
+          def expire_sessions(time)
+            raise '#expire_sessions not implemented'
+          end
+
+          private
+
+          def want_thread_safe?
+            @env['rack.multithread']
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/session/file/marshal.rb

@@ -0,0 +1,66 @@
+# coding: utf-8
+require 'rubygems'
+require 'fileutils'
+require File.expand_path(File.dirname(__FILE__) + '/abstract')
+
+module Rack
+  module Session
+    module File
+      class Marshal < Abstract
+        def new_transaction(env)
+          Rack::Session::File::Marshal::Transaction.new(env, @transaction_options)
+        end
+
+        class Transaction < Rack::Session::File::Abstract::Transaction
+          def store_session(sid, data)
+            open_session_file(sid, 'w') do |file|
+              ::Marshal.dump(data, file)
+            end
+          end
+
+          def load_session(sid)
+            begin
+              open_session_file(sid, 'r') do |file|
+                return ::Marshal.load(file)
+              end
+            rescue Errno::ENOENT
+              return nil
+          end
+          end
+
+          def delete_session(sid)
+            filename = session_file_name(sid)
+            if ::File.exists?(filename)
+              ::File.unlink(filename)
+            end
+          end
+
+          def expire_sessions(time)
+            # TODO
+          end
+
+          private
+
+          def open_session_file(sid, mode = 'r')
+            ensure_storage_accessible() if mode =~ /^w/
+            if block_given?
+              open(session_file_name(sid), mode) do |file|
+                yield file
+              end
+            else
+              return open(session_file_name(sid), mode)
+            end
+          end
+
+          def session_file_name(sid)
+            return ::File.join(@storage, sid)
+          end
+
+          def ensure_storage_accessible
+            FileUtils.mkdir_p(@storage)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/session/file/pstore.rb

@@ -0,0 +1,70 @@
+# coding: utf-8
+require 'rubygems'
+require 'fileutils'
+require 'pstore'
+require File.expand_path(File.dirname(__FILE__) + '/abstract')
+
+module Rack
+  module Session
+    module File
+      class PStore < Abstract
+        def new_transaction(env)
+          Rack::Session::File::PStore::Transaction.new(env, @transaction_options)
+        end
+
+        class Transaction < Rack::Session::File::Abstract::Transaction
+          def store_session(sid, data)
+            ensure_storage_accessible()
+
+            store_for_sid(sid).transaction do |db|
+              data.keys.each do |key|
+                db[key] = data[key]
+              end
+            end
+          end
+
+          def load_session(sid)
+            ensure_storage_accessible()
+
+            data = {}
+            store_for_sid(sid).transaction(true) do |db|
+              db.roots.each do |key|
+                data[key] = db[key]
+              end
+            end
+            return data
+          end
+
+          def delete_session(sid)
+            filename = store_for_sid(sid).path
+            if ::File.exists?(filename)
+              ::File.unlink(filename)
+            end
+          end
+
+          def expire_sessions(time)
+            # TODO
+          end
+
+          private
+
+          def store_for_sid(sid)
+            begin
+              ::PStore.new(session_file_name(sid), want_thread_safe?)
+            rescue ArgumentError
+              ::PStore.new(session_file_name(sid))
+            end
+          end
+
+          def session_file_name(sid)
+            return ::File.join(@storage, sid)
+          end
+
+          def ensure_storage_accessible
+            FileUtils.mkdir_p(@storage)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/session/file/yaml.rb

@@ -0,0 +1,76 @@
+# coding: utf-8
+require 'rubygems'
+require 'fileutils'
+require 'yaml/store'
+require File.expand_path(File.dirname(__FILE__) + '/abstract')
+
+module Rack
+  module Session
+    module File
+      class YAML < Abstract
+        def initialize(app, options = {})
+          super
+          @transaction_options['yaml'] = @default_options.delete(:yaml) || {}
+        end
+
+        def new_transaction(env)
+          Rack::Session::File::YAML::Transaction.new(env, @transaction_options)
+        end
+
+        class Transaction < Rack::Session::File::Abstract::Transaction
+          def initialize(env, options = {})
+            super
+            @yaml_options = options[:yaml] || {}
+          end
+
+          def store_session(sid, data)
+            ensure_storage_accessible()
+
+            store_for_sid(sid).transaction do |db|
+              data.keys.each do |key|
+                db[key] = data[key]
+              end
+            end
+          end
+
+          def load_session(sid)
+            ensure_storage_accessible()
+
+            data = {}
+            store_for_sid(sid).transaction(true) do |db|
+              db.roots.each do |key|
+                data[key] = db[key]
+              end
+            end
+            return data
+          end
+
+          def delete_session(sid)
+            filename = store_for_sid(sid).path
+            if ::File.exists?(filename)
+              ::File.unlink(filename)
+            end
+          end
+
+          def expire_sessions(time)
+            # TODO
+          end
+
+          private
+
+          def store_for_sid(sid)
+            ::YAML::Store.new(session_file_name(sid), @yaml_options)
+          end
+
+          def session_file_name(sid)
+            return ::File.join(@storage, sid)
+          end
+
+          def ensure_storage_accessible
+            FileUtils.mkdir_p(@storage)
+          end
+        end
+      end
+    end
+  end
+end

data/rack-session-file.gemspec

@@ -0,0 +1,50 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["ITO Nobuaki"]
+  gem.email         = ["daydream.trippers@gmail.com"]
+  gem.description   = %q{A rack-based session store on plain file system.}
+  gem.summary       = %q{A rack-based session store on plain file system}
+  gem.homepage      = ""
+
+  gem.files         = [
+    "rack-session-file.gemspec",
+    "Gemfile",
+    "LICENSE",
+    "README.md",
+    "Rakefile",
+    "lib/rack-session-file.rb",
+    "lib/rack/session/file.rb",
+    "lib/rack/session/file/abstract.rb",
+    "lib/rack/session/file/marshal.rb",
+    "lib/rack/session/file/pstore.rb",
+    "lib/rack/session/file/yaml.rb",
+    "spec/common.rb",
+    "spec/rack-session-file_spec.rb",
+    "spec/rack-session-file-marshal_spec.rb",
+    "spec/rack-session-file-pstore_spec.rb",
+    "spec/rack-session-file-yaml_spec.rb",
+    "spec/spec_helper.rb",
+  ]
+
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "rack-session-file"
+  gem.require_paths = ["lib"]
+  gem.version       = '0.3.0'
+
+  if gem.respond_to? :specification_version then
+    gem.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      gem.add_runtime_dependency 'rack', '>= 1.1.0'
+      gem.add_development_dependency 'rspec', '>= 1.2.9'
+    else
+      gem.add_dependency 'rack', '>= 1.1.0'
+      gem.add_dependency 'rspec', '>= 1.2.9'
+    end
+  else
+    gem.add_dependency 'rack', '>= 1.1.0'
+    gem.add_dependency 'rspec', '>= 1.2.9'
+  end
+end

data/spec/common.rb

@@ -0,0 +1,164 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'fileutils'
+require 'tempfile'
+
+shared_examples_for Rack::Session::File do
+  before(:all) do
+    if described_class.constants.include?(:DEFAULT_OPTIONS)
+      @session_key = described_class::DEFAULT_OPTIONS[:key]
+    else
+      require 'rack/session/abstract/id'
+      @session_key = Rack::Session::Abstract::ID::DEFAULT_OPTIONS[:key]
+    end
+    @session_match = /#{@session_key}=[0-9A-Fa-f]+;/
+
+    tf = Tempfile.open("racksess")
+    @storage = tf.path
+    tf.close!
+
+    @increment_mockapp = lambda do |env|
+      env['rack.session']['counter'] ||= 0
+      env['rack.session']['counter'] += 1
+      Rack::Response.new(env['rack.session'].inspect).finish
+    end
+
+    @drop_session_mockapp = lambda do |env|
+      env['rack.session.options'][:drop] = true
+      @increment_mockapp.call(env)
+    end
+
+    @renew_session_mockapp = lambda do |env|
+      env['rack.session.options'][:renew] = true
+      @increment_mockapp.call(env)
+    end
+
+    @defer_session_mockapp = lambda do |env|
+      env['rack.session.options'][:defer] = true
+      @increment_mockapp.call(env)
+    end
+  end
+
+  after(:all) do
+    FileUtils.remove_dir(@storage)
+  end
+
+  let(:pool) { pool = described_class.new(@increment_mockapp, :storage => @storage) }
+
+  it 'creates a new cookie' do
+    res = Rack::MockRequest.new(pool).get('/')
+
+    res['Set-Cookie'].should match(/#{@session_key}=/)
+    res.body.should == '{"counter"=>1}'
+  end
+
+  it 'determines session from a cookie' do
+    req = Rack::MockRequest.new(pool)
+
+    res = req.get('/')
+    cookie = res['Set-Cookie']
+
+    res = req.get('/', 'HTTP_COOKIE' => cookie)
+    res.body.should == '{"counter"=>2}'
+
+    res = req.get('/', 'HTTP_COOKIE' => cookie)
+    res.body.should == '{"counter"=>3}'
+  end
+
+  it 'survives nonexistent cookies' do
+    bad_cookie = 'rack.session=blarghfasel'
+    res = Rack::MockRequest.new(pool) \
+            .get('/', 'HTTP_COOKIE' => bad_cookie)
+
+    res.body.should == '{"counter"=>1}'
+    cookie = res['Set-Cookie'][@session_match]
+    cookie.should_not match(/#{bad_cookie}/)
+  end
+
+  it 'should maintain freshness' do
+    pool2 = described_class.new(@increment_mockapp, :storage => @storage, :expire_after => 2)
+    expired_time = Time.now + 5
+    res = Rack::MockRequest.new(pool2).get('/')
+    res.body.should include('"counter"=>1')
+
+    cookie = res['Set-Cookie']
+
+    res = Rack::MockRequest.new(pool2).get('/', 'HTTP_COOKIE' => cookie)
+    res['Set-Cookie'].should == cookie
+    res.body.should include('"counter"=>2')
+
+    Time.stub!(:now).and_return(expired_time)
+
+    res = Rack::MockRequest.new(pool2).get('/', 'HTTP_COOKIE' => cookie)
+    res['Set-Cookie'].should_not == cookie
+    res.body.should include('"counter"=>1')
+  end
+
+  it 'deletes cookies with :drop option' do
+    req = Rack::MockRequest.new(pool)
+    drop = Rack::Utils::Context.new(pool, @drop_session_mockapp)
+    dreq = Rack::MockRequest.new(drop)
+
+    res0 = req.get('/')
+    session = (cookie = res0['Set-Cookie'])[@session_match]
+    res0.body.should == '{"counter"=>1}'
+
+    res1 = req.get('/', 'HTTP_COOKIE' => cookie)
+#   res1['Set-Cookie'][@session_match].should == session
+    res1.body.should == '{"counter"=>2}'
+
+    res2 = dreq.get('/', 'HTTP_COOKIE' => cookie)
+    res2['Set-Cookie'].should be_nil
+    res2.body.should == '{"counter"=>3}'
+
+    res3 = req.get('/', 'HTTP_COOKIE' => cookie)
+    res3['Set-Cookie'][@session_match].should_not == session
+    res3.body.should == '{"counter"=>1}'
+  end
+
+  it 'provides new session id with :renew option' do
+    req = Rack::MockRequest.new(pool)
+    renew = Rack::Utils::Context.new(pool, @renew_session_mockapp)
+    rreq = Rack::MockRequest.new(renew)
+
+    res0 = req.get('/')
+    session = (cookie = res0['Set-Cookie'])[@session_match]
+    res0.body.should == '{"counter"=>1}'
+
+    res1 = req.get('/', 'HTTP_COOKIE' => cookie)
+#   res1['Set-Cookie'][@session_match].should == session
+    res1.body.should == '{"counter"=>2}'
+
+    res2 = rreq.get('/', 'HTTP_COOKIE' => cookie)
+    new_cookie = res2['Set-Cookie']
+    new_session = new_cookie[@session_match]
+    new_session.should_not == session
+    res2.body.should == '{"counter"=>3}'
+
+    res3 = req.get('/', 'HTTP_COOKIE' => new_cookie)
+#   res3['Set-Cookie'][@session_match].should == new_session
+    res3.body.should == '{"counter"=>4}'
+  end
+
+  it 'omits cookie with :defer option' do
+    req = Rack::MockRequest.new(pool)
+    defer = Rack::Utils::Context.new(pool, @defer_session_mockapp)
+    dreq = Rack::MockRequest.new(defer)
+
+    res0 = req.get('/')
+    session = (cookie = res0['Set-Cookie'])[@session_match]
+    res0.body.should == '{"counter"=>1}'
+
+    res1 = req.get('/', 'HTTP_COOKIE' => cookie)
+#   res1['Set-Cookie'][@session_match].should == session
+    res1.body.should == '{"counter"=>2}'
+
+    res2 = dreq.get('/', 'HTTP_COOKIE' => cookie)
+    res2['Set-Cookie'].should be_nil
+    res2.body.should == '{"counter"=>3}'
+
+    res3 = req.get('/', 'HTTP_COOKIE' => cookie)
+#   res3['Set-Cookie'][@session_match].should == session
+    res3.body.should == '{"counter"=>4}'
+  end
+end
+

data/spec/rack-session-file-marshal_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/common')
+
+describe Rack::Session::File::Marshal do
+  it_behaves_like Rack::Session::File
+end
+

data/spec/rack-session-file-pstore_spec.rb

@@ -0,0 +1,6 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/common')
+
+describe Rack::Session::File::PStore do
+  it_behaves_like Rack::Session::File
+end

data/spec/rack-session-file-yaml_spec.rb

@@ -0,0 +1,6 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/common')
+
+describe Rack::Session::File::YAML do
+  it_behaves_like Rack::Session::File
+end

data/spec/rack-session-file_spec.rb

@@ -0,0 +1,6 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/common')
+
+describe Rack::Session::File do
+  it_behaves_like Rack::Session::File
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'rack-session-file'
+
+require 'rack/mock'
+require 'rack/response'
+require 'thread'
+
+RSpec.configure do |config|
+  #
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: rack-session-file
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+  prerelease: 
+platform: ruby
+authors:
+- ITO Nobuaki
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.9
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.9
+description: A rack-based session store on plain file system.
+email:
+- daydream.trippers@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- rack-session-file.gemspec
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/rack-session-file.rb
+- lib/rack/session/file.rb
+- lib/rack/session/file/abstract.rb
+- lib/rack/session/file/marshal.rb
+- lib/rack/session/file/pstore.rb
+- lib/rack/session/file/yaml.rb
+- spec/common.rb
+- spec/rack-session-file_spec.rb
+- spec/rack-session-file-marshal_spec.rb
+- spec/rack-session-file-pstore_spec.rb
+- spec/rack-session-file-yaml_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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: 3561167824695945220
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3561167824695945220
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A rack-based session store on plain file system
+test_files:
+- spec/common.rb
+- spec/rack-session-file_spec.rb
+- spec/rack-session-file-marshal_spec.rb
+- spec/rack-session-file-pstore_spec.rb
+- spec/rack-session-file-yaml_spec.rb
+- spec/spec_helper.rb