php_session 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 301319f11805c591578f708b2a3cc3023e3c0fe7
-  data.tar.gz: 09259e558139f5fb3a242fc8398084178de42cfa
+  metadata.gz: b17d2e471e2fc62c4c3681598183b9ce7551a277
+  data.tar.gz: 45400c08a847f2ef18c8e0241648542fa01bc1ab
 SHA512:
-  metadata.gz: 24532c8a7b0f755b6a60c5ae4461c898827e2254b9cd6525b4174f48fd7cdd7128970be7a4882852b61d8bc510748a1828eff43e8ca03a85a0472ee374b78a82
-  data.tar.gz: be39ee678cb923830646b666f2f82d018036072f903367993df75d913956a50a0390225f0c65c59b869c771cff583800aef3fb0b141a95e6eee7ebf27185c590
+  metadata.gz: 890cec71b4f562a2ac591099a36ea7371c190403546fb216749a72dc7dfc883ff520d72b77d87295d097a446a93ad97a625457f9067954d8ccbd4efc4ae6e869
+  data.tar.gz: 608e598aabacdf55c0d1c834057ff1befe09ea8898e3438b9b3b4048a1a99eb76f10eb74072d401e8c4e73b301308a42bc39063443a7958a7eba3770d5f3c145

data/README.md

