php-serialize4ruby 0.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.8.0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", ">= 1.0.0"
+  gem "jeweler", "~> 1.8.3"
+  gem "simplecov"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Kasper Johansen
+
+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

@@ -0,0 +1,34 @@
+Ruby PHP Serializer
+===================
+
+This module provides two methods: PHP.serialize() and PHP.unserialize(), both
+of which should be compatible with the similarly named functions in PHP.
+
+Basic usage:
+
+ require 'php_serialize'
+ in = {'foo' => 'bar'}
+ php = PHP.serialize(in)
+ # pass string to PHP unserialize() to get array('foo' => 'bar')
+ out = PHP.unserialize(php) # => {'foo' => 'bar'}
+
+
+PHP.unserialize can also read PHP sessions, which are collections of named
+serialized objects.  These can be reserialized using PHP.serialize_session(),
+which has the same semantics as PHP.serialize(), but which only supports
+Hash and associative Arrays for the root object.
+
+
+Acknowledgements
+================
+
+TJ Vanderpoel, initial PHP serialized session support.
+
+Philip Hallstrom, fix for self-generated Structs on unserialization.
+
+Edward Speyer, fix for assoc serialization in nested structures.
+
+
+
+Author: Thomas Hurst <tom@hur.st>, http://hur.st/
+WWW: http://www.aagh.net/projects/ruby-php-serialize

data/README.rdoc

@@ -0,0 +1,19 @@
+= php-serialize4ruby
+
+Description goes here.
+
+== Contributing to php-serialize4ruby
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 Kasper Johansen. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "php-serialize4ruby"
+  gem.homepage = "http://github.com/kaspernj/php-serialize4ruby"
+  gem.license = "MIT"
+  gem.summary = %Q{A fork of the original gem "php-serialize" because I have no hope of the original guy to update the gem}
+  gem.description = %Q{Read the original gems description.}
+  gem.email = "k@spernj.org"
+  gem.authors = ["Kasper Johansen"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "php-serialize4ruby #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/php-serialize4ruby.rb

@@ -0,0 +1,314 @@
+#!/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.
+
+# 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
+# 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 ||= {}
+
+		require 'stringio'
+		string = StringIO.new(string)
+		def string.read_until(char)
+			val = ''
+			while (c = self.read(1)) != char
+				val << c
+			end
+			val
+		end
+
+		if string.string =~ /^(\w+)\|/ # session_name|serialized_data
+			ret = Hash.new
+			loop do
+				if string.string[string.pos, 32] =~ /^(\w+)\|/
+					string.pos += $&.size
+					ret[$1] = PHP.do_unserialize(string, classmap, assoc)
+				else
+					break
+				end
+			end
+			ret
+		else
+			PHP.do_unserialize(string, classmap, assoc)
+		end
+	end
+
+private
+	def PHP.do_unserialize(string, classmap, assoc)
+		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), do_unserialize(string, classmap, assoc)]
+				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
+					end
+				else
+					if assoc
+						val = vals.map {|v| v }
+					else
+						val = Hash.new
+						vals.each do |key,value|
+							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))
+					attrs << [attr.intern, (attr << '=').intern, do_unserialize(string, classmap, assoc)]
+				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] = 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] # 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/lib/php_serialize.rb

@@ -0,0 +1,314 @@
+#!/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.
+
+# 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
+# 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 ||= {}
+
+		require 'stringio'
+		string = StringIO.new(string)
+		def string.read_until(char)
+			val = ''
+			while (c = self.read(1)) != char
+				val << c
+			end
+			val
+		end
+
+		if string.string =~ /^(\w+)\|/ # session_name|serialized_data
+			ret = Hash.new
+			loop do
+				if string.string[string.pos, 32] =~ /^(\w+)\|/
+					string.pos += $&.size
+					ret[$1] = PHP.do_unserialize(string, classmap, assoc)
+				else
+					break
+				end
+			end
+			ret
+		else
+			PHP.do_unserialize(string, classmap, assoc)
+		end
+	end
+
+private
+	def PHP.do_unserialize(string, classmap, assoc)
+		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), do_unserialize(string, classmap, assoc)]
+				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
+					end
+				else
+					if assoc
+						val = vals.map {|v| v }
+					else
+						val = Hash.new
+						vals.each do |key,value|
+							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))
+					attrs << [attr.intern, (attr << '=').intern, do_unserialize(string, classmap, assoc)]
+				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] = 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] # 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/php-serialize.gemspec

@@ -0,0 +1,19 @@
+
+Gem::Specification.new do |spec|
+	spec.name = "php-serialize"
+	spec.version = "1.1.0"
+	spec.summary = "Ruby analogs to PHP's serialize() and unserialize() functions"
+	spec.require_path = 'lib/'
+	spec.files = Dir['lib/*.rb']
+	spec.author = "Thomas Hurst"
+	spec.email = "tom@hur.st"
+	spec.homepage = "http://www.aagh.net/projects/ruby-php-serialize"
+	spec.description = <<-EOF
+	This module provides two methods: PHP.serialize() and PHP.unserialize(), both
+	of which should be compatible with the similarly named functions in PHP.
+
+	It can also serialize and unserialize PHP sessions.
+	EOF
+	spec.test_file = 'test.rb'
+	spec.has_rdoc = true
+end

data/php-serialize4ruby.gemspec

@@ -0,0 +1,67 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{php-serialize4ruby}
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Kasper Johansen"]
+  s.date = %q{2012-05-06}
+  s.description = %q{Read the original gems description.}
+  s.email = %q{k@spernj.org}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "LICENSE.txt",
+    "README",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/php-serialize4ruby.rb",
+    "lib/php_serialize.rb",
+    "php-serialize.gemspec",
+    "php-serialize4ruby.gemspec",
+    "spec/php-serialize4ruby_spec.rb",
+    "spec/spec_helper.rb",
+    "test.rb"
+  ]
+  s.homepage = %q{http://github.com/kaspernj/php-serialize4ruby}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{A fork of the original gem "php-serialize" because I have no hope of the original guy to update the gem}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, [">= 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+  end
+end
+

data/spec/php-serialize4ruby_spec.rb

@@ -0,0 +1,9 @@
+#coding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "PhpSerialize4ruby" do
+  it "should be able to some stuff without failing" do
+    PHP.serialize(:type => "hmm", :test => "åæø")
+  end
+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 'php-serialize4ruby'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

data/test.rb

@@ -0,0 +1,119 @@
+#!/usr/local/bin/ruby
+# encoding: utf-8
+
+if RUBY_VERSION == "1.9.2"
+  # needed, when running in Ruby 1.9.2 -> no stdlib test/unit
+  gem 'test-unit'
+end
+require 'test/unit'
+require 'test/unit/ui/console/testrunner'
+
+$:.unshift "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("öäü")
+  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
+
+	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
+end
+
+require 'test/unit/ui/console/testrunner'
+Test::Unit::UI::Console::TestRunner.run(TestPhpSerialize)
+

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification 
+name: php-serialize4ruby
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Kasper Johansen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-05-06 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "3.12"
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: simplecov
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+description: Read the original gems description.
+email: k@spernj.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README
+- README.rdoc
+files: 
+- .document
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/php-serialize4ruby.rb
+- lib/php_serialize.rb
+- php-serialize.gemspec
+- php-serialize4ruby.gemspec
+- spec/php-serialize4ruby_spec.rb
+- spec/spec_helper.rb
+- test.rb
+has_rdoc: true
+homepage: http://github.com/kaspernj/php-serialize4ruby
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -4127720001001404955
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A fork of the original gem "php-serialize" because I have no hope of the original guy to update the gem
+test_files: []
+