packsnap 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.o
+*.so
+*.gem
+*.class
+.bundle
+Gemfile*
+pkg
+test/debug.log
+*~
+/rdoc
+tmp
+.classpath
+.project
+.settings
+/nbproject/private/
+ext/java/build
+ext/java/msgpack.jar

data/ChangeLog

@@ -0,0 +1,29 @@
+
+2012-05-05 version 0.4.7:
+
+  * Fixed serialization of double values on ARM OABI architectures
+  * Fixed byteorder problem on big-endian platforms
+  * Don't use MRI internals in the Ruby extension for Rubinius
+  * Detect whether st.h is present and don't use RUBY_VM as the condition for
+    Rubinius
+
+2011-08-08 version 0.4.6:
+
+  * Fixed compile error problem on Mac OS X Lion
+
+2011-05-09 version 0.4.5:
+
+  * Improves compatibility with JRuby
+
+2010-11-28 version 0.4.4:
+
+  * Adds Unpacker#feed_each method
+  * Improves compatibility with Rubinius
+  * Improves compatibility with ruby-1.8.5
+  * Encodings of String instances to UTF-8 on Ruby 1.9
+
+2010-06-29 version 0.4.3:
+
+  * Adds MessagePack::VERSION constant
+  * Fixes SEGV problem caused by GC bug at MessagePack_Unpacker_mark
+

data/README.rdoc

@@ -0,0 +1,26 @@
+
+= MessagePack
+
+MessagePack is an efficient binary serialization format.
+It lets you exchange data among multiple languages like JSON but it's faster and smaller.
+For example, small integers (like flags or error code) are encoded into a single byte,
+and typical short strings only require an extra byte in addition to the strings themselves.
+
+If you ever wished to use JSON for convenience (storing an image with metadata) but could
+not for technical reasons (encoding, size, speed...), MessagePack is a perfect replacement.
+
+    require 'msgpack'
+    msg = [1,2,3].to_msgpack  #=> "\x93\x01\x02\x03"
+    MessagePack.unpack(msg)   #=> [1,2,3]
+
+Use RubyGems to install:
+
+    gem install msgpack
+
+
+== Copyright
+
+Author::    FURUHASHI Sadayuki <frsyuki@gmail.com>
+Copyright:: Copyright (c) 2008-2012 FURUHASHI Sadayuki
+License::   Apache License, Version 2.0
+

data/Rakefile

