protobuf_java_helpers 0.1.1-java → 0.2.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a3f9b31577a8febb01cea661b249658bd7687ae2
-  data.tar.gz: 900ded1d519d468307eb34efc4bb313731fec93b
+  metadata.gz: 5dbe390930dc3f5880b318fae77f1d18783b875e
+  data.tar.gz: d67af2c6dfba079537fbecba804268f57ff7a8ae
 SHA512:
-  metadata.gz: 99ab497203ad7e98a8cc4a3fe63dbcc7098e8f4dc749a777748d8a476d073724a4062c41b8df4932da68aba0f87460292e0a8bd0456ce3c519d8413a630343fb
-  data.tar.gz: 56ba95bebf58a01272beaf2665d8ad3fd1466d52aa83d459f41e534ad383f622d0a8870188e11000b6b88ab96637b54e2ebf85fe3563f0af94d9af27d87ac109
+  metadata.gz: 65fe02b012cdaf484e043e0e282eb9d886e14b8468efbd3a0eb5cac1e84e77b6696d1e6894f26027ea0b2ac0d26345eed3b1f3f7cefe216172c576dfa93c6ccc
+  data.tar.gz: 06cda872d96c48edc94d7809dc2e34beda699adcf4b2c07973375ef987d2e43847d32ab07748880d2b66c5c1926f98ced0dadddeb90094c2ea1102c1cefa2833

data/ext/ruby_protobuf/Int32ProtobufField.java

