k-php-serialize 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0ca2fe3387bf53ef734923627612458e40617b53
+  data.tar.gz: 641a388382641c7ecafa503366f8df96632ef99a
+SHA512:
+  metadata.gz: b1d1089a746f1b44b17d9ad1610efdb9baa629c93832fbf591354c3b9d0da2d185c24fd0e2463acf2721545eefcb9b6dbe1e15b43f00d1c993848af1e0fc9d44
+  data.tar.gz: b9a5a79f1e2cf93e9eb36977971acebad374e51903a026efdb3b26f4d8322f003bf1add2f59105e87478c274f43b04966cd1dc6350d03b5f074679184cc2e8fc

data/lib/php_serialize.rb

@@ -0,0 +1,316 @@
+#!/usr/bin/env ruby
+# Copyright (c) 2003-2009 Thomas Hurst <tom@hur.st>
+#
+# 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.
+
+require 'stringio'
+
+# PHP serialize() and unserialize() workalikes
+#
+# Release History:
+#  1.0.0 - 2003-06-02 - First release.
+#  1.0.1 - 2003-06-16 - Minor bugfixes.
+#  1.0.2 - 2004-09-17 - Switch all {}'s to explicit Hash.new's.
+#  1.1.0 - 2009-04-01 - Pass assoc to recursive calls (thanks to Edward Speyer).
+#                     - Serialize Symbol like String.
+#                     - Add testsuite.
+#                     - Instantiate auto-generated Structs properly (thanks
+#                       to Philip Hallstrom).
+#                     - Unserialize arrays properly in assoc mode.
+#                     - Add PHP session support (thanks to TJ Vanderpoel).
+#                     - Release as tarball and gem.
+#
+# See http://www.php.net/serialize and http://www.php.net/unserialize for
+# details on the PHP side of all this.
+module PHP
+	class StringIOReader < StringIO
+		# Reads data from the buffer until +char+ is found. The
+		# returned string will include +char+.
+		def read_until(char)
+			val, cpos = '', pos
+			if idx = string.index(char, cpos)
+				val = read(idx - cpos + 1)
+			end
+			val
+		end
+	end
+
+# string = PHP.serialize(mixed var[, bool assoc])
+#
+# Returns a string representing the argument in a form PHP.unserialize
+# and PHP's unserialize() should both be able to load.
+#
+# Array, Hash, Fixnum, Float, True/FalseClass, NilClass, String and Struct
+# are supported; as are objects which support the to_assoc method, which
+# returns an array of the form [['attr_name', 'value']..].  Anything else
+# will raise a TypeError.
+#
+# If 'assoc' is specified, Array's who's first element is a two value
+# array will be assumed to be an associative array, and will be serialized
+# as a PHP associative array rather than a multidimensional array.
+	def PHP.serialize(var, assoc = false) # {{{
+		s = ''
+		case var
+			when Array
+				s << "a:#{var.size}:{"
+				if assoc and var.first.is_a?(Array) and var.first.size == 2
+					var.each { |k,v|
+						s << PHP.serialize(k, assoc) << PHP.serialize(v, assoc)
+					}
+				else
+					var.each_with_index { |v,i|
+						s << "i:#{i};#{PHP.serialize(v, assoc)}"
+					}
+				end
+
+				s << '}'
+
+			when Hash
+				s << "a:#{var.size}:{"
+				var.each do |k,v|
+					s << "#{PHP.serialize(k, assoc)}#{PHP.serialize(v, assoc)}"
+				end
+				s << '}'
+
+			when Struct
+				# encode as Object with same name
+				s << "O:#{var.class.to_s.length}:\"#{var.class.to_s.downcase}\":#{var.members.length}:{"
+				var.members.each do |member|
+					s << "#{PHP.serialize(member, assoc)}#{PHP.serialize(var[member], assoc)}"
+				end
+				s << '}'
+
+			when String, Symbol
+				s << "s:#{var.to_s.bytesize}:\"#{var.to_s}\";"
+
+			when Fixnum # PHP doesn't have bignums
+				s << "i:#{var};"
+
+			when Float
+				s << "d:#{var};"
+
+			when NilClass
+				s << 'N;'
+
+			when FalseClass, TrueClass
+				s << "b:#{var ? 1 :0};"
+
+			else
+				if var.respond_to?(:to_assoc)
+					v = var.to_assoc
+					# encode as Object with same name
+					s << "O:#{var.class.to_s.length}:\"#{var.class.to_s.downcase}\":#{v.length}:{"
+					v.each do |k,v|
+						s << "#{PHP.serialize(k.to_s, assoc)}#{PHP.serialize(v, assoc)}"
+					end
+					s << '}'
+				else
+					raise TypeError, "Unable to serialize type #{var.class}"
+				end
+		end
+
+		s
+	end # }}}
+
+# string = PHP.serialize_session(mixed var[, bool assoc])
+#
+# Like PHP.serialize, but only accepts a Hash or associative Array as the root
+# type.  The results are returned in PHP session format.
+	def PHP.serialize_session(var, assoc = false) # {{{
+		s = ''
+		case var
+		when Hash
+			var.each do |key,value|
+				if key.to_s =~ /\|/
+					raise IndexError, "Top level names may not contain pipes"
+				end
+				s << "#{key}|#{PHP.serialize(value, assoc)}"
+			end
+		when Array
+			var.each do |x|
+				case x
+				when Array
+					if x.size == 2
+						s << "#{x[0]}|#{PHP.serialize(x[1])}"
+					else
+						raise TypeError, "Array is not associative"
+					end
+				end
+			end
+		else
+			raise TypeError, "Unable to serialize sessions with top level types other than Hash and associative Array"
+		end
+		s
+	end # }}}
+
+# mixed = PHP.unserialize(string serialized, [hash classmap, [bool assoc]])
+#
+# Returns an object containing the reconstituted data from serialized.
+#
+# If a PHP array (associative; like an ordered hash) is encountered, it
+# scans the keys; if they're all incrementing integers counting from 0,
+# it's unserialized as an Array, otherwise it's unserialized as a Hash.
+# Note: this will lose ordering.  To avoid this, specify assoc=true,
+# and it will be unserialized as an associative array: [[key,value],...]
+#
+# If a serialized object is encountered, the hash 'classmap' is searched for
+# the class name (as a symbol).  Since PHP classnames are not case-preserving,
+# this *must* be a .capitalize()d representation.  The value is expected
+# to be the class itself; i.e. something you could call .new on.
+#
+# If it's not found in 'classmap', the current constant namespace is searched,
+# and failing that, a new Struct(classname) is generated, with the arguments
+# for .new specified in the same order PHP provided; since PHP uses hashes
+# to represent attributes, this should be the same order they're specified
+# in PHP, but this is untested.
+#
+# each serialized attribute is sent to the new object using the respective
+# {attribute}=() method; you'll get a NameError if the method doesn't exist.
+#
+# Array, Hash, Fixnum, Float, True/FalseClass, NilClass and String should
+# be returned identically (i.e. foo == PHP.unserialize(PHP.serialize(foo))
+# for these types); Struct should be too, provided it's in the namespace
+# Module.const_get within unserialize() can see, or you gave it the same
+# name in the Struct.new(<structname>), otherwise you should provide it in
+# classmap.
+#
+# Note: StringIO is required for unserialize(); it's loaded as needed
+	def PHP.unserialize(string, classmap = nil, assoc = false) # {{{
+		if classmap == true or classmap == false
+			assoc = classmap
+			classmap = {}
+		end
+		classmap ||= {}
+
+		ret = nil
+		original_encoding = string.encoding
+		string = StringIOReader.new(string.force_encoding('BINARY'))
+		while string.string[string.pos, 32] =~ /^(\w+)\|/ # session_name|serialized_data
+			ret ||= {}
+			string.pos += $&.size
+			ret[$1] = PHP.do_unserialize(string, classmap, assoc, original_encoding)
+		end
+
+		ret ? ret : PHP.do_unserialize(string, classmap, assoc, original_encoding)
+	end
+
+private
+	def PHP.do_unserialize(string, classmap, assoc, original_encoding)
+		val = nil
+		# determine a type
+		type = string.read(2)[0,1]
+		case type
+			when 'a' # associative array, a:length:{[index][value]...}
+				count = string.read_until('{').to_i
+				val = vals = Array.new
+				count.times do |i|
+					vals << [do_unserialize(string, classmap, assoc, original_encoding), do_unserialize(string, classmap, assoc, original_encoding)]
+				end
+				string.read(1) # skip the ending }
+
+				# now, we have an associative array, let's clean it up a bit...
+				# arrays have all numeric indexes, in order; otherwise we assume a hash
+				array = true
+				i = 0
+				vals.each do |key,value|
+					if key != i # wrong index -> assume hash
+						array = false
+						break
+					end
+					i += 1
+				end
+
+				if array
+					vals.collect! do |key,value|
+						value.kind_of?(String) ? value.force_encoding(original_encoding) : value
+					end
+				else
+					if assoc
+						val = vals.map {|v| v }
+					else
+						val = Hash.new
+						vals.each do |key,value|
+							key = key.force_encoding(original_encoding) if key.kind_of?(String)
+							value = value.force_encoding(original_encoding) if value.kind_of?(String)
+							val[key] = value
+						end
+					end
+				end
+
+			when 'O' # object, O:length:"class":length:{[attribute][value]...}
+				# class name (lowercase in PHP, grr)
+				len = string.read_until(':').to_i + 3 # quotes, seperator
+				klass = string.read(len)[1...-2].capitalize.intern # read it, kill useless quotes
+
+				# read the attributes
+				attrs = []
+				len = string.read_until('{').to_i
+
+				len.times do
+					attr = (do_unserialize(string, classmap, assoc, original_encoding))
+					attrs << [attr.intern, (attr << '=').intern, do_unserialize(string, classmap, assoc, original_encoding)]
+				end
+				string.read(1)
+
+				val = nil
+				# See if we need to map to a particular object
+				if classmap.has_key?(klass)
+					val = classmap[klass].new
+				elsif Struct.const_defined?(klass) # Nope; see if there's a Struct
+					classmap[klass] = val = Struct.const_get(klass)
+					val = val.new
+				else # Nope; see if there's a Constant
+					begin
+						classmap[klass] = val = Module.const_get(klass)
+
+						val = val.new
+					rescue NameError # Nope; make a new Struct
+						classmap[klass] = val = Struct.new(klass.to_s, *attrs.collect { |v| v[0].to_s })
+						val = val.new
+					end
+				end
+
+				attrs.each do |attr,attrassign,v|
+					val.__send__(attrassign, v)
+				end
+
+			when 's' # string, s:length:"data";
+				len = string.read_until(':').to_i + 3 # quotes, separator
+				val = string.read(len)[1...-2].force_encoding(original_encoding) # read it, kill useless quotes
+
+			when 'i' # integer, i:123
+				val = string.read_until(';').to_i
+
+			when 'd' # double (float), d:1.23
+				val = string.read_until(';').to_f
+
+			when 'N' # NULL, N;
+				val = nil
+
+			when 'b' # bool, b:0 or 1
+				val = (string.read(2)[0] == ?1 ? true : false)
+
+			else
+				raise TypeError, "Unable to unserialize type '#{type}'"
+		end
+
+		val
+	end # }}}
+end
+