@@ -1,12 +1,13 @@
 # PHPSession
 [![Build Status](https://travis-ci.org/Shinpeim/ruby_php_session.png?branch=master)](https://travis-ci.org/Shinpeim/ruby_php_session)
 
+## Description
 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.
+* Associative arrays in PHP is mapped to hashes in ruby.
+* Objects in PHP is mapped to instances of Struct::ClassName in ruby.
 
 When encoding ruby objects to php session data,
 
@@ -15,6 +16,35 @@ When encoding ruby objects to php session data,
 * 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.
 
+### Multibyte support
+
+Passing option to PHPSession.new, you can handle encodings.
+
+Options are:
+
+* :internal_encoding
+    
+    When this value is not nil, Session decoder tries to
+    encode string values into this encoding.
+    
+    For a instance, if your php session file written in EUC-JP and you
+    like to handle string as UTF-8 in Ruby, you should set :internal_encoding
+    as "UTF-8" and :external_encoding as "EUC-JP".
+
+    Default value is Encoding.default_internal.
+    
+* :external_encoding
+    
+    This value should be same as php session file's encoding.
+    Encoder tries to encode string values into this encoding.
+    
+    Default value is Encoding.default_external.
+    
+* :encoding_option
+    
+    This value is passed to String#encode.
+
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -31,11 +61,22 @@ Or install it yourself as:
 
 ## Usage
     # initialize
-    session = PHPSession.new(session_file_dir, session_id)
+    option = {
+        :internal_encoding => "UTF-8",  # value will be decoded as UTF-8
+        :external_encoding => "EUC-JP", # encoding of sesion file is EUC-JP
+        :encoding_option   => {:undef => :replace} # passed to String#encode
+    }
+    # option's default values are 
+    # :internal_encoding => Encoding.default_internal_encoding
+    # :external_encoding => Encoding.default_external_encoding
+    # :encoding_option   => {}
+    session = PHPSession.new(session_file_dir, session_id, option)
 
     begin
       # load session data from file and obtain a lock
       data = session.load
+      
+      data.is_a? Hash # => true
 
       # save session and release the lock
       session.commit(data)

data/lib/php_session/decoder.rb

@@ -2,15 +2,16 @@
 class PHPSession
   class Decoder
     attr_accessor :buffer, :state, :stack, :array
-    attr_reader :encoding
+    attr_reader :encoding, :encoding_option
 
-    def self.decode(string, encoding = "UTF-8")
-      self.new(string, encoding).decode
+    def self.decode(string, encoding = nil, encoding_option = {})
+      self.new(string, encoding, encoding_option).decode
     end
 
-    def initialize(string, encoding)
+    def initialize(string, encoding, encoding_option)
       @encoding = encoding
-      @buffer = string.force_encoding("ASCII-8BIT")
+      @encoding_option = encoding_option
+      @buffer = string
       @data = {}
       @state = State::VarName
       @stack = []
@@ -172,11 +173,11 @@ class PHPSession
           length = decoder.stack.pop
           length_include_quotes = length + 3
 
-          value_include_quotes = decoder.buffer[0, length_include_quotes]
+          value_include_quotes = decoder.buffer.byteslice(0, length_include_quotes)
           value = value_include_quotes.gsub(/^"/,'').gsub(/";$/, '')
-          value.force_encoding(decoder.encoding)
 
-          decoder.buffer = decoder.buffer[length_include_quotes .. -1]
+          value = value.encode(decoder.encoding, decoder.encoding_option) if decoder.encoding
+          decoder.buffer = decoder.buffer.byteslice(length_include_quotes .. -1)
 
           decoder.process_value(value)
         end

data/lib/php_session/encoder.rb

@@ -1,88 +1,106 @@
 # -*- coding: utf-8 -*-
 class PHPSession
   class Encoder
-    def self.encode(hash)
+    attr_reader :encoding, :encoding_option
+    def self.encode(hash, encoding = nil, encoding_option = {})
+      encoding = Encoding.default_external if encoding.nil?
+      self.new(encoding, encoding_option).encode(hash)
+    end
+
+    def initialize(encoding, encoding_option)
+      @encoding = encoding
+      @encoding_option = encoding_option
+    end
+
+    def encode(hash)
       serialized = hash.map do|k,v|
-        "#{k}|#{serialize(v)}"
+        "#{k.to_s}|#{serialize(v)}"
       end
       serialized.join
     end
 
-    private
-
-    def self.serialize(value)
+    def serialize(value)
       get_serializer(value.class).serialize(value)
     end
 
-    def self.get_serializer(klass)
+    private
+
+    def get_serializer(klass)
       case
       when klass <= String || klass <= Symbol
-        StringSerializer
+        StringSerializer.new(self)
       when klass <= Integer
-        IntegerSerializer
+        IntegerSerializer.new(self)
       when klass <= Float
-        FloatSerializer
+        FloatSerializer.new(self)
       when klass <= NilClass
-        NilSerializer
+        NilSerializer.new(self)
       when klass <= TrueClass || klass <= FalseClass
-        BooleanSerializer
+        BooleanSerializer.new(self)
       when klass <= Hash
-        HashSerializer
+        HashSerializer.new(self)
       when klass <= Array
-        ArraySerializer
+        ArraySerializer.new(self)
       when klass <= Struct
-        StructSerializer
+        StructSerializer.new(self)
       else
         raise Errors::EncodeError, "unsupported class:#{klass.to_s} is passed."
       end
     end
 
-   class StringSerializer
-      def self.serialize(value)
-        s = value.to_s
+    class Serializer
+      def initialize(encoder)
+        @encoder = encoder
+      end
+    end
+    class StringSerializer < Serializer
+      def serialize(value)
+        value = value.to_s
+        # encode here for valid bytesize
+        s = value.encode(@encoder.encoding, @encoder.encoding_option)
         %|s:#{s.bytesize}:"#{s}";|
       end
     end
-    class IntegerSerializer
-      def self.serialize(value)
+    class IntegerSerializer < Serializer
+      def serialize(value)
         %|i:#{value};|
       end
     end
-    class FloatSerializer
-      def self.serialize(value)
+    class FloatSerializer < Serializer
+      def serialize(value)
         %|d:#{value};|
       end
     end
-    class NilSerializer
-      def self.serialize(value)
+    class NilSerializer < Serializer
+      def serialize(value)
         %|N;|
       end
     end
-    class BooleanSerializer
-      def self.serialize(value)
+    class BooleanSerializer < Serializer
+      def serialize(value)
         %|b:#{value ? 1 : 0};|
       end
     end
-    class HashSerializer
-      def self.serialize(value)
+    class HashSerializer < Serializer
+      def serialize(value)
         serialized_values = value.map do |k, v|
-          [Encoder.serialize(k), Encoder.serialize(v)]
+          [@encoder.serialize(k), @encoder.serialize(v)]
         end
         %|a:#{value.size}:{#{serialized_values.flatten.join}}|
       end
     end
-    class ArraySerializer
-      def self.serialize(value)
+    class ArraySerializer < Serializer
+      def serialize(value)
         key_values = value.map.with_index{|el, i| [i, el]}
         hash = Hash[key_values]
-        HashSerializer.serialize(hash)
+        HashSerializer.new(@encoder).serialize(hash)
       end
     end
-    class StructSerializer
-      def self.serialize(value)
+    class StructSerializer < Serializer
+      def serialize(value)
         key_values = value.members.zip(value.values)
         serialized_key_values = key_values.map do |kv|
-          kv.map {|el| Encoder.serialize(el)}
+          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}}|

data/lib/php_session/version.rb

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

data/lib/php_session.rb

@@ -6,7 +6,13 @@ require "php_session/encoder"
 
 class PHPSession
   attr_reader :data
-  def initialize(session_dir, session_id)
+  def initialize(session_dir, session_id, option = {})
+    default_option = {
+      :internal_encoding => Encoding.default_internal,
+      :external_encoding => Encoding.default_external,
+      :encoding_option => {},
+    }
+    @option = default_option.merge(option)
     @session_dir = File.expand_path(session_dir)
     set_session_id(session_id)
 
@@ -20,7 +26,9 @@ class PHPSession
       raise PHPSession::Errors, "can't obtain lock of session file"
     end
 
-    data = Decoder.decode(@file.read) || {}
+    # set internal_encoding to nil to avoid encoding conversion
+    @file.set_encoding(@option[:external_encoding], nil)
+    data = Decoder.decode(@file.read, @option[:internal_encoding], @option[:encoding_option]) || {}
     @file.rewind
     data
   end