@@ -0,0 +1,150 @@
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+require 'yard'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["-c", "-f progress"]
+  t.rspec_opts << "-Ilib"
+  t.pattern = 'spec/**/*_spec.rb'
+  t.verbose = true
+end
+
+task :spec => :compile
+
+desc 'Run RSpec code examples and measure coverage'
+task :coverage do |t|
+  ENV['SIMPLE_COV'] = '1'
+  Rake::Task["spec"].invoke
+end
+
+desc 'Generate YARD document'
+YARD::Rake::YardocTask.new(:doc) do |t|
+  t.files   = ['lib/packsnap/version.rb','doclib/**/*.rb']
+  t.options = []
+  t.options << '--debug' << '--verbose' if $trace
+end
+
+def create_gemspec(platform, extra_globs, remove_globs)
+  spec = eval(File.read('packsnap.gemspec'))
+
+  extra_globs.each {|glob| spec.files += Dir[glob] }
+  remove_globs.each {|glob| spec.files -= Dir[glob] }
+
+  if platform && !platform.empty?
+    spec.platform = platform
+  end
+
+  spec
+end
+
+def create_gem(platform, extra_globs, remove_globs)
+  spec = create_gemspec(platform, extra_globs, remove_globs)
+  name = Gem::Builder.new(spec).build
+
+  FileUtils.mkdir_p('pkg/')
+  FileUtils.mv(name, 'pkg/')
+end
+
+def run_command(cmd, env = {})
+  puts env.map {|k,v| "#{k}=\"#{v}\"" }.join(' ')
+  puts cmd
+  if env.empty?
+    system(cmd)  # for jruby
+  else
+    system(env, cmd)
+  end
+
+  if $?.to_i != 0
+    raise "command failed (#{$?.to_i}): #{cmd}"
+  end
+end
+
+task :default => :gem
+
+desc "Create gem package"
+task "gem" do
+  #if RUBY_PLATFORM =~ /java/
+  #  Rake::Task["gem:java"].invoke
+  #else
+    create_gem(nil, ["lib/packsnap/**/*.{so,bundle}"], ["ext/**/*"])
+  #end
+end
+
+desc "Create precompiled gem package"
+task "gem:build" do
+  config = YAML.load_file("packsnap.build.yml")
+
+  platform = config['platform']
+  archs = []
+
+  begin
+    FileUtils.rm_rf Dir["lib/packsnap/*-*"]
+
+    config['versions'].each {|ver|
+      ruby = ver.delete('ruby')
+      env = ver.delete('env') || {}
+      arch = `'#{ruby}' -rrbconfig -e "puts RUBY_PLATFORM"`.strip
+      ruby_version = `'#{ruby}' -rrbconfig -e "puts RbConfig::CONFIG['ruby_version']"`.strip
+      vpath = "#{arch}/#{ruby_version}"
+
+      run_command "cd ext/packsnap && '#{ruby}' extconf.rb && make clean && make", env
+
+      path = Dir['ext/packsnap/packsnap.{so,bundle}'].first
+      FileUtils.mkdir_p("lib/packsnap/#{vpath}")
+      FileUtils.cp(path, "lib/packsnap/#{vpath}/")
+
+      archs << arch
+    }
+
+    create_gem(platform, ["lib/packsnap/**/*.{so,bundle}"], ["ext/**/*"])
+
+  ensure
+    FileUtils.rm_rf Dir["lib/packsnap/*-*"]
+  end
+end
+
+#task "gem:java" do
+#  Rake::Task["compile:java"].invoke
+#
+#  begin
+#    FileUtils.mkdir_p 'lib/packsnap/java'
+#    FileUtils.cp Dir["ext/java/*.jar"], "lib/"
+#    FileUtils.cp "ext/java/packsnap.jar", "lib/packsnap"
+#
+#    create_gem('java', [], ["ext/packsnap/**/*"])
+#  ensure
+#    FileUtils.rm_rf "ext/java/build"
+#    FileUtils.rm_rf "lib/packsnap/java"
+#    FileUtils.rm_rf Dir["lib/*.jar"]
+#  end
+#end
+
+task "compile" do
+  #if RUBY_PLATFORM =~ /java/
+  #  Rake::Task["compile:java"].invoke
+  #else
+    ruby = 'ruby'  # TODO use self
+    run_command "cd ext/packsnap && '#{ruby}' extconf.rb && make clean && make"
+  #end
+end
+
+#task "compile:java" do
+#  Dir.chdir('ext/java')
+#  begin
+#    jruby_home = RbConfig::CONFIG['prefix']
+#    classpath = ["#{jruby_home}/lib/jruby.jar"] + Dir['*.jar']
+#    files = Dir['packsnap/**/*.java']
+#
+#    FileUtils.rm_rf "ext/java/build"
+#    FileUtils.mkdir_p 'build'
+#    run_command "javac -cp '#{classpath.join(':')}' -d build #{files.join(' ')}"
+#    run_command "jar cvf packsnap.jar -C build/ ."
+#  ensure
+#    Dir.chdir('../..')
+#  end
+#end
+

data/doclib/msgpack.rb

@@ -0,0 +1,54 @@
+module Packsnap
+  #
+  # Serializes an object into an IO or String.
+  #
+  # @overload dump(obj)
+  #   @return [String] serialized data
+  #
+  # @overload dump(obj, io)
+  #   @return [IO]
+  #
+  def self.dump(arg)
+  end
+
+  #
+  # Serializes an object into an IO or String. Alias of dump.
+  #
+  # @overload dump(obj)
+  #   @return [String] serialized data
+  #
+  # @overload dump(obj, io)
+  #   @return [IO]
+  #
+  def self.pack(arg)
+  end
+
+  #
+  # Deserializes an object from an IO or String.
+  #
+  # @overload load(string)
+  #   @param string [String] data to deserialize
+  #
+  # @overload load(io)
+  #   @param io [IO]
+  #
+  # @return [Object] deserialized object
+  #
+  def self.load(arg)
+  end
+
+  #
+  # Deserializes an object from an IO or String. Alias of load.
+  #
+  # @overload unpack(string)
+  #   @param string [String] data to deserialize
+  #
+  # @overload unpack(io)
+  #   @param io [IO]
+  #
+  # @return [Object] deserialized object
+  #
+  def self.unpack(arg)
+  end
+end
+

data/doclib/packsnap/buffer.rb

