msgpack 0.7.4 → 1.3.3

data/doclib/msgpack/factory.rb

@@ -19,6 +19,22 @@ module MessagePack
     def packer(*args)
     end
 
+    #
+    # Serialize the passed value
+    #
+    # If it could not serialize the object, it raises
+    # NoMethodError: undefined method `to_msgpack' for #<the_object>.
+    #
+    # @param obj [Object] object to serialize
+    # @param options [Hash]
+    # @return [String] serialized object
+    #
+    # See Packer#initialize for supported options.
+    #
+    def dump(obj, options={})
+    end
+    alias pack dump
+
     #
     # Creates a MessagePack::Unpacker instance, which has ext types already registered.
     # Options are passed to MessagePack::Unpacker#initialized.
@@ -28,6 +44,23 @@ module MessagePack
     def unpacker(*args)
     end
 
+    #
+    # Deserializes an object from the string or io and returns it.
+    #
+    # If there're not enough data to deserialize one object, this method raises EOFError.
+    # If data format is invalid, this method raises MessagePack::MalformedFormatError.
+    # If the object nests too deeply, this method raises MessagePack::StackError.
+    #
+    # @param data [String]
+    # @param options [Hash]
+    # @return [Object] deserialized object
+    #
+    # See Unpacker#initialize for supported options.
+    #
+    def load(data, options={})
+    end
+    alias unpack load
+
     #
     # Register a type and Class to be registered for packer and/or unpacker.
     # If options are not speicified, factory will use :to_msgpack_ext for packer, and

data/doclib/msgpack/packer.rb

@@ -91,6 +91,12 @@ module MessagePack
     def write_nil
     end
 
+    #
+    # Serializes a string object as binary data. Same as write("string".encode(Encoding::BINARY)).
+    #
+    def write_bin(obj)
+    end
+
     #
     # Write a header of an array whose size is _n_.
     # For example, write_array_header(1).write(true) is same as write([ true ]).
@@ -109,6 +115,20 @@ module MessagePack
     def write_map_header(n)
     end
 
+    #
+    # Write a header of a binary string whose size is _n_. Useful if you want to append large binary data without loading it into memory at once.
+    # For example,
+    # MessagePack::Packer.new(io).write_bin_header(12).flush
+    # io.write('chunk1')
+    # io.write('chunk2')
+    # is the same as
+    # write('chunk1chunk2'.encode(Encoding::BINARY)).
+    #
+    # @return [Packer] self
+    #
+    def write_bin_header(n)
+    end
+
     #
     # Serializes _value_ as 32-bit single precision float into internal buffer.
     # _value_ will be approximated with the nearest possible single precision float, thus

data/doclib/msgpack/time.rb

@@ -0,0 +1,22 @@
+module MessagePack
+
+  # MessagePack::Time provides packer and unpacker functions for a timestamp type.
+  # @example Setup for DefaultFactory
+  #   MessagePack::DefaultFactory.register_type(
+  #     MessagePack::Timestamp::TYPE,
+  #     Time,
+  #     packer: MessagePack::Time::Packer,
+  #     unpacker: MessagePack::Time::Unpacker
+  #   )
+  class Time
+    # A packer function that packs a Time instance to a MessagePack timestamp.
+    Packer = lambda { |payload|
+      # ...
+    }
+
+    # An unpacker function that unpacks a MessagePack timestamp to a Time instance.
+    Unpacker = lambda { |time|
+      # ...
+    }
+  end
+end

data/doclib/msgpack/timestamp.rb