@@ -37,7 +45,7 @@ class PHPSession
 
   def commit(data)
     @file.truncate(0)
-    @file.write(Encoder.encode(data))
+    @file.write(Encoder.encode(data, @option[:external_encoding], @option[:encoding_option]))
     ensure_file_closed
   end
 

data/php_session.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   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.summary       = %q{php_session is a php session file reader/writer. Multibyte string and exclusive control is supported}
   spec.homepage      = "https://github.com/Shinpeim/ruby_php_session"
   spec.license       = "MIT"
 

data/spec/php_session/encoder_spec.rb

@@ -17,6 +17,13 @@ describe PHPSession::Encoder do
         ).to eq('hoge|s:9:"テスト";')
       end
     end
+    context "when given multi string value with external encoding" do
+      it "should return 'KEY|SERIALIZED_STRING'" do
+        expect(
+          PHPSession::Encoder.encode({:hoge => "テスト🍣"}, "EUC-JP", {:undef => :replace})
+        ).to eq('hoge|s:7:"テスト?";'.encode('EUC-JP'))
+      end
+    end
     context "when given int value" do
       it "should return 'KEY|SERIALIZED_INT" do
         expect(

data/spec/php_session_spec.rb

@@ -3,6 +3,56 @@ require 'spec_helper'
 
 describe PHPSession do
   describe "load" do
+    context "when session file encoding is utf8" do
+      before do
+        @session_file = create_dummy_session_file('key|s:13:"テスト🍺";')
+      end
+      it "should be able to load file with internal:nil, external:utf8" do
+        option = {
+          :internal_encoding => nil,
+          :external_encoding => "UTF-8",
+        }
+        session = PHPSession.new(@session_file[:dir_name], @session_file[:session_id], option)
+        begin
+          data = session.load
+          expect(data).to eq({"key" => "テスト🍺"})
+        ensure
+          session.ensure_file_closed
+        end
+      end
+      it "should be able to load file with internal:utf8, external:utf8" do
+        option = {
+          :internal_encoding => "UTF-8",
+          :external_encoding => "UTF-8",
+        }
+        session = PHPSession.new(@session_file[:dir_name], @session_file[:session_id], option)
+        begin
+          data = session.load
+          expect(data).to eq({"key" => "テスト🍺"})
+        ensure
+          session.ensure_file_closed
+        end
+      end
+      it "should return euc-jp string with internal:euc-jp, exterenal:utf8" do
+        option = {
+          :internal_encoding => "EUC-JP",
+          :external_encoding => "UTF-8",
+          :encoding_option => {
+            :undef => :replace
+          }
+        }
+        session = PHPSession.new(@session_file[:dir_name], @session_file[:session_id], option)
+        begin
+          data = session.load
+          expect(data).to eq({"key" => "テスト🍺".encode("EUC-JP", {:undef => :replace})})
+        ensure
+          session.ensure_file_closed
+        end
+      end
+      after do
+        File.delete(@session_file[:file_path])
+      end
+    end
     context "when session file exists" do
       before do
         @session_file = create_dummy_session_file('key|s:1:"a";')
@@ -42,12 +92,19 @@ describe PHPSession do
     end
 
     it "should save session_data in session_file" do
-      session = PHPSession.new(@session_file[:dir_name], @session_file[:session_id])
+      option = {
+        :external_encoding => "EUC-JP",
+        :internal_encoding => "UTF-8",
+        :encoding_option   => {:undef => :replace}
+      }
+      session = PHPSession.new(@session_file[:dir_name], @session_file[:session_id], option)
       data = session.load
-      data["key"] = "b"
+      data["key"] = "テスト🍣"
       session.commit(data)
 
-      expect(IO.read(@session_file[:file_path])).to eq('key|s:1:"b";')
+      # read in bytesequence mode to avoid encoding conversion
+      byte_sequence = IO.read(@session_file[:file_path], File.size(@session_file[:file_path]))
+      expect(byte_sequence.force_encoding('EUC-JP')).to eq('key|s:7:"テスト?";'.encode("EUC-JP"))
     end
 
     after do

data/spec/spec_helper.rb

@@ -12,3 +12,18 @@ def create_dummy_session_file(text)
 
   {:file_path => file_path, :dir_name => dirname, :session_id => session_id}
 end
+
+def with_encoding(internal, external)
+  default_internal_was = Encoding.default_internal
+  default_external_was = Encoding.default_external
+
+  Encoding.default_external = external
+  Encoding.default_internal = internal
+
+  begin
+    yield
+  ensure
+    Encoding.default_external = default_external_was
+    Encoding.default_internal = default_internal_was
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: php_session
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Shinpei Maruyama
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-24 00:00:00.000000000 Z
+date: 2013-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -99,7 +99,7 @@ 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
+summary: php_session is a php session file reader/writer. Multibyte string and exclusive
   control is supported
 test_files:
 - spec/php_session/decoder_spec.rb