php_session 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 301319f11805c591578f708b2a3cc3023e3c0fe7
+  data.tar.gz: 09259e558139f5fb3a242fc8398084178de42cfa
+SHA512:
+  metadata.gz: 24532c8a7b0f755b6a60c5ae4461c898827e2254b9cd6525b4174f48fd7cdd7128970be7a4882852b61d8bc510748a1828eff43e8ca03a85a0472ee374b78a82
+  data.tar.gz: be39ee678cb923830646b666f2f82d018036072f903367993df75d913956a50a0390225f0c65c59b869c771cff583800aef3fb0b141a95e6eee7ebf27185c590

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+    - 1.9.3
+    - 2.0.0
+    - ruby-head

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in php_session.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Shinpei Maruyama
+
+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,56 @@
+# PHPSession
+[![Build Status](https://travis-ci.org/Shinpeim/ruby_php_session.png?branch=master)](https://travis-ci.org/Shinpeim/ruby_php_session)
+
+PHPSession is a php session file reader/writer. Multibyte string and exclusive control are supported.
+
+When decoding php session data to ruby objects,
+
+* An associative array in PHP is mapped to a hash in ruby.
+* Object in PHP is mapped to Struct::ClassName in ruby.
+
+When encoding ruby objects to php session data,
+
+* Strings or symbols in ruby is mapped to strings in PHP.
+* Instances of Struct::ClassName in ruby is mapped to a objects in PHP.
+* Arrays in ruby is mapped to a associative arrays which's keys are integer in PHP.
+* Hashes in ruby is mapped to a associative arrays which's keys are string in PHP.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'php_session'
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install php_session
+
+## Usage
+    # initialize
+    session = PHPSession.new(session_file_dir, session_id)
+
+    begin
+      # load session data from file and obtain a lock
+      data = session.load
+
+      # save session and release the lock
+      session.commit(data)
+
+      # delete session file and release the lock
+      session.destroy
+    ensure
+      # please ensure that the lock is released and the file is closed.
+      session.ensure_file_closed
+    end
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/php_session.rb

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+require "php_session/version"
+require "php_session/errors"
+require "php_session/decoder"
+require "php_session/encoder"
+
+class PHPSession
+  attr_reader :data
+  def initialize(session_dir, session_id)
+    @session_dir = File.expand_path(session_dir)
+    set_session_id(session_id)
+
+    @file = nil
+  end
+
+  def load
+    @file = File.open(file_path, File::CREAT|File::RDWR)
+
+    unless @file.flock(File::LOCK_EX)
+      raise PHPSession::Errors, "can't obtain lock of session file"
+    end
+
+    data = Decoder.decode(@file.read) || {}
+    @file.rewind
+    data
+  end
+
+  def destroy
+    if @file && ! @file.closed?
+      @file.truncate(0)
+    end
+    ensure_file_closed
+    File.delete(file_path)
+  rescue Errno::ENOENT => e
+    # file already deleted
+  end
+
+  def commit(data)
+    @file.truncate(0)
+    @file.write(Encoder.encode(data))
+    ensure_file_closed
+  end
+
+  def ensure_file_closed
+    if @file && ! @file.closed?
+      @file.close
+    end
+  end
+
+  private
+
+  def set_session_id(session_id)
+    @session_id = session_id
+    raise Errors::SecurityError, "directory traversal detected" unless file_path.index(@session_dir) == 0
+  end
+
+  def file_path
+    File.expand_path(File.join(@session_dir, "sess_#{@session_id}"))
+  end
+end

data/lib/php_session/decoder.rb

@@ -0,0 +1,224 @@
+# -*- coding: utf-8 -*-
+class PHPSession
+  class Decoder
+    attr_accessor :buffer, :state, :stack, :array
+    attr_reader :encoding
+
+    def self.decode(string, encoding = "UTF-8")
+      self.new(string, encoding).decode
+    end
+
+    def initialize(string, encoding)
+      @encoding = encoding
+      @buffer = string.force_encoding("ASCII-8BIT")
+      @data = {}
+      @state = State::VarName
+      @stack = []
+      @array = [] # array of array
+    end
+
+    def decode
+      loop do
+        break if @buffer.size == 0
+        @state.parse(self)
+      end
+      @data
+    end
+
+    def start_array(length, klass = nil)
+      # [length, comsumed?, class]
+      @array.unshift({
+        :length => length,
+        :consumed_count => 0,
+        :klass => klass
+      })
+    end
+    def elements_count
+      @array[0][:length]
+    end
+    def in_array
+      @array.size > 0
+    end
+    def consume_array
+      @array[0][:consumed_count] += 1
+    end
+    def finished_array
+      @array[0][:length] * 2 == @array[0][:consumed_count]
+    end
+
+    def extract_stack(count)
+      poped = @stack[(@stack.size - count) .. -1]
+      @stack = @stack.slice(0, @stack.size - count)
+      poped
+    end
+
+    def process_empty_array_value
+      array_which_finished  = @array.shift
+
+      klass  = array_which_finished[:klass];
+      if klass
+        struct = define_or_find_struct(klass, [])
+        process_value(struct.new)
+      else
+        process_value({})
+      end
+      @state = State::ArrayEnd
+    end
+    def process_value(value)
+      if in_array
+        @stack.push(value)
+        consume_array
+
+        if finished_array
+          array_which_finished  = @array.shift
+          key_values_array = extract_stack(array_which_finished[:length] * 2)
+          key_values = key_values_array.group_by.with_index{|el, i| i%2 == 0 ? :key : :value}
+
+          klass  = array_which_finished[:klass];
+          if klass
+            struct = define_or_find_struct(klass, key_values[:key])
+            process_value(struct.new(*key_values[:value]))
+            @state = State::ArrayEnd
+            @state.parse(self)
+          else
+            hash = {}
+            key_values_array.each_slice(2) do |kv|
+              hash[kv[0]] = kv[1]
+            end
+            process_value(hash)
+
+            @state = State::ArrayEnd
+            @state.parse(self)
+          end
+        else
+          @state = State::VarType
+        end
+      else
+        varname = @stack.pop;
+        @data[varname] = value;
+        @state = State::VarName
+      end
+    end
+
+    private
+
+    def define_or_find_struct(name, properties)
+      if Struct.const_defined?(name)
+        struct = Struct.const_get(name)
+        if struct.members.sort != properties.map(&:to_sym).sort
+          raise Errors::ParseError, "objects properties don't match with the other object which has same class"
+        end
+      else
+        struct = Struct.new(name, *properties)
+      end
+      struct
+    end
+
+    module State
+      class VarName
+        def self.parse(decoder)
+          matches = /^(.*?)\|(.*)$/.match(decoder.buffer)
+          raise Errors::ParseError, "invalid format" if matches.nil?
+          varName = matches[1]
+          decoder.buffer = matches[2]
+
+          decoder.stack.push(varName)
+          decoder.state = VarType
+        end
+      end
+
+      class VarType
+        def self.parse(decoder)
+          case decoder.buffer
+          when /^s:(\d+):(.*)/ # string
+            decoder.buffer = $2
+            decoder.stack.push($1.to_i)
+            decoder.state = String
+          when /^i:(-?\d+);(.*)/ #int
+            decoder.buffer = $2
+            decoder.process_value($1.to_i)
+          when /^d:(-?\d+(?:\.\d+)?);(.*)/ # double
+            decoder.buffer = $2
+            decoder.process_value($1.to_f)
+          when /^a:(\d+):(.*)/ # array
+            decoder.buffer = $2
+            decoder.start_array($1.to_i)
+            decoder.state = ArrayStart
+          when /^(N);(.*)/ # null
+            decoder.buffer = $2
+            decoder.process_value(nil)
+          when /^b:([01]);(.*)/ # boolean
+            decoder.buffer = $2
+            bool = case $1
+                   when "0" then false
+                   when "1" then true
+                   end
+            decoder.process_value(bool)
+          when /^O:(\d+):(.*)/ # object
+            decoder.buffer = $2
+            decoder.stack.push($1.to_i);
+            decoder.state = ClassName
+          when /^[Rr]:(\d+);(.*)/ # reference count?
+            decoder.buffer = $2
+            decoder.process_value($1)
+          else
+            raise Errors::ParseError, "invalid session format"
+          end
+        end
+      end
+
+      class String
+        def self.parse(decoder)
+          length = decoder.stack.pop
+          length_include_quotes = length + 3
+
+          value_include_quotes = decoder.buffer[0, length_include_quotes]
+          value = value_include_quotes.gsub(/^"/,'').gsub(/";$/, '')
+          value.force_encoding(decoder.encoding)
+
+          decoder.buffer = decoder.buffer[length_include_quotes .. -1]
+
+          decoder.process_value(value)
+        end
+      end
+
+      class ArrayStart
+        def self.parse(decoder)
+          raise Errors::ParseError, "invalid array format" unless decoder.buffer =~ /^{/
+            decoder.buffer = decoder.buffer[1..-1]
+          if decoder.elements_count > 0
+            decoder.state = VarType
+          else
+            decoder.process_empty_array_value
+          end
+        end
+      end
+
+      class ArrayEnd
+        def self.parse(decoder)
+          raise Errors::ParseError, "invalid array format" unless decoder.buffer =~ /^}/
+            decoder.buffer = decoder.buffer[1..-1]
+          next_state = decoder.in_array ? VarType : VarName;
+          decoder.state = next_state
+        end
+      end
+
+      class ClassName
+        def self.parse(decoder)
+          length = decoder.stack.pop;
+          length_include_quotes = length + 3
+
+          value_include_quotes = decoder.buffer[0, length_include_quotes]
+          klass = value_include_quotes.gsub(/^"/,'').gsub(/":$/,'')
+
+          decoder.buffer = decoder.buffer[length_include_quotes..-1]
+
+          raise Errors::ParseError, "invalid class format" unless decoder.buffer =~ /^(\d+):(.*)/
+          decoder.buffer = $2
+          decoder.start_array($1.to_i, klass)
+          decoder.state = ArrayStart
+        end
+      end
+    end
+  end
+end

data/lib/php_session/encoder.rb

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+class PHPSession
+  class Encoder
+    def self.encode(hash)
+      serialized = hash.map do|k,v|
+        "#{k}|#{serialize(v)}"
+      end
+      serialized.join
+    end
+
+    private
+
+    def self.serialize(value)
+      get_serializer(value.class).serialize(value)
+    end
+
+    def self.get_serializer(klass)
+      case
+      when klass <= String || klass <= Symbol
+        StringSerializer
+      when klass <= Integer
+        IntegerSerializer
+      when klass <= Float
+        FloatSerializer
+      when klass <= NilClass
+        NilSerializer
+      when klass <= TrueClass || klass <= FalseClass
+        BooleanSerializer
+      when klass <= Hash
+        HashSerializer
+      when klass <= Array
+        ArraySerializer
+      when klass <= Struct
+        StructSerializer
+      else
+        raise Errors::EncodeError, "unsupported class:#{klass.to_s} is passed."
+      end
+    end
+
+   class StringSerializer
+      def self.serialize(value)
+        s = value.to_s
+        %|s:#{s.bytesize}:"#{s}";|
+      end
+    end
+    class IntegerSerializer
+      def self.serialize(value)
+        %|i:#{value};|
+      end
+    end
+    class FloatSerializer
+      def self.serialize(value)
+        %|d:#{value};|
+      end
+    end
+    class NilSerializer
+      def self.serialize(value)
+        %|N;|
+      end
+    end
+    class BooleanSerializer
+      def self.serialize(value)
+        %|b:#{value ? 1 : 0};|
+      end
+    end
+    class HashSerializer
+      def self.serialize(value)
+        serialized_values = value.map do |k, v|
+          [Encoder.serialize(k), Encoder.serialize(v)]
+        end
+        %|a:#{value.size}:{#{serialized_values.flatten.join}}|
+      end
+    end
+    class ArraySerializer
+      def self.serialize(value)
+        key_values = value.map.with_index{|el, i| [i, el]}
+        hash = Hash[key_values]
+        HashSerializer.serialize(hash)
+      end
+    end
+    class StructSerializer
+      def self.serialize(value)
+        key_values = value.members.zip(value.values)
+        serialized_key_values = key_values.map do |kv|
+          kv.map {|el| Encoder.serialize(el)}
+        end
+        class_name = value.class.to_s.gsub(/^Struct::/,'')
+        %|o:#{class_name.bytesize}:"#{class_name}":#{key_values.size}:{#{serialized_key_values.flatten.join}}|
+      end
+    end
+  end
+end

data/lib/php_session/errors.rb

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+class PHPSession::Errors < StandardError; end
+class PHPSession::Errors::ParseError < StandardError; end
+class PHPSession::Errors::EncodeError < StandardError; end

data/lib/php_session/version.rb

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+class PHPSession
+  VERSION = "0.0.1"
+end

data/php_session.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'php_session/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "php_session"
+  spec.version       = PHPSession::VERSION
+  spec.authors       = ["Shinpei Maruyama"]
+  spec.email         = ["shinpeim@gmail.com"]
+  spec.description   = %q{php session reader/writer}
+  spec.summary       = %q{php_session is a php session file reader/writer. Multibyte string and exclusiv control is supported}
+  spec.homepage      = "https://github.com/Shinpeim/ruby_php_session"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/php_session/decoder_spec.rb

@@ -0,0 +1,183 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe PHPSession::Decoder do
+  describe ".decode" do
+    context "when given invalid session format" do
+      it "should raise ParseError" do
+        expect {
+          PHPSession::Decoder.decode("invalid format string")
+        }.to raise_error(PHPSession::Errors::ParseError)
+      end
+    end
+    context "when given a String value in session data" do
+      it "should return a hash which has a string" do
+        expect(
+          PHPSession::Decoder.decode('key|s:3:"str";')
+        ).to eq({"key" => "str"})
+      end
+    end
+    context "when given a multibyte string in session data" do
+      it "should return a hash which has a multibyte string" do
+        expect(
+          PHPSession::Decoder.decode('key|s:9:"テスト";')
+        ).to eq({"key" => "テスト"})
+      end
+    end
+    context "when given a Integer value in session data" do
+      it "should return a hash which has a int value" do
+        expect(
+          PHPSession::Decoder.decode('key|i:10;')
+        ).to eq({"key" => 10})
+      end
+    end
+    context "when given a doulble value in session data" do
+      it "should return a hash which has a float value" do
+        expect(
+          PHPSession::Decoder.decode('key|d:3.1415;')
+        ).to eq({"key" => 3.1415})
+      end
+    end
+    context "when given a null in session data" do
+      it "should return a hash which has a nil" do
+        expect(
+          PHPSession::Decoder.decode('key|N;')
+        ).to eq({"key" => nil})
+      end
+    end
+    context "when given boolean in session data" do
+      it "should return a  hash which has a boolean" do
+        expect(
+          PHPSession::Decoder.decode('key|b:1;')
+        ).to eq({"key" => true})
+        expect(
+          PHPSession::Decoder.decode('key|b:0;')
+        ).to eq({"key" => false})
+      end
+    end
+    context "when given a empty array in session data" do
+      it "should return a hash which contains no data" do
+        expect(
+          PHPSession::Decoder.decode('key|a:0:{}')
+        ).to eq({"key" => {}})
+      end
+    end
+    context "when given a AssociatedArray value in session data" do
+      it "should return a hash which has a hash" do
+        expect(
+          PHPSession::Decoder.decode('key|a:2:{s:2:"k1";s:2:"v1";s:2:"k2";s:2:"v2";}')
+        ).to eq({
+          "key" => {
+            "k1" => "v1",
+            "k2" => "v2"
+          }
+        })
+      end
+    end
+    context "when given a object" do
+      it "should return a hash which has a object" do
+        data = PHPSession::Decoder.decode('key|O:4:"Nyan":1:{s:1:"k";s:1:"v";}')
+        expect(data["key"].class).to eq(Struct::Nyan)
+        expect(data["key"].k).to eq("v")
+      end
+    end
+    context "when given a object which has no property" do
+      it "should return a hash which has a object" do
+        data = PHPSession::Decoder.decode('key|O:4:"Piyo":0:{}')
+        expect(data["key"].class).to eq(Struct::Piyo)
+      end
+    end
+    context "when given objects which have same class" do
+      it "should return same class Structs" do
+        data = PHPSession::Decoder.decode('key|a:2:{s:1:"1";O:4:"Nyan":1:{s:1:"k";s:1:"v";}s:1:"2";O:4:"Nyan":1:{s:1:"k";s:1:"v";}}')
+        expect(data["key"]["1"].class).to eq(Struct::Nyan)
+        expect(data["key"]["1"].k).to eq("v")
+      end
+    end
+    context "when given objects which have same class but different properties" do
+      it "should raise ParseError" do
+        expect {
+          PHPSession::Decoder.decode('key|a:2:{s:1:"1";O:4:"Nyan":1:{s:1:"k";s:1:"v";}s:1:"2";O:4:"Nyan":0:{}}')
+        }.to raise_error(PHPSession::Errors::ParseError)
+      end
+    end
+    context "when given multi key session data" do
+      it "should return a hash which has multipul keys" do
+        expect(
+          PHPSession::Decoder.decode('key1|d:3.1415;key2|s:4:"hoge";')
+        ).to eq({
+          "key1" => 3.1415,
+          "key2" => "hoge",
+        })
+      end
+    end
+    context "when given nested array" do
+      it "should return a nested array" do
+        expect(
+          PHPSession::Decoder.decode('key1|a:1:{s:1:"a";a:1:{s:1:"b";s:1:"c";}}')
+        ).to eq({
+          "key1" => {
+            "a" => {
+               "b" => "c"
+            }
+          }
+        })
+      end
+    end
+    context "when given a complex data" do
+      it "should return a complex hash" do
+        session_data = <<'EOS'
+Config|a:3:{s:9:"userAgent";s:32:"d2673506d1c64ae55d1ea2421143f994";s:4:"time";i:1382414678;s:7:"timeout";i:10;}Account|a:2:{s:7:"Account";a:14:{s:2:"id";s:1:"1";s:7:"user_id";s:1:"1";s:5:"state";s:6:"active";s:5:"email";s:16:"test@example.com";s:8:"password";s:32:"5a2c1429a27a9783609e8b429748aa33";s:10:"owner_flag";b:1;s:4:"name";s:9:"テスト";s:7:"created";s:19:"2013-10-16 11:21:35";s:8:"modified";s:19:"2013-10-16 11:21:36";s:4:"uuid";s:36:"0e866700-c572-4d17-aab3-de0f35cf502e";s:10:"user_state";s:6:"active";s:8:"pc1_flag";b:0;s:10:"account_id";s:1:"1";s:8:"rmc_type";s:2:"pc";}s:4:"User";a:20:{s:2:"id";s:1:"1";s:12:"company_name";s:9:"テスト";s:13:"producer_name";s:9:"テスト";s:16:"consumer_message";s:0:"";s:7:"created";s:19:"2013-10-16 11:21:35";s:8:"modified";s:19:"2013-10-16 11:21:35";s:5:"state";s:6:"active";s:10:"apply_flag";b:0;s:9:"paid_flag";b:0;s:17:"company_name_kana";s:0:"";s:18:"producer_name_kana";s:0:"";s:15:"payer_name_kana";s:0:"";s:8:"zip_code";s:0:"";s:10:"prefecture";s:0:"";s:7:"address";s:0:"";s:8:"address2";s:0:"";s:5:"phone";s:0:"";s:5:"other";s:0:"";s:4:"uuid";s:36:"f6120e89-0554-449a-9c79-aa330ba9d6c5";s:8:"pc1_flag";b:0;}}Auth|a:0:{}
+EOS
+        expect(PHPSession::Decoder.decode(session_data)).to eq({
+          "Config" => {
+            "userAgent"=>"d2673506d1c64ae55d1ea2421143f994",
+            "time"=>1382414678,
+            "timeout"=>10
+          },
+          "Account" => {
+            "Account"=> {
+              "id"=>"1",
+              "user_id"=>"1",
+              "state"=>"active",
+              "email"=>"test@example.com",
+              "password"=>"5a2c1429a27a9783609e8b429748aa33",
+              "owner_flag"=>true,
+              "name"=>"テスト",
+              "created"=>"2013-10-16 11:21:35",
+              "modified"=>"2013-10-16 11:21:36",
+              "uuid"=>"0e866700-c572-4d17-aab3-de0f35cf502e",
+              "user_state"=>"active",
+              "pc1_flag"=>false,
+              "account_id"=>"1",
+              "rmc_type"=>"pc",
+            },
+            "User"=> {
+              "id"=>"1",
+              "company_name"=>"テスト",
+              "producer_name"=>"テスト",
+              "consumer_message"=>"",
+              "created"=>"2013-10-16 11:21:35",
+              "modified"=>"2013-10-16 11:21:35",
+              "state"=>"active",
+              "apply_flag"=>false,
+              "paid_flag"=>false,
+              "company_name_kana"=>"",
+              "producer_name_kana"=>"",
+              "payer_name_kana"=>"",
+              "zip_code"=>"",
+              "prefecture"=>"",
+              "address"=>"",
+              "address2"=>"",
+              "phone"=>"",
+              "other"=>"",
+              "uuid"=>"f6120e89-0554-449a-9c79-aa330ba9d6c5",
+              "pc1_flag"=>false}
+            },
+          "Auth"=>{
+          }
+        })
+      end
+    end
+  end
+end

data/spec/php_session/encoder_spec.rb

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe PHPSession::Encoder do
+  describe ".encode" do
+    context "when given string value" do
+      it "should return 'KEY|SERIALIZED_STRING'" do
+        expect(
+          PHPSession::Encoder.encode({:hoge => "nyan"})
+        ).to eq('hoge|s:4:"nyan";')
+      end
+    end
+    context "when given multi string value" do
+      it "should return 'KEY|SERIALIZED_STRING'" do
+        expect(
+          PHPSession::Encoder.encode({:hoge => "テスト"})
+        ).to eq('hoge|s:9:"テスト";')
+      end
+    end
+    context "when given int value" do
+      it "should return 'KEY|SERIALIZED_INT" do
+        expect(
+          PHPSession::Encoder.encode({:hoge => 1})
+        ).to eq ('hoge|i:1;')
+      end
+    end
+    context "when given double value" do
+      it "should return 'KEY|DOUBLE|'" do
+        expect(
+          PHPSession::Encoder.encode({:hoge => 1.1})
+        ).to eq('hoge|d:1.1;')
+      end
+    end
+    context "when given nil value" do
+      it "should return 'KEY|N;'" do
+        expect(
+          PHPSession::Encoder.encode({:hoge => nil})
+        ).to eq('hoge|N;')
+      end
+    end
+    context "when given boolean value" do
+      it "should return 'KEY|b:(0|1);'" do
+        expect(
+          PHPSession::Encoder.encode({:hoge => true})
+        ).to eq('hoge|b:1;')
+        expect(
+          PHPSession::Encoder.encode({:hoge => false})
+        ).to eq('hoge|b:0;')
+      end
+    end
+    context "when given hash value" do
+      it "should return 'KEY|a:SIZE:ARRAY'" do
+        expect(
+          PHPSession::Encoder.encode({:hoge => {:a => 1,:b => 2,:c => 3}})
+        ).to eq('hoge|a:3:{s:1:"a";i:1;s:1:"b";i:2;s:1:"c";i:3;}')
+      end
+    end
+    context "when given array value" do
+      it "should return 'KEY|a:SIZE:ARRAY'" do
+        expect(
+          PHPSession::Encoder.encode({:hoge => [1, 2, 3]})
+        ).to eq('hoge|a:3:{i:0;i:1;i:1;i:2;i:2;i:3;}')
+      end
+    end
+    context "when given Struct" do
+      it "should return 'KEY|o:CLASSNAME_SIZE:PROPERTIES_SIZE:{PROPERTIES_AND_VALUES}'" do
+        piyo = Struct.const_defined?(:Test) ? Struct.const_get(:Test) : Struct.new("Test", :p1, :p2)
+        expect(
+          PHPSession::Encoder.encode(:hoge => piyo.new(1, 2))
+        ).to eq('hoge|o:4:"Test":2:{s:2:"p1";i:1;s:2:"p2";i:2;}')
+      end
+    end
+    context "when given nested value" do
+      it "should return nested serialized string" do
+        hash = {
+          :key => {
+            :hoge => {
+              :fuga => "nyan"
+            }
+          }
+        }
+        expect(
+          PHPSession::Encoder.encode(hash)
+        ).to eq('key|a:1:{s:4:"hoge";a:1:{s:4:"fuga";s:4:"nyan";}}')
+      end
+    end
+    context "when given other types" do
+      it "should raise EncodeError" do
+        expect {
+          PHPSession::Encoder.encode({:key => Date.today})
+        }.to raise_error PHPSession::Errors::EncodeError
+      end
+    end
+  end
+end

data/spec/php_session_spec.rb

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe PHPSession do
+  describe "load" do
+    context "when session file exists" do
+      before do
+        @session_file = create_dummy_session_file('key|s:1:"a";')
+      end
+
+      it "should return session data" do
+        session = PHPSession.new(@session_file[:dir_name], @session_file[:session_id])
+        begin
+          data = session.load
+          expect(data).to eq({"key" => "a"})
+        ensure
+          session.ensure_file_closed
+        end
+      end
+
+      after do
+        File.delete(@session_file[:file_path])
+      end
+    end
+
+    context "when session file dosen't exist" do
+      it "should return new session data" do
+        session = PHPSession.new(Dir.tmpdir,"session_id")
+        begin
+          data = session.load
+          expect(data).to eq({})
+        ensure
+          session.ensure_file_closed
+        end
+      end
+    end
+  end
+
+  describe "#commit" do
+    before do
+      @session_file = create_dummy_session_file('key|s:1:"a";')
+    end
+
+    it "should save session_data in session_file" do
+      session = PHPSession.new(@session_file[:dir_name], @session_file[:session_id])
+      data = session.load
+      data["key"] = "b"
+      session.commit(data)
+
+      expect(IO.read(@session_file[:file_path])).to eq('key|s:1:"b";')
+    end
+
+    after do
+      File.delete(@session_file[:file_path])
+    end
+  end
+
+  describe "#destroy" do
+    context "when session file exists and loaded" do
+      before do
+        @session_file = create_dummy_session_file('key|s:1:"a";')
+        @session = PHPSession.new(@session_file[:dir_name], @session_file[:session_id])
+        @session.load
+      end
+
+      it "should delete session file" do
+        @session.destroy
+        expect(File.exists?(@session_file[:file_path])).to eq(false)
+      end
+    end
+
+    context "when session file exists and not loaded" do
+      before do
+        @session_file = create_dummy_session_file('key|s:1:"a";')
+        @session = PHPSession.new(@session_file[:dir_name], @session_file[:session_id])
+      end
+
+      it "should delete session file" do
+        @session.destroy
+        expect(File.exists?(@session_file[:file_path])).to eq(false)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+require 'php_session'
+require 'tempfile'
+
+def create_dummy_session_file(text)
+  file_path = Tempfile.open(["sess_", ""]) {|f|
+    f.write(text)
+    f.path
+  }
+  dirname = File.dirname(file_path)
+  session_id = File.basename(file_path).gsub(/^sess_/,'')
+
+  {:file_path => file_path, :dir_name => dirname, :session_id => session_id}
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: php_session
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Shinpei Maruyama
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: php session reader/writer
+email:
+- shinpeim@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/php_session.rb
+- lib/php_session/decoder.rb
+- lib/php_session/encoder.rb
+- lib/php_session/errors.rb
+- lib/php_session/version.rb
+- php_session.gemspec
+- spec/php_session/decoder_spec.rb
+- spec/php_session/encoder_spec.rb
+- spec/php_session_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/Shinpeim/ruby_php_session
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: php_session is a php session file reader/writer. Multibyte string and exclusiv
+  control is supported
+test_files:
+- spec/php_session/decoder_spec.rb
+- spec/php_session/encoder_spec.rb
+- spec/php_session_spec.rb
+- spec/spec_helper.rb