@@ -0,0 +1,44 @@
+module MessagePack
+  # A utility class for MessagePack timestamp type
+  class Timestamp
+    #
+    # The timestamp extension type defined in the MessagePack spec.
+    #
+    # See https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type for details.
+    #
+    TYPE = -1
+
+    # @return [Integer] Second part of the timestamp.
+    attr_reader :sec
+
+    # @return [Integer] Nanosecond part of the timestamp.
+    attr_reader :nsec
+
+    # @param [Integer] sec
+    # @param [Integer] nsec
+    def initialize(sec, nsec)
+    end
+
+    # @example An unpacker implementation for the Time class
+    #   lambda do |payload|
+    #     tv = MessagePack::Timestamp.from_msgpack_ext(payload)
+    #     Time.at(tv.sec, tv.nsec, :nanosecond)
+    #   end
+    #
+    # @param [String] data
+    # @return [MessagePack::Timestamp]
+    def self.from_msgpack_ext(data)
+    end
+
+    # @example A packer implementation for the Time class
+    #   unpacker = lambda do |time|
+    #     MessagePack::Timestamp.to_msgpack_ext(time.tv_sec, time.tv_nsec)
+    #   end
+    #
+    # @param [Integer] sec
+    # @param [Integer] nsec
+    # @return [String]
+    def self.to_msgpack_ext(sec, nsec)
+    end
+  end
+end

data/ext/java/org/msgpack/jruby/Buffer.java

@@ -179,6 +179,10 @@ public class Buffer extends RubyObject {
     return skipCommon(ctx, length, true);
   }
 