@@ -15,7 +15,7 @@ import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
 public class Int32ProtobufField {
-  private static final long MIN = 0L;
+  private static final long MIN = (long)java.lang.Math.pow(-2, 31);
   private static final long MAX = ((long)java.lang.Math.pow(2, 31) - 1);
   private static String TYPE = "Int32";
 

data/ext/ruby_protobuf/Int64ProtobufField.java

@@ -17,12 +17,15 @@ import org.jruby.runtime.builtin.IRubyObject;
 public class Int64ProtobufField {
   private static final long MIN = ((long)java.lang.Math.pow(-2, 63));
   private static final long MAX = ((long)java.lang.Math.pow(2, 63) - 1);
-  private static String TYPE = "Int32";
+  private static String TYPE = "Int64";
+
+  private static boolean internal_acceptable(long value) {
+    return value >= MIN && value <= MAX;
+  }
 
   private static boolean internal_acceptable(IRubyObject recv) {
-    if (recv instanceof RubyInteger || recv instanceof RubyFixnum) {
-      long value = ((RubyFixnum) recv).getLongValue();
-      return value >= MIN && value <= MAX;
+    if (recv instanceof RubyInteger || recv instanceof RubyFixnum || recv instanceof RubyNumeric || recv instanceof RubyFloat) {
+      return internal_acceptable(((RubyNumeric) recv).getLongValue());
     }
 
     return false;
@@ -46,15 +49,7 @@ public class Int64ProtobufField {
     if (!internal_acceptable(recv)) {
       throw runtime.newTypeError("can't convert " + recv.getMetaClass() + " into " + TYPE);
     }
-
-    if (recv instanceof RubyInteger) {
-      return ((RubyInteger)recv).to_i();
-    }
-
-    if (recv instanceof RubyFixnum) {
-      return ((RubyFixnum)recv).to_i();
-    }
-
-    return org.jruby.util.TypeConverter.convertToInteger(context, recv, 10);
+    
+    return context.getRuntime().newFixnum(((RubyNumeric) recv).getLongValue());
   }
 }

data/ext/ruby_protobuf/IntegerProtobufField.java

@@ -0,0 +1,90 @@
+package com.abrandoned.protobuf_java_helpers;
+
+import java.lang.Math;
+import org.jruby.Ruby;
+import org.jruby.RubyBignum;
+import org.jruby.RubyComplex;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyFloat;
+import org.jruby.RubyInteger;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyString;
+import java.math.BigInteger;
+import org.jruby.util.TypeConverter;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+public class IntegerProtobufField {
+  private static final long MIN = ((long)java.lang.Math.pow(-2, 63));
+  private static final long MAX = ((long)java.lang.Math.pow(2, 63) - 1);
+  private static String TYPE = "Integer";
+
+  private static boolean internal_acceptable(long value) {
+    return value >= MIN && value <= MAX;
+  }
+
+  private static boolean internal_acceptable(IRubyObject recv) {
+    if (recv instanceof RubyInteger || recv instanceof RubyFixnum || recv instanceof RubyNumeric || recv instanceof RubyFloat) {
+      return internal_acceptable(((RubyFixnum) recv).getLongValue());
+    }
+
+    return false;
+  }
+
+  @JRubyMethod(name = "acceptable?")
+  public static IRubyObject acceptable_p( ThreadContext context, IRubyObject self, IRubyObject recv ) {
+    org.jruby.Ruby runtime = context.getRuntime();
+
+    if (internal_acceptable(recv)) {
+      return runtime.getTrue();
+    }
+
+    return runtime.getFalse();
+  }
+
+  @JRubyMethod(name = "coerce!")
+  public static IRubyObject coerce_bang( ThreadContext context, IRubyObject self, IRubyObject recv ) {
+    org.jruby.Ruby runtime = context.getRuntime();
+
+    if (!internal_acceptable(recv)) {
+      throw runtime.newTypeError("can't convert " + recv.getMetaClass() + " into " + TYPE);
+    }
+
+    if (recv instanceof RubyInteger) {
+      return ((RubyInteger)recv).to_i();
+    }
+
+    if (recv instanceof RubyFixnum) {
+      return ((RubyFixnum)recv).to_i();
+    }
+
+    return org.jruby.util.TypeConverter.convertToInteger(context, recv, 10);
+  }
+
+  @JRubyMethod
+  public static IRubyObject decode_varint_64( ThreadContext context, IRubyObject self, IRubyObject recv ) {
+    if (!(recv instanceof RubyInteger || recv instanceof RubyFixnum || recv instanceof RubyNumeric || recv instanceof RubyFloat)) {
+      System.out.println("DERP");
+      return context.nil;
+    }
+
+    long value = ((RubyNumeric) recv).getLongValue();
+    org.jruby.Ruby runtime = context.getRuntime();
+
+    if ((value & 0x8000000000000000L) != 0L) {
+      java.math.BigInteger big_value = java.math.BigInteger.valueOf(value);
+      java.math.BigInteger big_minus = java.math.BigInteger.ONE.shiftLeft(16);
+      big_value = big_value.subtract(big_minus);
+
+      value = big_value.longValue();
+    }
+
+    if (internal_acceptable(value)) {
+      return context.getRuntime().newFixnum(value);
+    } else {
+      System.out.println("DERP2");
+      return context.nil;
+    }
+  }
+}

data/ext/ruby_protobuf/Sint64ProtobufField.java

@@ -17,7 +17,7 @@ import org.jruby.runtime.builtin.IRubyObject;
 public class Sint64ProtobufField {
   private static final long MIN = ((long)java.lang.Math.pow(-2, 63));
   private static final long MAX = ((long)java.lang.Math.pow(2, 63) - 1);
-  private static String TYPE = "Sint32";
+  private static String TYPE = "Sint64";
 
   private static boolean internal_acceptable(IRubyObject recv) {
     if (recv instanceof RubyInteger || recv instanceof RubyFixnum) {

data/ext/ruby_protobuf/Uint32ProtobufField.java

@@ -16,7 +16,7 @@ import org.jruby.runtime.builtin.IRubyObject;
 
 public class Uint32ProtobufField {
   private static final long MIN = 0L;
-  private static final long MAX = ((long)java.lang.Math.pow(2, 31) - 1);
+  private static final long MAX = ((long)java.lang.Math.pow(2, 32) - 1);
   private static String TYPE = "Uint32";
 
   private static boolean internal_acceptable(IRubyObject recv) {

data/ext/ruby_protobuf/Uint64ProtobufField.java

@@ -17,7 +17,7 @@ import org.jruby.runtime.builtin.IRubyObject;
 public class Uint64ProtobufField {
   private static final long MIN = 0L;
   private static final long MAX = ((long)java.lang.Math.pow(2, 64) - 1);
-  private static String TYPE = "Uint32";
+  private static String TYPE = "Uint64";
 
   private static boolean internal_acceptable(IRubyObject recv) {
     if (recv instanceof RubyInteger || recv instanceof RubyFixnum) {

data/ext/ruby_protobuf/Varint.java

@@ -0,0 +1,203 @@
+package com.abrandoned.protobuf_java_helpers;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+/**
+ * <p>Encodes signed and unsigned values using a common variable-length
+ * scheme, found for example in
+ * <a href="http://code.google.com/apis/protocolbuffers/docs/encoding.html">
+ * Google's Protocol Buffers</a>. It uses fewer bytes to encode smaller values,
+ * but will use slightly more bytes to encode large values.</p>
+ * <p/>
+ * <p>Signed values are further encoded using so-called zig-zag encoding
+ * in order to make them "compatible" with variable-length encoding.</p>
+ */
+public final class Varint {
+
+    private Varint() {
+    }
+
+    /**
+     * Encodes a value using the variable-length encoding from
+     * <a href="http://code.google.com/apis/protocolbuffers/docs/encoding.html">
+     * Google Protocol Buffers</a>. It uses zig-zag encoding to efficiently
+     * encode signed values. If values are known to be nonnegative,
+     * {@link #writeUnsignedVarLong(long, DataOutput)} should be used.
+     *
+     * @param value value to encode
+     * @param out   to write bytes to
+     * @throws IOException if {@link DataOutput} throws {@link IOException}
+     */
+    public static void writeSignedVarLong(long value, DataOutput out) throws IOException {
+        // Great trick from http://code.google.com/apis/protocolbuffers/docs/encoding.html#types
+        writeUnsignedVarLong((value << 1) ^ (value >> 63), out);
+    }
+
+    /**
+     * Encodes a value using the variable-length encoding from
+     * <a href="http://code.google.com/apis/protocolbuffers/docs/encoding.html">
+     * Google Protocol Buffers</a>. Zig-zag is not used, so input must not be negative.
+     * If values can be negative, use {@link #writeSignedVarLong(long, DataOutput)}
+     * instead. This method treats negative input as like a large unsigned value.
+     *
+     * @param value value to encode
+     * @param out   to write bytes to
+     * @throws IOException if {@link DataOutput} throws {@link IOException}
+     */
+    public static void writeUnsignedVarLong(long value, DataOutput out) throws IOException {
+        while ((value & 0xFFFFFFFFFFFFFF80L) != 0L) {
+            out.writeByte(((int) value & 0x7F) | 0x80);
+            value >>>= 7;
+        }
+        out.writeByte((int) value & 0x7F);
+    }
+
+    public static void writeUnsignedVarLong2(long value, DataOutput out) throws IOException {
+      if ((value & 0xFFFFFFFFFFFFFF80L) != 0L) {
+        out.writeByte(((int) value & 0x7F) | 0x80);
+        value >>>= 7;
+        if ((value & 0xFFFFFFFFFFFFFF80L) != 0L) {
+          out.writeByte(((int) value & 0x7F) | 0x80);
+          value >>>= 7;
+          if ((value & 0xFFFFFFFFFFFFFF80L) != 0L) {
+            out.writeByte(((int) value & 0x7F) | 0x80);
+            value >>>= 7;
+            if ((value & 0xFFFFFFFFFFFFFF80L) != 0L) {
+              out.writeByte(((int) value & 0x7F) | 0x80);
+              value >>>= 7;
+              if ((value & 0xFFFFFFFFFFFFFF80L) != 0L) {
+                out.writeByte(((int) value & 0x7F) | 0x80);
+                value >>>= 7;
+                if ((value & 0xFFFFFFFFFFFFFF80L) != 0L) {
+                  out.writeByte(((int) value & 0x7F) | 0x80);
+                  value >>>= 7;
+                  if ((value & 0xFFFFFFFFFFFFFF80L) != 0L) {
+                    out.writeByte(((int) value & 0x7F) | 0x80);
+                    value >>>= 7;
+                    if ((value & 0xFFFFFFFFFFFFFF80L) != 0L) {
+                      out.writeByte(((int) value & 0x7F) | 0x80);
+                      value >>>= 7;
+                      if ((value & 0xFFFFFFFFFFFFFF80L) != 0L) {
+                        out.writeByte(((int) value & 0x7F) | 0x80);
+                        value >>>= 7;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      out.writeByte((int) value & 0x7F);
+    }
+
+    /**
+     * @see #writeSignedVarLong(long, DataOutput)
+     */
+    public static void writeSignedVarInt(int value, DataOutput out) throws IOException {
+        // Great trick from http://code.google.com/apis/protocolbuffers/docs/encoding.html#types
+        writeUnsignedVarInt((value << 1) ^ (value >> 31), out);
+    }
+
+    /**
+     * @see #writeUnsignedVarLong(long, DataOutput)
+     */
+    public static void writeUnsignedVarInt(int value, DataOutput out) throws IOException {
+        while ((value & 0xFFFFFF80) != 0L) {
+            out.writeByte((value & 0x7F) | 0x80);
+            value >>>= 7;
+        }
+        out.writeByte(value & 0x7F);
+    }
+
+    /**
+     * @param in to read bytes from
+     * @return decode value
+     * @throws IOException              if {@link DataInput} throws {@link IOException}
+     * @throws IllegalArgumentException if variable-length value does not terminate
+     *                                  after 9 bytes have been read
+     * @see #writeSignedVarLong(long, DataOutput)
+     */
+    public static long readSignedVarLong(DataInput in) throws IOException {
+        long raw = readUnsignedVarLong(in);
+        // This undoes the trick in writeSignedVarLong()
+        long temp = (((raw << 63) >> 63) ^ raw) >> 1;
+        // This extra step lets us deal with the largest signed values by treating
+        // negative results from read unsigned methods as like unsigned values
+        // Must re-flip the top bit if the original read value had it set.
+        return temp ^ (raw & (1L << 63));
+    }
+
+    /**
+     * @param in to read bytes from
+     * @return decode value
+     * @throws IOException              if {@link DataInput} throws {@link IOException}
+     * @throws IllegalArgumentException if variable-length value does not terminate
+     *                                  after 9 bytes have been read
+     * @see #writeUnsignedVarLong(long, DataOutput)
+     */
+    public static long readUnsignedVarLong(DataInput in) throws IOException {
+        long value = 0L;
+        int i = 0;
+        long b;
+        while (((b = in.readByte()) & 0x80L) != 0) {
+            value |= (b & 0x7F) << i;
+            i += 7;
+        }
+        return value | (b << i);
+    }
+
+    /**
+     * @throws IllegalArgumentException if variable-length value does not terminate
+     *                                  after 5 bytes have been read
+     * @throws IOException              if {@link DataInput} throws {@link IOException}
+     * @see #readSignedVarLong(DataInput)
+     */
+    public static int readSignedVarInt(DataInput in) throws IOException {
+        int raw = readUnsignedVarInt(in);
+        // This undoes the trick in writeSignedVarInt()
+        int temp = (((raw << 31) >> 31) ^ raw) >> 1;
+        // This extra step lets us deal with the largest signed values by treating
+        // negative results from read unsigned methods as like unsigned values.
+        // Must re-flip the top bit if the original read value had it set.
+        return temp ^ (raw & (1 << 31));
+    }
+
+
+    /**
+     * @throws IllegalArgumentException if variable-length value does not terminate
+     *                                  after 5 bytes have been read
+     * @throws IOException              if {@link DataInput} throws {@link IOException}
+     * @see #readUnsignedVarLong(DataInput)
+     */
+    public static int readUnsignedVarInt(DataInput in) throws IOException {
+        int value = 0;
+        int i = 0;
+        int b;
+        while (((b = in.readByte()) & 0x80) != 0) {
+            value |= (b & 0x7F) << i;
+            i += 7;
+        }
+        return value | (b << i);
+    }
+}

data/ext/ruby_protobuf/Varinter.java

@@ -2,13 +2,17 @@ package com.abrandoned.protobuf_java_helpers;
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.OutputStream;;
+import java.io.DataOutput;
+import java.io.DataInput;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
 import java.io.ByteArrayOutputStream;
 import java.lang.Math;
-import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.function.Function;
+import java.math.BigInteger;
 import org.jcodings.specific.ASCIIEncoding;
 import org.jruby.Ruby;
+import org.jruby.RubyArray;
 import org.jruby.RubyBignum;
 import org.jruby.RubyComplex;
 import org.jruby.RubyFixnum;
@@ -17,104 +21,27 @@ import org.jruby.RubyInteger;
 import org.jruby.RubyNumeric;
 import org.jruby.RubyString;
 import org.jruby.RubyIO;
-import org.jruby.ext.stringio.StringIO;
+import org.jruby.util.IOInputStream;
 import org.jruby.util.ByteList;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
 public class Varinter {
-  private static final long INT32_MAX = ((long)java.lang.Math.pow(2, 31) - 1);
-
-  private static byte[] internal_to_varint(long value) {
-    java.io.ByteArrayOutputStream bytes = new java.io.ByteArrayOutputStream();
-
-    while (value > 0x7f) {
-      bytes.write((byte) (0x80 | (value & 0x7f)));
-      value >>= 7;
-    }
-
-    bytes.write((byte) value);
-    return bytes.toByteArray();
-  }
-
-  @JRubyMethod(name = "acceptable?")
-  public static IRubyObject acceptable_p( ThreadContext context, IRubyObject self, IRubyObject recv ) {
-    org.jruby.Ruby runtime = context.getRuntime();
-
-    if (recv instanceof RubyInteger || recv instanceof RubyFixnum) {
-      long value = ((RubyFixnum) recv).getLongValue();
-
-      if (value >= 0 && value <= INT32_MAX) {
-        return runtime.getTrue();
-      } else {
-        return runtime.getFalse();
-      }
-    }
-
-    return runtime.getFalse();
-  }
-
   @JRubyMethod
-  public static IRubyObject to_varint( ThreadContext context, IRubyObject self, IRubyObject recv ) {
-    if (!(recv instanceof RubyInteger || recv instanceof RubyFixnum)) {
+  public static IRubyObject to_varint( ThreadContext context, IRubyObject self, IRubyObject recv ) throws IOException {
+    if (recv instanceof RubyBignum || !(recv instanceof RubyInteger || recv instanceof RubyFixnum || recv instanceof RubyNumeric || recv instanceof RubyFloat)) {
       return context.nil;
     }
 
-    long value = ((RubyFixnum) recv).getLongValue();
+    long value = ((RubyNumeric) recv).getLongValue();
     org.jruby.Ruby runtime = context.getRuntime();
-    RubyString bit_string = runtime.newString(new ByteList(internal_to_varint(value), true));
-    bit_string.force_encoding(context, runtime.getEncodingService().getEncoding(org.jcodings.specific.ASCIIEncoding.INSTANCE));
-    return bit_string;
-  }
+    ByteArrayOutputStream backing = new ByteArrayOutputStream();
+    DataOutput data_output = new DataOutputStream(backing);
+    com.abrandoned.protobuf_java_helpers.Varint.writeUnsignedVarLong2(value, data_output);
 
-  @JRubyMethod
-  public static IRubyObject to_varint_64( ThreadContext context, IRubyObject self, IRubyObject recv ) {
-    if (!(recv instanceof RubyInteger || recv instanceof RubyFixnum)) {
-      return context.nil;
-    }
-
-    long value = ((RubyFixnum) recv).getLongValue();
-    org.jruby.Ruby runtime = context.getRuntime();
-    RubyString bit_string = runtime.newString(new ByteList(internal_to_varint(value & 0xffffffffffffffffL), true));
+    RubyString bit_string = runtime.newString(new ByteList(backing.toByteArray(), true));
     bit_string.force_encoding(context, runtime.getEncodingService().getEncoding(org.jcodings.specific.ASCIIEncoding.INSTANCE));
     return bit_string;
   }
-
-  @JRubyMethod
-  public static IRubyObject read_varint(ThreadContext context, IRubyObject self, IRubyObject recv ) throws IOException {
-    long value = 0L;
-    int index = 0;
-    long current_byte;
-
-    if (recv instanceof StringIO) {
-      StringIO current_recv = ((StringIO)recv);
-      RubyFixnum fixnum;
-
-      do {
-        fixnum = ((RubyFixnum)(current_recv.getbyte(context)));
-        current_byte = fixnum.getLongValue();
-        if (index == 0 && current_byte < 128) { return context.getRuntime().newFixnum(current_byte); }
-        value = (value | ((current_byte & 0x7f) << (7 * index)));
-        index++;
-      } while ((current_byte & 0x80) != 0);
-
-      return context.getRuntime().newFixnum(value);
-    }
-
-    if (recv instanceof RubyIO) {
-      RubyIO current_recv = ((RubyIO)recv);
-
-      do {
-        current_byte = current_recv.getByte(context);
-        if (index == 0 && current_byte < 128) { return context.getRuntime().newFixnum(current_byte); }
-        value = (value | ((current_byte & 0x7f) << (7 * index)));
-        index++;
-      } while ((current_byte & 0x80) != 0);
-
-      return context.getRuntime().newFixnum(value);
-    }
-
-    return context.nil;
-  }
 }

data/ext/ruby_protobuf/VarinterService.java

@@ -15,6 +15,9 @@ public class VarinterService implements BasicLibraryService {
         RubyModule varinter = protobuf_java_helpers.defineModuleUnder(Varinter.class.getSimpleName());
         varinter.defineAnnotatedMethods(Varinter.class);
 
+        RubyModule integer_protobuf = protobuf_java_helpers.defineModuleUnder(IntegerProtobufField.class.getSimpleName());
+        integer_protobuf.defineAnnotatedMethods(IntegerProtobufField.class);
+
         RubyModule uint64_protobuf = protobuf_java_helpers.defineModuleUnder(Uint64ProtobufField.class.getSimpleName());
         uint64_protobuf.defineAnnotatedMethods(Uint64ProtobufField.class);
 

data/lib/protobuf_java_helpers.rb

@@ -3,8 +3,36 @@ require "jruby"
 require "protobuf_java_helpers/version"
 
 module ProtobufJavaHelpers
-  # Your code goes here...
 end
 
 require "jars/protobuf_java_helpers.jar"
 com.abrandoned.protobuf_java_helpers.VarinterService.new.basicLoad(::JRuby.runtime)
+
+module ProtobufJavaHelpers
+  module EncodeDecode
+    include ::ProtobufJavaHelpers::Varinter
+
+    def pure_encode(value)
+      bytes = []
+      until value < 128
+        bytes << (0x80 | (value & 0x7f))
+        value >>= 7
+      end
+      (bytes << value).pack('C*')
+    end
+
+    def encode(value)
+      to_varint(value) || pure_encode(value)
+    end
+
+    def decode(stream)
+      value = index = 0
+      begin
+        byte = stream.readbyte
+        value |= (byte & 0x7f) << (7 * index)
+        index += 1
+      end while (byte & 0x80).nonzero?
+      value
+    end
+  end
+end

data/lib/protobuf_java_helpers/version.rb

@@ -1,3 +1,3 @@
 module ProtobufJavaHelpers
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/protobuf_java_helpers.gemspec

@@ -33,6 +33,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_development_dependency "benchmark-ips"
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: protobuf_java_helpers
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: java
 authors:
 - Brandon Dewitt
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2018-11-05 00:00:00.000000000 Z
+date: 2019-01-15 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: benchmark-ips
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -84,10 +98,12 @@ files:
 - bin/setup
 - ext/ruby_protobuf/Int32ProtobufField.java
 - ext/ruby_protobuf/Int64ProtobufField.java
+- ext/ruby_protobuf/IntegerProtobufField.java
 - ext/ruby_protobuf/Sint32ProtobufField.java
 - ext/ruby_protobuf/Sint64ProtobufField.java
 - ext/ruby_protobuf/Uint32ProtobufField.java
 - ext/ruby_protobuf/Uint64ProtobufField.java
+- ext/ruby_protobuf/Varint.java
 - ext/ruby_protobuf/VarintProtobufField.java
 - ext/ruby_protobuf/Varinter.java
 - ext/ruby_protobuf/VarinterService.java