@@ -0,0 +1,177 @@
+module Packsnap
+
+  class Buffer
+    #
+    # Creates a Packsnap::Buffer instance.
+    #
+    # @overload initialize(options={})
+    #   @param options [Hash]
+    #
+    # @overload initialize(io, options={})
+    #   @param io [IO]
+    #   @param options [Hash]
+    #   This buffer writes written data into the IO when it is filled.
+    #   This buffer reads data from the IO when it is empty.
+    #
+    # _io_ must respond to readpartial(length, [,string]) or read(string) method and
+    # write(string) or append(string) method.
+    #
+    # Supported options:
+    #
+    # * *:io_buffer_size* buffer size to read data from the internal IO. (default: 32768)
+    # * *:read_reference_threshold* the threshold size to enable zero-copy deserialize optimization. Read strings longer than this threshold will refer the original string instead of copying it. (default: 256) (supported in MRI only)
+    # * *:write_reference_threshold* the threshold size to enable zero-copy serialize optimization. The buffer refers written strings longer than this threshold instead of copying it. (default: 524288) (supported in MRI only)
+    #
+    def initialize(*args)
+    end
+
+    #
+    # Makes the buffer empty
+    #
+    # @return nil
+    #
+    def clear
+    end
+
+    #
+    # Returns byte size of the buffer.
+    #
+    # @return nil
+    #
+    def size
+    end
+
+    #
+    # Returns _true_ if the buffer is empty.
+    # This method is slightly faster than _size_.
+    #
+    # @return [Boolean]
+    #
+    def empty?
+    end
+
+    #
+    # Appends the given data to the buffer.
+    #
+    # @param data [String]
+    # @return [Integer] byte size written
+    #
+    def write(data)
+    end
+
+    #
+    # Appends the given data to the buffer.
+    #
+    # @param data [String]
+    # @return [Buffer] self
+    #
+    def <<(data)
+    end
+
+    #
+    # Consumes _n_ bytes from the head of the buffer and returns consumed data.
+    # If the size of the buffer is less than _n_, it reads all of data in the buffer.
+    #
+    # If _n_ is 0, it does nothing and returns an empty string.
+    # If the optional _buffer_ argument is given, the content of the string will be replaced with the consumed data.
+    #
+    # @overload read
+    #
+    # @overload read(n)
+    #   @param n [Integer] bytes to read
+    #
+    # @overload read(n, buffer)
+    #   @param n [Integer] bytes to read
+    #   @param buffer [String] buffer to read into
+    #
+    # @return [String]
+    #
+    def read(n)
+    end
+
+    #
+    # Consumes _n_ bytes from the head of the buffer and returns consumed data.
+    # If the size of the buffer is less than _n_, it does nothing and raises EOFError.
+    #
+    # If _n_ is 0, it does nothing and returns an empty string.
+    # If the optional _buffer_ argument is given, the content of the string will be replaced with the consumed data.
+    #
+    # @overload read_all
+    #
+    # @overload read_all(n)
+    #   @param n [Integer] bytes to read
+    #
+    # @overload read_all(n, buffer)
+    #   @param n [Integer] bytes to read
+    #   @param buffer [String] buffer to read into
+    #
+    # @return [String]
+    #
+    def read_all(n, buffer=nil)
+    end
+
+    #
+    # Consumes _n_ bytes from the head of the buffer.
+    # If the size of the buffer is less than _n_, it skips all of data in the buffer and returns integer less than _n_.
+    #
+    # If _n_ is 0, it does nothing and returns _0_.
+    #
+    # @param n [Integer] byte size to skip
+    # @return [Integer] byte size actually skipped
+    #
+    def skip(n)
+    end
+
+    #
+    # Consumes _n_ bytes from the head of the buffer.
+    # If the size of the buffer is less than _n_, it does nothing and raises EOFError.
+    # If _n_ is 0, it does nothing.
+    #
+    # @param n [Integer] byte size to skip
+    # @return [Buffer] self
+    #
+    def skip_all(n)
+    end
+
+    #
+    # Returns all data in the buffer as a string.
+    # Destructive update to the returned string does NOT effect the buffer.
+    #
+    # @return [String]
+    #
+    def to_str
+    end
+
+    #
+    # Returns content of the buffer as an array of strings.
+    #
+    # This method is sometimes faster than to_s because the internal
+    # structure of the buffer is a queue of buffer chunks.
+    #
+    # @return [Array] array of strings
+    #
+    def to_a
+    end
+
+    #
+    # Flushes data in the internal buffer to the internal IO.
+    # If internal IO is not set, it doesn nothing.
+    #
+    # @return [Buffer] self
+    #
+    def flush
+    end
+
+    #
+    # Writes all of data in the internal buffer into the given IO.
+    # This method consumes and removes data from the internal buffer.
+    # _io_ must respond to write(data) method.
+    #
+    # @param io [IO]
+    # @return [Integer] byte size of written data
+    #
+    def write_to(io)
+    end
+  end
+
+end