msgpack 0.2.2 → 0.3.0

data/AUTHORS

@@ -0,0 +1 @@
+FURUHASHI Sadayuki <frsyuki _at_ users.sourceforge.jp>

data/README

@@ -0,0 +1,29 @@
+
+= MessagePack
+
+
+== Description
+
+
+== Installation
+
+=== Archive Installation
+
+	rake install
+
+=== Gem Installation
+
+	gem install msgpack
+
+
+== Features/Problems
+
+
+== Synopsis
+
+
+== Copyright
+
+Author::    frsyuki <frsyuki@users.sourceforge.jp>
+Copyright:: Copyright (c) 2008-2009 frsyuki
+License::   Apache License, Version 2.0

data/Rakefile

@@ -1,4 +1,133 @@
-require 'config/requirements'
-require 'config/hoe' # setup Hoe + all gem configuration
-
-Dir['tasks/**/*.rake'].each { |rake| load rake }
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'rake/contrib/sshpublisher'
+require 'fileutils'
+include FileUtils
+
+NAME              = "msgpack"
+AUTHOR            = "FURUHASHI Sadayuki"
+EMAIL             = "frsyuki _at_ users.sourceforge.jp"
+DESCRIPTION       = "Binary-based efficient data interchange format."
+RUBYFORGE_PROJECT = "msgpack"
+HOMEPATH          = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+BIN_FILES         = %w(  )
+VERS              = "0.3.0"
+
+#REV = File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
+REV = nil
+CLEAN.include ['**/.*.sw?', '*.gem', '.config']
+RDOC_OPTS = [
+	'--title', "#{NAME} documentation",
+	"--charset", "utf-8",
+	"--opname", "index.html",
+	"--line-numbers",
+	"--main", "README",
+	"--inline-source",
+]
+
+task :default => [:test]
+task :package => [:clean]
+
+Rake::TestTask.new("test") do |t|
+	t.libs   << "test"
+	t.pattern = "test/**/*_test.rb"
+	t.verbose = true
+end
+
+spec = Gem::Specification.new do |s|
+	s.name              = NAME
+	s.version           = VERS
+	s.platform          = Gem::Platform::RUBY
+	s.has_rdoc          = true
+	s.extra_rdoc_files  = ["README", "ChangeLog", "AUTHORS"]
+	s.rdoc_options     += RDOC_OPTS + ['--exclude', '^(examples|extras)/']
+	s.summary           = DESCRIPTION
+	s.description       = DESCRIPTION
+	s.author            = AUTHOR
+	s.email             = EMAIL
+	s.homepage          = HOMEPATH
+	s.executables       = BIN_FILES
+	s.rubyforge_project = RUBYFORGE_PROJECT
+	s.bindir            = "bin"
+	s.require_path      = "ext"
+	s.autorequire       = ""
+	s.test_files        = Dir["test/test_*.rb"]
+
+	#s.add_dependency('activesupport', '>=1.3.1')
+	#s.required_ruby_version = '>= 1.8.2'
+
+	s.files = %w(README ChangeLog Rakefile) +
+		Dir.glob("{bin,doc,test,lib,templates,generator,extras,website,script}/**/*") + 
+		Dir.glob("ext/**/*.{h,c,rb}") +
+		Dir.glob("examples/**/*.rb") +
+		Dir.glob("tools/*.rb") +
+		Dir.glob("msgpack/*.h")
+
+	s.extensions = FileList["ext/**/extconf.rb"].to_a
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+	p.need_tar = true
+	p.gem_spec = spec
+end
+
+task :install do
+	name = "#{NAME}-#{VERS}.gem"
+	sh %{rake package}
+	sh %{sudo gem install pkg/#{name}}
+end
+
+task :uninstall => [:clean] do
+	sh %{sudo gem uninstall #{NAME}}
+end
+
+
+#Rake::RDocTask.new do |rdoc|
+#	rdoc.rdoc_dir = 'html'
+#	rdoc.options += RDOC_OPTS
+#	rdoc.template = "resh"
+#	#rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+#	if ENV['DOC_FILES']
+#		rdoc.rdoc_files.include(ENV['DOC_FILES'].split(/,\s*/))
+#	else
+#		rdoc.rdoc_files.include('README', 'ChangeLog')
+#		rdoc.rdoc_files.include('lib/**/*.rb')
+#		rdoc.rdoc_files.include('ext/**/*.c')
+#	end
+#end
+
+desc "Publish to RubyForge"
+task :rubyforge => [:rdoc, :package] do
+	require 'rubyforge'
+	Rake::RubyForgePublisher.new(RUBYFORGE_PROJECT, 'frsyuki').upload
+end
+
+desc 'Package and upload the release to rubyforge.'
+task :release => [:clean, :package] do |t|
+	v = ENV["VERSION"] or abort "Must supply VERSION=x.y.z"
+	abort "Versions don't match #{v} vs #{VERS}" unless v == VERS
+	pkg = "pkg/#{NAME}-#{VERS}"
+
+	rf = RubyForge.new
+	puts "Logging in"
+	rf.login
+
+	c = rf.userconfig
+#	c["release_notes"] = description if description
+#	c["release_changes"] = changes if changes
+	c["preformatted"] = true
+
+	files = [
+		"#{pkg}.tgz",
+		"#{pkg}.gem"
+	].compact
+
+	puts "Releasing #{NAME} v. #{VERS}"
+	rf.add_release RUBYFORGE_PROJECT, NAME, VERS, *files
+end

data/ext/pack.c

@@ -1,7 +1,7 @@
 /*
- * MessagePack packing routine for Ruby
+ * MessagePack for Ruby packing routine
  *
- * Copyright (C) 2008 FURUHASHI Sadayuki
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -19,10 +19,10 @@
 #include "msgpack/pack_define.h"
 
 #define msgpack_pack_inline_func(name) \
-	static inline void msgpack_pack_##name
+	static inline void msgpack_pack ## name
 
 #define msgpack_pack_inline_func_cint(name) \
-	static inline void msgpack_pack_##name
+	static inline void msgpack_pack ## name
 
 #define msgpack_pack_user VALUE
 

data/ext/pack.h

@@ -1,7 +1,7 @@
 /*
- * MessagePack packing routine for Ruby
+ * MessagePack for Ruby packing routine
  *
- * Copyright (C) 2008 FURUHASHI Sadayuki
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.

data/ext/rbinit.c

@@ -1,7 +1,7 @@
 /*
  * MessagePack for Ruby
  *
- * Copyright (C) 2008 FURUHASHI Sadayuki
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.

data/ext/unpack.c

@@ -1,7 +1,7 @@
 /*
- * MessagePack unpacking routine for Ruby
+ * MessagePack for Ruby unpacking routine
  *
- * Copyright (C) 2008 FURUHASHI Sadayuki
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -21,99 +21,99 @@
 
 typedef struct {
 	int finished;
-	VALUE origstr;
-} msgpack_unpack_context;
+	VALUE source;
+} unpack_user;
 
 
 #define msgpack_unpack_struct(name) \
-	struct msgpack_unpacker_##name
+	struct template ## name
 
 #define msgpack_unpack_func(ret, name) \
-	ret msgpack_unpacker_##name
+	ret template ## name
 
 #define msgpack_unpack_callback(name) \
-	template_callback_##name
+	template_callback ## name
 
 #define msgpack_unpack_object VALUE
 
-#define msgpack_unpack_user msgpack_unpack_context
+#define msgpack_unpack_user unpack_user
 
 
-struct msgpack_unpacker_context;
-typedef struct msgpack_unpacker_context msgpack_unpacker;
+struct template_context;
+typedef struct template_context msgpack_unpack_t;
 
-static void msgpack_unpacker_init(msgpack_unpacker* ctx);
+static void template_init(msgpack_unpack_t* u);
 
-static VALUE msgpack_unpacker_data(msgpack_unpacker* ctx);
+static VALUE template_data(msgpack_unpack_t* u);
 
-static int msgpack_unpacker_execute(msgpack_unpacker* ctx,
+static int template_execute(msgpack_unpack_t* u,
 		const char* data, size_t len, size_t* off);
 
 
-static inline VALUE template_callback_init(msgpack_unpack_context* x)
+static inline VALUE template_callback_root(unpack_user* u)
 { return Qnil; }
 
-static inline VALUE template_callback_uint8(msgpack_unpack_context* x, uint8_t d)
-{ return INT2FIX(d); }
+static inline int template_callback_uint8(unpack_user* u, uint8_t d, VALUE* o)
+{ *o = INT2FIX(d); return 0; }
 
-static inline VALUE template_callback_uint16(msgpack_unpack_context* x, uint16_t d)
-{ return INT2FIX(d); }
+static inline int template_callback_uint16(unpack_user* u, uint16_t d, VALUE* o)
+{ *o = INT2FIX(d); return 0; }
 
-static inline VALUE template_callback_uint32(msgpack_unpack_context* x, uint32_t d)
-{ return UINT2NUM(d); }
+static inline int template_callback_uint32(unpack_user* u, uint32_t d, VALUE* o)
+{ *o = UINT2NUM(d); return 0; }
 
-static inline VALUE template_callback_uint64(msgpack_unpack_context* x, uint64_t d)
-{ return rb_ull2inum(d); }
+static inline int template_callback_uint64(unpack_user* u, uint64_t d, VALUE* o)
+{ *o = rb_ull2inum(d); return 0; }
 
-static inline VALUE template_callback_int8(msgpack_unpack_context* x, int8_t d)
-{ return INT2FIX((long)d); }
+static inline int template_callback_int8(unpack_user* u, int8_t d, VALUE* o)
+{ *o = INT2FIX((long)d); return 0; }
 
-static inline VALUE template_callback_int16(msgpack_unpack_context* x, int16_t d)
-{ return INT2FIX((long)d); }
+static inline int template_callback_int16(unpack_user* u, int16_t d, VALUE* o)
+{ *o = INT2FIX((long)d); return 0; }
 
-static inline VALUE template_callback_int32(msgpack_unpack_context* x, int32_t d)
-{ return INT2NUM((long)d); }
+static inline int template_callback_int32(unpack_user* u, int32_t d, VALUE* o)
+{ *o = INT2NUM((long)d); return 0; }
 
-static inline VALUE template_callback_int64(msgpack_unpack_context* x, int64_t d)
-{ return rb_ll2inum(d); }
+static inline int template_callback_int64(unpack_user* u, int64_t d, VALUE* o)
+{ *o = rb_ll2inum(d); return 0; }
 
-static inline VALUE template_callback_float(msgpack_unpack_context* x, float d)
-{ return rb_float_new(d); }
+static inline int template_callback_float(unpack_user* u, float d, VALUE* o)
+{ *o = rb_float_new(d); return 0; }
 
-static inline VALUE template_callback_double(msgpack_unpack_context* x, double d)
-{ return rb_float_new(d); }
+static inline int template_callback_double(unpack_user* u, double d, VALUE* o)
+{ *o = rb_float_new(d); return 0; }
 
-static inline VALUE template_callback_nil(msgpack_unpack_context* x)
-{ return Qnil; }
+static inline int template_callback_nil(unpack_user* u, VALUE* o)
+{ *o = Qnil; return 0; }
 
-static inline VALUE template_callback_true(msgpack_unpack_context* x)
-{ return Qtrue; }
+static inline int template_callback_true(unpack_user* u, VALUE* o)
+{ *o = Qtrue; return 0; }
 
-static inline VALUE template_callback_false(msgpack_unpack_context* x)
-{ return Qfalse; }
+static inline int template_callback_false(unpack_user* u, VALUE* o)
+{ *o = Qfalse; return 0;}
 
-static inline VALUE template_callback_array(msgpack_unpack_context* x, unsigned int n)
-{ return rb_ary_new2(n); }
+static inline int template_callback_array(unpack_user* u, unsigned int n, VALUE* o)
+{ *o = rb_ary_new2(n); return 0; }
 
-static inline void template_callback_array_item(msgpack_unpack_context* x, VALUE* c, VALUE o)
-{ rb_ary_push(*c, o); }  // FIXME set value directry RARRAY_PTR(obj)[RARRAY_LEN(obj)++]
+static inline int template_callback_array_item(unpack_user* u, VALUE* c, VALUE o)
+{ rb_ary_push(*c, o); return 0; }  // FIXME set value directry RARRAY_PTR(obj)[RARRAY_LEN(obj)++]
 
-static inline VALUE template_callback_map(msgpack_unpack_context* x, unsigned int n)
-{ return rb_hash_new(); }
+static inline int template_callback_map(unpack_user* u, unsigned int n, VALUE* o)
+{ *o = rb_hash_new(); return 0; }
 
-static inline void template_callback_map_item(msgpack_unpack_context* x, VALUE* c, VALUE k, VALUE v)
-{ rb_hash_aset(*c, k, v); }
+static inline int template_callback_map_item(unpack_user* u, VALUE* c, VALUE k, VALUE v)
+{ rb_hash_aset(*c, k, v); return 0; }
 
-static inline VALUE template_callback_raw(msgpack_unpack_context* x, const char* b, const char* p, unsigned int l)
-{ return l == 0 ? rb_str_new(0,0) : rb_str_substr(x->origstr, p - b, l); }
+static inline int template_callback_raw(unpack_user* u, const char* b, const char* p, unsigned int l, VALUE* o)
+{ *o = (l == 0) ? rb_str_new(0,0) : rb_str_substr(u->source, p - b, l); return 0; }
 
 
 #include "msgpack/unpack_template.h"
 
 
 #define UNPACKER(from, name) \
-	msgpack_unpacker *name = NULL; \
-	Data_Get_Struct(from, msgpack_unpacker, name); \
+	msgpack_unpack_t *name = NULL; \
+	Data_Get_Struct(from, msgpack_unpack_t, name); \
 	if(name == NULL) { \
 		rb_raise(rb_eArgError, "NULL found for " # name " when shouldn't be."); \
 	}
@@ -132,7 +132,7 @@ static void MessagePack_Unpacker_free(void* data)
 	if(data) { free(data); }
 }
 
-static void MessagePack_Unpacker_mark(msgpack_unpacker *mp)
+static void MessagePack_Unpacker_mark(msgpack_unpack_t *mp)
 {
 	unsigned int i;
 	for(i=0; i < mp->top; ++i) {
@@ -144,7 +144,7 @@ static void MessagePack_Unpacker_mark(msgpack_unpacker *mp)
 static VALUE MessagePack_Unpacker_alloc(VALUE klass)
 {
 	VALUE obj;
-	msgpack_unpacker* mp = ALLOC_N(msgpack_unpacker, 1);
+	msgpack_unpack_t* mp = ALLOC_N(msgpack_unpack_t, 1);
 	obj = Data_Wrap_Struct(klass, MessagePack_Unpacker_mark,
 			MessagePack_Unpacker_free, mp);
 	return obj;
@@ -153,9 +153,9 @@ static VALUE MessagePack_Unpacker_alloc(VALUE klass)
 static VALUE MessagePack_Unpacker_reset(VALUE self)
 {
 	UNPACKER(self, mp);
-	msgpack_unpacker_init(mp);
-	msgpack_unpack_context ctx = {0, Qnil};
-	mp->user = ctx;
+	template_init(mp);
+	unpack_user u = {0, Qnil};
+	mp->user = u;
 	return self;
 }
 
@@ -169,21 +169,20 @@ static VALUE MessagePack_Unpacker_execute_impl(VALUE args)
 {
 	VALUE self = ((VALUE*)args)[0];
 	VALUE data = ((VALUE*)args)[1];
-	VALUE off  = ((VALUE*)args)[2];
 
 	UNPACKER(self, mp);
-	size_t from = NUM2UINT(off);
+	size_t from = NUM2UINT(((VALUE*)args)[2]);
 	char* dptr = RSTRING_PTR(data);
-	long dlen = RSTRING_LEN(data);
+	long dlen = FIX2LONG(((VALUE*)args)[3]);
 	int ret;
 
 	if(from >= dlen) {
 		rb_raise(eUnpackError, "offset is bigger than data buffer size.");
 	}
 
-	mp->user.origstr = data;
-	ret = msgpack_unpacker_execute(mp, dptr, (size_t)dlen, &from);
-	mp->user.origstr = Qnil;
+	mp->user.source = data;
+	ret = template_execute(mp, dptr, (size_t)dlen, &from);
+	mp->user.source = Qnil;
 
 	if(ret < 0) {
 		rb_raise(eUnpackError, "parse error.");
@@ -206,17 +205,24 @@ static VALUE MessagePack_Unpacker_execute_rescue(VALUE nouse)
 #endif
 }
 
-static VALUE MessagePack_Unpacker_execute(VALUE self, VALUE data, VALUE off)
+static VALUE MessagePack_Unpacker_execute_limit(VALUE self, VALUE data,
+		VALUE off, VALUE limit)
 {
 	// FIXME execute実行中はmp->topが更新されないのでGC markが機能しない
 	rb_gc_disable();
-	VALUE args[3] = {self, data, off};
+	VALUE args[4] = {self, data, off, limit};
 	VALUE ret = rb_rescue(MessagePack_Unpacker_execute_impl, (VALUE)args,
 			MessagePack_Unpacker_execute_rescue, Qnil);
 	rb_gc_enable();
 	return ret;
 }
 
+static VALUE MessagePack_Unpacker_execute(VALUE self, VALUE data, VALUE off)
+{
+	return MessagePack_Unpacker_execute_limit(self, data, off,
+			LONG2FIX(RSTRING_LEN(data)));
+}
+
 static VALUE MessagePack_Unpacker_finished_p(VALUE self)
 {
 	UNPACKER(self, mp);
@@ -229,23 +235,23 @@ static VALUE MessagePack_Unpacker_finished_p(VALUE self)
 static VALUE MessagePack_Unpacker_data(VALUE self)
 {
 	UNPACKER(self, mp);
-	return msgpack_unpacker_data(mp);
+	return template_data(mp);
 }
 
 
 static VALUE MessagePack_unpack_impl(VALUE args)
 {
-	msgpack_unpacker* mp = (msgpack_unpacker*)((VALUE*)args)[0];
+	msgpack_unpack_t* mp = (msgpack_unpack_t*)((VALUE*)args)[0];
 	VALUE data = ((VALUE*)args)[1];
 
 	size_t from = 0;
 	char* dptr = RSTRING_PTR(data);
-	long dlen = RSTRING_LEN(data);
+	long dlen = FIX2LONG(((VALUE*)args)[2]);
 	int ret;
 
-	mp->user.origstr = data;
-	ret = msgpack_unpacker_execute(mp, dptr, (size_t)dlen, &from);
-	mp->user.origstr = Qnil;
+	mp->user.source = data;
+	ret = template_execute(mp, dptr, (size_t)dlen, &from);
+	mp->user.source = Qnil;
 
 	if(ret < 0) {
 		rb_raise(eUnpackError, "parse error.");
@@ -255,7 +261,7 @@ static VALUE MessagePack_unpack_impl(VALUE args)
 		if(from < dlen) {
 			rb_raise(eUnpackError, "extra bytes.");
 		}
-		return msgpack_unpacker_data(mp);
+		return template_data(mp);
 	}
 }
 
@@ -269,22 +275,30 @@ static VALUE MessagePack_unpack_rescue(VALUE args)
 #endif
 }
 
-static VALUE MessagePack_unpack(VALUE self, VALUE data)
+static VALUE MessagePack_unpack_limit(VALUE self, VALUE data, VALUE limit)
 {
 	CHECK_STRING_TYPE(data);
-	msgpack_unpacker mp;
-	msgpack_unpacker_init(&mp);
-	msgpack_unpack_context ctx = {0, Qnil};
-	mp.user = ctx;
+
+	msgpack_unpack_t mp;
+	template_init(&mp);
+	unpack_user u = {0, Qnil};
+	mp.user = u;
 
 	rb_gc_disable();
-	VALUE args[2] = {(VALUE)&mp, data};
+	VALUE args[3] = {(VALUE)&mp, data, limit};
 	VALUE ret = rb_rescue(MessagePack_unpack_impl, (VALUE)args,
 			MessagePack_unpack_rescue, Qnil);
 	rb_gc_enable();
+
 	return ret;
 }
 
+static VALUE MessagePack_unpack(VALUE self, VALUE data)
+{
+	return MessagePack_unpack_limit(self, data,
+			LONG2FIX(RSTRING_LEN(data)));
+}
+
 
 void Init_msgpack_unpack(VALUE mMessagePack)
 {
@@ -293,10 +307,12 @@ void Init_msgpack_unpack(VALUE mMessagePack)
 	rb_define_alloc_func(cUnpacker, MessagePack_Unpacker_alloc);
 	rb_define_method(cUnpacker, "initialize", MessagePack_Unpacker_initialize, 0);
 	rb_define_method(cUnpacker, "execute", MessagePack_Unpacker_execute, 2);
+	rb_define_method(cUnpacker, "execute_limit", MessagePack_Unpacker_execute_limit, 3);
 	rb_define_method(cUnpacker, "finished?", MessagePack_Unpacker_finished_p, 0);
 	rb_define_method(cUnpacker, "data", MessagePack_Unpacker_data, 0);
 	rb_define_method(cUnpacker, "reset", MessagePack_Unpacker_reset, 0);
 	rb_define_module_function(mMessagePack, "unpack", MessagePack_unpack, 1);
+	rb_define_module_function(mMessagePack, "unpack_limit", MessagePack_unpack_limit, 2);
 }