+  public boolean hasIo() {
+    return io != null;
+  }
+
   @JRubyMethod(name = "to_s", alias = {"to_str"})
   public IRubyObject toS(ThreadContext ctx) {
     ensureReadMode();

data/ext/java/org/msgpack/jruby/Encoder.java

@@ -3,9 +3,11 @@ package org.msgpack.jruby;
 
 import java.math.BigInteger;
 import java.nio.ByteBuffer;
+import java.util.Arrays;
 
 import org.jruby.Ruby;
 import org.jruby.RubyObject;
+import org.jruby.RubyModule;
 import org.jruby.RubyNil;
 import org.jruby.RubyBoolean;
 import org.jruby.RubyNumeric;
@@ -37,15 +39,18 @@ public class Encoder {
   private final boolean compatibilityMode;
   private final ExtensionRegistry registry;
 
+  public boolean hasSymbolExtType;
+
   private ByteBuffer buffer;
 
-  public Encoder(Ruby runtime, boolean compatibilityMode, ExtensionRegistry registry) {
+  public Encoder(Ruby runtime, boolean compatibilityMode, ExtensionRegistry registry, boolean hasSymbolExtType) {
     this.runtime = runtime;
     this.buffer = ByteBuffer.allocate(CACHE_LINE_SIZE - ARRAY_HEADER_SIZE);
     this.binaryEncoding = runtime.getEncodingService().getAscii8bitEncoding();
     this.utf8Encoding = UTF8Encoding.INSTANCE;
     this.compatibilityMode = compatibilityMode;
     this.registry = registry;
+    this.hasSymbolExtType = hasSymbolExtType;
   }
 
   public boolean isCompatibilityMode() {
@@ -86,6 +91,11 @@ public class Encoder {
     return readRubyString();
   }
 
+  public IRubyObject encodeBinHeader(int size) {
+    appendStringHeader(size, true);
+    return readRubyString();
+  }
+
   public IRubyObject encodeFloat32(RubyNumeric numeric) {
     appendFloat32(numeric);
     return readRubyString();
@@ -111,7 +121,11 @@ public class Encoder {
     } else if (object instanceof RubyString) {
       appendString((RubyString) object);
     } else if (object instanceof RubySymbol) {
-      appendString(((RubySymbol) object).asString());
+      if (hasSymbolExtType) {
+        appendOther(object, destination);
+      } else {
+        appendString(((RubySymbol) object).asString());
+      }
     } else if (object instanceof RubyArray) {
       appendArray((RubyArray) object);
     } else if (object instanceof RubyHash) {
@@ -124,14 +138,18 @@ public class Encoder {
   }
 
   private void appendBignum(RubyBignum object) {
-    BigInteger value = ((RubyBignum) object).getBigIntegerValue();
-    if (value.bitLength() > 64 || (value.bitLength() > 63 && value.signum() < 0)) {
-      throw runtime.newArgumentError(String.format("Cannot pack big integer: %s", value));
+    BigInteger value = object.getBigIntegerValue();
+    if (value.compareTo(RubyBignum.LONG_MIN) < 0 || value.compareTo(RubyBignum.LONG_MAX) > 0) {
+      if (value.bitLength() > 64 || (value.bitLength() > 63 && value.signum() < 0)) {
+        throw runtime.newArgumentError(String.format("Cannot pack big integer: %s", value));
+      }
+      ensureRemainingCapacity(9);
+      buffer.put(value.signum() < 0 ? INT64 : UINT64);
+      byte[] b = value.toByteArray();
+      buffer.put(b, b.length - 8, 8);
+    } else {
+      appendInteger(object);
     }
-    ensureRemainingCapacity(9);
-    buffer.put(value.signum() < 0 ? INT64 : UINT64);
-    byte[] b = value.toByteArray();
-    buffer.put(b, b.length - 8, 8);
   }
 
   private void appendInteger(RubyInteger object) {
@@ -208,14 +226,7 @@ public class Encoder {
     buffer.putFloat(value);
   }
 
-  private void appendString(RubyString object) {
-    Encoding encoding = object.getEncoding();
-    boolean binary = !compatibilityMode && encoding == binaryEncoding;
-    if (encoding != utf8Encoding && encoding != binaryEncoding) {
-      object = (RubyString) ((RubyString) object).encode(runtime.getCurrentContext(), runtime.getEncodingService().getEncoding(utf8Encoding));
-    }
-    ByteList bytes = object.getByteList();
-    int length = bytes.length();
+  private void appendStringHeader(int length, boolean binary) {
     if (length < 32 && !binary) {
       ensureRemainingCapacity(1 + length);
       buffer.put((byte) (length | FIXSTR));
@@ -232,6 +243,17 @@ public class Encoder {
       buffer.put(binary ? BIN32 : STR32);
       buffer.putInt((int) length);
     }
+  }
+
+  private void appendString(RubyString object) {
+    Encoding encoding = object.getEncoding();
+    boolean binary = !compatibilityMode && encoding == binaryEncoding;
+    if (encoding != utf8Encoding && encoding != binaryEncoding) {
+      object = (RubyString) ((RubyString) object).encode(runtime.getCurrentContext(), runtime.getEncodingService().getEncoding(utf8Encoding));
+    }
+    ByteList bytes = object.getByteList();
+    int length = bytes.length();
+    appendStringHeader(length, binary);
     buffer.put(bytes.unsafeBytes(), bytes.begin(), length);
   }
 
@@ -363,7 +385,15 @@ public class Encoder {
 
   private void appendOther(IRubyObject object, IRubyObject destination) {
     if (registry != null) {
-      IRubyObject[] pair = registry.lookupPackerByClass(object.getType());
+      RubyModule lookupClass;
+
+      if (object.getType() == runtime.getSymbol()) {
+        lookupClass = object.getType();
+      } else {
+        lookupClass = object.getSingletonClass();
+      }
+
+      IRubyObject[] pair = registry.lookupPackerForObject(object);
       if (pair != null) {
         RubyString bytes = pair[0].callMethod(runtime.getCurrentContext(), "call", object).asString();
         int type = (int) ((RubyFixnum) pair[1]).getLongValue();

data/ext/java/org/msgpack/jruby/ExtensionRegistry.java

@@ -3,8 +3,9 @@ package org.msgpack.jruby;
 import org.jruby.Ruby;
 import org.jruby.RubyHash;
 import org.jruby.RubyArray;
-import org.jruby.RubyClass;
+import org.jruby.RubyModule;
 import org.jruby.RubyFixnum;
+import org.jruby.RubySymbol;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
@@ -12,19 +13,19 @@ import java.util.Map;
 import java.util.HashMap;
 
 public class ExtensionRegistry {
-  private final Map<RubyClass, ExtensionEntry> extensionsByClass;
-  private final Map<RubyClass, ExtensionEntry> extensionsByAncestor;
+  private final Map<RubyModule, ExtensionEntry> extensionsByModule;
+  private final Map<RubyModule, ExtensionEntry> extensionsByAncestor;
   private final ExtensionEntry[] extensionsByTypeId;
 
   public ExtensionRegistry() {
-    this(new HashMap<RubyClass, ExtensionEntry>());
+    this(new HashMap<RubyModule, ExtensionEntry>());
   }
 
-  private ExtensionRegistry(Map<RubyClass, ExtensionEntry> extensionsByClass) {
-    this.extensionsByClass = new HashMap<RubyClass, ExtensionEntry>(extensionsByClass);
-    this.extensionsByAncestor = new HashMap<RubyClass, ExtensionEntry>();
+  private ExtensionRegistry(Map<RubyModule, ExtensionEntry> extensionsByModule) {
+    this.extensionsByModule = new HashMap<RubyModule, ExtensionEntry>(extensionsByModule);
+    this.extensionsByAncestor = new HashMap<RubyModule, ExtensionEntry>();
     this.extensionsByTypeId = new ExtensionEntry[256];
-    for (ExtensionEntry entry : extensionsByClass.values()) {
+    for (ExtensionEntry entry : extensionsByModule.values()) {
       if (entry.hasUnpacker()) {
         extensionsByTypeId[entry.getTypeId() + 128] = entry;
       }
@@ -32,15 +33,15 @@ public class ExtensionRegistry {
   }
 
   public ExtensionRegistry dup() {
-    return new ExtensionRegistry(extensionsByClass);
+    return new ExtensionRegistry(extensionsByModule);
   }
 
   public IRubyObject toInternalPackerRegistry(ThreadContext ctx) {
     RubyHash hash = RubyHash.newHash(ctx.getRuntime());
-    for (RubyClass extensionClass : extensionsByClass.keySet()) {
-      ExtensionEntry entry = extensionsByClass.get(extensionClass);
+    for (RubyModule extensionModule : extensionsByModule.keySet()) {
+      ExtensionEntry entry = extensionsByModule.get(extensionModule);
       if (entry.hasPacker()) {
-        hash.put(extensionClass, entry.toPackerTuple(ctx));
+        hash.put(extensionModule, entry.toPackerTuple(ctx));
       }
     }
     return hash;
@@ -58,9 +59,9 @@ public class ExtensionRegistry {
     return hash;
   }
 
-  public void put(RubyClass cls, int typeId, IRubyObject packerProc, IRubyObject packerArg, IRubyObject unpackerProc, IRubyObject unpackerArg) {
-    ExtensionEntry entry = new ExtensionEntry(cls, typeId, packerProc, packerArg, unpackerProc, unpackerArg);
-    extensionsByClass.put(cls, entry);
+  public void put(RubyModule mod, int typeId, IRubyObject packerProc, IRubyObject packerArg, IRubyObject unpackerProc, IRubyObject unpackerArg) {
+    ExtensionEntry entry = new ExtensionEntry(mod, typeId, packerProc, packerArg, unpackerProc, unpackerArg);
+    extensionsByModule.put(mod, entry);
     extensionsByTypeId[typeId + 128] = entry;
     extensionsByAncestor.clear();
   }
@@ -74,45 +75,73 @@ public class ExtensionRegistry {
     }
   }
 
-  public IRubyObject[] lookupPackerByClass(RubyClass cls) {
-    ExtensionEntry e = extensionsByClass.get(cls);
-    if (e == null) {
-      e = extensionsByAncestor.get(cls);
+  public IRubyObject[] lookupPackerForObject(IRubyObject object) {
+    RubyModule lookupClass = null;
+    IRubyObject[] pair;
+    /*
+     * Objects of type Integer (Fixnum, Bignum), Float, Symbol and frozen
+     * String have no singleton class and raise a TypeError when trying to get
+     * it.
+     *
+     * Since all but symbols are already filtered out when reaching this code
+     * only symbols are checked here.
+     */
+    if (!(object instanceof RubySymbol)) {
+      lookupClass = object.getSingletonClass();
+      pair = fetchEntryByModule(lookupClass);
+      if (pair != null) {
+          return pair;
+      }
+    }
+
+    pair = fetchEntryByModule(object.getType());
+    if (pair != null) {
+      return pair;
+    }
+
+    if (lookupClass == null) {
+      lookupClass = object.getType(); // only for Symbol
+    }
+    ExtensionEntry e = findEntryByModuleOrAncestor(lookupClass);
+    if (e != null && e.hasPacker()) {
+      extensionsByAncestor.put(e.getExtensionModule(), e);
+      return e.toPackerProcTypeIdPair(lookupClass.getRuntime().getCurrentContext());
     }
+    return null;
+  }
+
+  private IRubyObject[] fetchEntryByModule(final RubyModule mod) {
+    ExtensionEntry e = extensionsByModule.get(mod);
     if (e == null) {
-      e = findEntryByClassOrAncestor(cls);
-      if (e != null) {
-        extensionsByAncestor.put(e.getExtensionClass(), e);
-      }
+      e = extensionsByAncestor.get(mod);
     }
     if (e != null && e.hasPacker()) {
-      return e.toPackerProcTypeIdPair(cls.getRuntime().getCurrentContext());
-    } else {
-      return null;
+      return e.toPackerProcTypeIdPair(mod.getRuntime().getCurrentContext());
     }
+    return null;
   }
 
-  private ExtensionEntry findEntryByClassOrAncestor(final RubyClass cls) {
-    ThreadContext ctx = cls.getRuntime().getCurrentContext();
-    for (RubyClass extensionClass : extensionsByClass.keySet()) {
-      RubyArray ancestors = (RubyArray) cls.callMethod(ctx, "ancestors");
-      if (ancestors.callMethod(ctx, "include?", extensionClass).isTrue()) {
-        return extensionsByClass.get(extensionClass);
+  private ExtensionEntry findEntryByModuleOrAncestor(final RubyModule mod) {
+    ThreadContext ctx = mod.getRuntime().getCurrentContext();
+    for (RubyModule extensionModule : extensionsByModule.keySet()) {
+      RubyArray ancestors = (RubyArray) mod.callMethod(ctx, "ancestors");
+      if (ancestors.callMethod(ctx, "include?", extensionModule).isTrue()) {
+        return extensionsByModule.get(extensionModule);
       }
     }
     return null;
   }
 
   private static class ExtensionEntry {
-    private final RubyClass cls;
+    private final RubyModule mod;
     private final int typeId;
     private final IRubyObject packerProc;
     private final IRubyObject packerArg;
     private final IRubyObject unpackerProc;
     private final IRubyObject unpackerArg;
 
-    public ExtensionEntry(RubyClass cls, int typeId, IRubyObject packerProc, IRubyObject packerArg, IRubyObject unpackerProc, IRubyObject unpackerArg) {
-      this.cls = cls;
+    public ExtensionEntry(RubyModule mod, int typeId, IRubyObject packerProc, IRubyObject packerArg, IRubyObject unpackerProc, IRubyObject unpackerArg) {
+      this.mod = mod;
       this.typeId = typeId;
       this.packerProc = packerProc;
       this.packerArg = packerArg;
@@ -120,8 +149,8 @@ public class ExtensionRegistry {
       this.unpackerArg = unpackerArg;
     }
 
-    public RubyClass getExtensionClass() {
-      return cls;
+    public RubyModule getExtensionModule() {
+      return mod;
     }
 
     public int getTypeId() {
@@ -149,7 +178,7 @@ public class ExtensionRegistry {
     }
 
     public RubyArray toUnpackerTuple(ThreadContext ctx) {
-      return RubyArray.newArray(ctx.getRuntime(), new IRubyObject[] {cls, unpackerProc, unpackerArg});
+      return RubyArray.newArray(ctx.getRuntime(), new IRubyObject[] {mod, unpackerProc, unpackerArg});
     }
 
     public IRubyObject[] toPackerProcTypeIdPair(ThreadContext ctx) {