data/test.rb

@@ -0,0 +1,137 @@
+#!/usr/local/bin/ruby
+# encoding: utf-8
+
+require 'test/unit'
+
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'php_serialize'
+
+TestStruct = Struct.new(:name, :value)
+class TestClass
+	attr_accessor :name
+	attr_accessor :value
+
+	def initialize(name = nil, value = nil)
+		@name = name
+		@value = value
+	end
+
+	def to_assoc
+		[['name', @name], ['value', @value]]
+	end
+
+	def ==(other)
+		other.class == self.class and other.name == @name and other.value == @value
+	end
+end
+
+ClassMap = {
+	TestStruct.name.capitalize.intern => TestStruct,
+	TestClass.name.capitalize.intern => TestClass
+}
+
+class TestPhpSerialize < Test::Unit::TestCase
+	def self.test(ruby, php, opts = {})
+		if opts[:name]
+			name = opts[:name]
+		else
+			name = ruby.to_s
+		end
+
+		define_method("test_#{name}".intern) do
+			assert_nothing_thrown do
+				serialized = PHP.serialize(ruby)
+				assert_equal php, serialized
+
+				unserialized = PHP.unserialize(serialized, ClassMap)
+				case ruby
+				when Symbol
+					assert_equal ruby.to_s, unserialized
+				else
+					assert_equal ruby, unserialized
+				end
+			end
+		end
+	end
+
+	test nil, 'N;'
+	test false, 'b:0;'
+	test true, 'b:1;'
+	test 42, 'i:42;'
+	test -42, 'i:-42;'
+	test 2147483647, "i:2147483647;", :name => 'Max Fixnum'
+	test -2147483648, "i:-2147483648;", :name => 'Min Fixnum'
+	test 4.2, 'd:4.2;'
+	test 'test', 's:4:"test";'
+	test :test, 's:4:"test";', :name => 'Symbol'
+	test "\"\n\t\"", "s:4:\"\"\n\t\"\";", :name => 'Complex string'
+	test [nil, true, false, 42, 4.2, 'test'], 'a:6:{i:0;N;i:1;b:1;i:2;b:0;i:3;i:42;i:4;d:4.2;i:5;s:4:"test";}',
+		:name => 'Array'
+	test({'foo' => 'bar', 4 => [5,4,3,2]}, 'a:2:{s:3:"foo";s:3:"bar";i:4;a:4:{i:0;i:5;i:1;i:4;i:2;i:3;i:3;i:2;}}', :name => 'Hash')
+	test TestStruct.new("Foo", 65), 'O:10:"teststruct":2:{s:4:"name";s:3:"Foo";s:5:"value";i:65;}',
+		:name => 'Struct'
+	test TestClass.new("Foo", 65), 'O:9:"testclass":2:{s:4:"name";s:3:"Foo";s:5:"value";i:65;}',
+		:name => 'Class'
+
+  # PHP counts multibyte string, not string length
+  def test_multibyte_string
+    assert_equal  "s:6:\"öäü\";", PHP.serialize("öäü")
+    assert_equal  PHP.unserialize("s:6:\"öäü\";"), "öäü"
+  end
+
+	# Verify assoc is passed down calls.
+	# Slightly awkward because hashes don't guarantee order.
+	def test_assoc
+		assert_nothing_raised do
+			ruby = {'foo' => ['bar','baz'], 'hash' => {'hash' => 'smoke'}}
+			ruby_assoc = [['foo', ['bar','baz']], ['hash', [['hash','smoke']]]]
+			phps = [
+				'a:2:{s:4:"hash";a:1:{s:4:"hash";s:5:"smoke";}s:3:"foo";a:2:{i:0;s:3:"bar";i:1;s:3:"baz";}}',
+				'a:2:{s:3:"foo";a:2:{i:0;s:3:"bar";i:1;s:3:"baz";}s:4:"hash";a:1:{s:4:"hash";s:5:"smoke";}}'
+			]
+			serialized = PHP.serialize(ruby, true)
+			assert phps.include?(serialized)
+			unserialized = PHP.unserialize(serialized, true)
+			assert_equal ruby_assoc.sort, unserialized.sort
+		end
+	end
+
+	# Multibyte version.
+	# Verify assoc is passed down calls.
+	# Slightly awkward because hashes don't guarantee order.
+	def test_assoc_multibyte
+		assert_nothing_raised do
+			ruby = {'ああ' => ['öäü','漢字'], 'hash' => {'おはよう' => 'smoke'}}
+			ruby_assoc = [['ああ', ['öäü','漢字']], ['hash', [['おはよう','smoke']]]]
+			phps = [
+				'a:2:{s:6:"ああ";a:2:{i:0;s:6:"öäü";i:1;s:6:"漢字";}s:4:"hash";a:1:{s:12:"おはよう";s:5:"smoke";}}',
+				'a:2:{s:4:"hash";a:1:{s:12:"おはよう";s:5:"smoke";}s:6:"ああ";a:2:{i:0;s:6:"öäü";i:1;s:6:"漢字";}}'
+			]
+			serialized = PHP.serialize(ruby, true)
+			assert phps.include?(serialized)
+			unserialized = PHP.unserialize(serialized, true)
+			assert_equal ruby_assoc.sort, unserialized.sort
+		end
+	end
+
+	def test_sessions
+		assert_nothing_raised do
+			ruby = {'session_id' => 42, 'user_data' => {'uid' => 666}}
+			phps = [
+				'session_id|i:42;user_data|a:1:{s:3:"uid";i:666;}',
+				'user_data|a:1:{s:3:"uid";i:666;}session_id|i:42;'
+			]
+			unserialized = PHP.unserialize(phps.first)
+			assert_equal ruby, unserialized
+			serialized = PHP.serialize_session(ruby)
+			assert phps.include?(serialized)
+		end
+	end
+
+  def test_new_struct_creation
+    assert_nothing_raised do
+      phps = 'O:8:"stdClass":2:{s:3:"url";s:17:"/legacy/index.php";s:8:"dateTime";s:19:"2012-10-24 22:29:13";}'
+      unserialized = PHP.unserialize(phps)
+    end
+  end
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: k-php-serialize
+version: !ruby/object:Gem::Version
+  version: 1.2.0
+platform: ruby
+authors:
+- Keitaroh Kobayashi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-27 00:00:00.000000000 Z
+dependencies: []
+description: "\tThis module provides two methods: PHP.serialize() and PHP.unserialize(),
+  both\n\tof which should be compatible with the similarly named functions in PHP.\n\n\tIt
+  can also serialize and unserialize PHP sessions.\n"
+email: keita@kkob.us
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/php_serialize.rb
+- test.rb
+homepage: https://github.com/keichan34/php-serialize
+licenses: []
+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.3
+signing_key: 
+specification_version: 4
+summary: Ruby analogs to PHP's serialize() and unserialize() functions
+test_files:
+- test.rb