How to use org.jruby

public static void createRubyDescriptor(Ruby runtime) {
  RubyModule protobuf = runtime.getClassFromPath("Google::Protobuf");
  RubyClass cDescriptor = protobuf.defineClassUnder("Descriptor", runtime.getObject(), new ObjectAllocator() {
    @Override
    public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
      return new RubyDescriptor(runtime, klazz);
    }
  });
  cDescriptor.includeModule(runtime.getEnumerable());
  cDescriptor.defineAnnotatedMethods(RubyDescriptor.class);
}

public static void createRubyFileDescriptor(Ruby runtime) {
  RubyModule mProtobuf = runtime.getClassFromPath("Google::Protobuf");
  RubyClass cFieldDescriptor = mProtobuf.defineClassUnder("FieldDescriptor", runtime.getObject(), new ObjectAllocator() {
    @Override
    public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
      return new RubyFieldDescriptor(runtime, klazz);
    }
  });
  cFieldDescriptor.defineAnnotatedMethods(RubyFieldDescriptor.class);
}

public static void createRubyDescriptorPool(Ruby runtime) {
  RubyModule protobuf = runtime.getClassFromPath("Google::Protobuf");
  RubyClass cDescriptorPool = protobuf.defineClassUnder("DescriptorPool", runtime.getObject(), new ObjectAllocator() {
    @Override
    public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
      return new RubyDescriptorPool(runtime, klazz);
    }
  });
  cDescriptorPool.defineAnnotatedMethods(RubyDescriptorPool.class);
  descriptorPool = (RubyDescriptorPool) cDescriptorPool.newInstance(runtime.getCurrentContext(), Block.NULL_BLOCK);
}

public static void createProtobuf(Ruby runtime) {
  RubyModule mGoogle = runtime.getModule("Google");
  RubyModule mProtobuf = mGoogle.defineModuleUnder("Protobuf");
  mProtobuf.defineAnnotatedMethods(RubyProtobuf.class);
}

@JRubyMethod
public IRubyObject hash(ThreadContext context) {
  int hashCode = this.storage.hashCode();
  return context.runtime.newFixnum(hashCode);
}

public static int num2uint(IRubyObject value) {
  long longVal = RubyNumeric.num2long(value);
  if (longVal > UINT_MAX)
    throw value.getRuntime().newRangeError("Integer " + longVal + " too big to convert to 'unsigned int'");
  long num = longVal;
  if (num > Integer.MAX_VALUE || num < Integer.MIN_VALUE)
    // encode to UINT32
    num = (-longVal ^ (-1l >>> 32) ) + 1;
  RubyNumeric.checkInt(value, num);
  return (int) num;
}

public static void checkNameAvailability(ThreadContext context, String name) {
  if (context.runtime.getObject().getConstantAt(name) != null)
    throw context.runtime.newNameError(name + " is already defined", name);
}

public static long num2ulong(Ruby runtime, IRubyObject value) {
  if (value instanceof RubyFloat) {
    RubyBignum bignum = RubyBignum.newBignum(runtime, ((RubyFloat) value).getDoubleValue());
    return RubyBignum.big2ulong(bignum);
  } else if (value instanceof RubyBignum) {
    return RubyBignum.big2ulong((RubyBignum) value);
  } else {
    return RubyNumeric.num2long(value);
  }
}

private int normalizeArrayIndex(IRubyObject index) {
  int arrIndex = RubyNumeric.num2int(index);
  int arrSize = this.storage.size();
  if (arrIndex < 0 && arrSize > 0) {
    arrIndex = arrSize + arrIndex;
  }
  return arrIndex;
}

public RubyRepeatedField(Ruby runtime, RubyClass klazz, Descriptors.FieldDescriptor.Type fieldType, IRubyObject typeClass) {
  this(runtime, klazz);
  this.fieldType = fieldType;
  this.storage = runtime.newArray();
  this.typeClass = typeClass;
}

private void checkRepeatedFieldType(ThreadContext context, IRubyObject value,
                  Descriptors.FieldDescriptor fieldDescriptor) {
  Ruby runtime = context.runtime;
  if (!(value instanceof RubyRepeatedField)) {
    throw runtime.newTypeError("Expected repeated field array");
  }
}

public RubyBuilder(Ruby runtime, RubyClass metaClass) {
  super(runtime, metaClass);
  this.cDescriptor = (RubyClass) runtime.getClassFromPath("Google::Protobuf::Descriptor");
  this.cEnumDescriptor = (RubyClass) runtime.getClassFromPath("Google::Protobuf::EnumDescriptor");
  this.cMessageBuilderContext = (RubyClass) runtime.getClassFromPath("Google::Protobuf::MessageBuilderContext");
  this.cEnumBuilderContext = (RubyClass) runtime.getClassFromPath("Google::Protobuf::EnumBuilderContext");
}

public static void createRubyEnumDescriptor(Ruby runtime) {
  RubyModule mProtobuf = runtime.getClassFromPath("Google::Protobuf");
  RubyClass cEnumDescriptor = mProtobuf.defineClassUnder("EnumDescriptor", runtime.getObject(), new ObjectAllocator() {
    @Override
    public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
      return new RubyEnumDescriptor(runtime, klazz);
    }
  });
  cEnumDescriptor.includeModule(runtime.getEnumerable());
  cEnumDescriptor.defineAnnotatedMethods(RubyEnumDescriptor.class);
}

public static void createRubyEnumBuilderContext(Ruby runtime) {
  RubyModule protobuf = runtime.getClassFromPath("Google::Protobuf");
  RubyClass cMessageBuilderContext = protobuf.defineClassUnder("EnumBuilderContext", runtime.getObject(), new ObjectAllocator() {
    @Override
    public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
      return new RubyEnumBuilderContext(runtime, klazz);
    }
  });
  cMessageBuilderContext.defineAnnotatedMethods(RubyEnumBuilderContext.class);
}

public static void createRubyRepeatedField(Ruby runtime) {
  RubyModule mProtobuf = runtime.getClassFromPath("Google::Protobuf");
  RubyClass cRepeatedField = mProtobuf.defineClassUnder("RepeatedField", runtime.getObject(),
      new ObjectAllocator() {
        @Override
        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
          return new RubyRepeatedField(runtime, klazz);
        }
      });
  cRepeatedField.defineAnnotatedMethods(RubyRepeatedField.class);
  cRepeatedField.includeModule(runtime.getEnumerable());
}

public static void createRubyMessageBuilderContext(Ruby runtime) {
  RubyModule protobuf = runtime.getClassFromPath("Google::Protobuf");
  RubyClass cMessageBuilderContext = protobuf.defineClassUnder("MessageBuilderContext", runtime.getObject(), new ObjectAllocator() {
    @Override
    public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
      return new RubyMessageBuilderContext(runtime, klazz);
    }
  });
  cMessageBuilderContext.defineAnnotatedMethods(RubyMessageBuilderContext.class);
}

public static void createRubyMap(Ruby runtime) {
  RubyModule protobuf = runtime.getClassFromPath("Google::Protobuf");
  RubyClass cMap = protobuf.defineClassUnder("Map", runtime.getObject(), new ObjectAllocator() {
    @Override
    public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) {
      return new RubyMap(ruby, rubyClass);
    }
  });
  cMap.includeModule(runtime.getEnumerable());
  cMap.defineAnnotatedMethods(RubyMap.class);
}

public static void createRubyOneofBuilderContext(Ruby runtime) {
  RubyModule protobuf = runtime.getClassFromPath("Google::Protobuf");
  RubyModule internal = protobuf.defineModuleUnder("Internal");
  RubyClass cRubyOneofBuidlerContext = internal.defineClassUnder("OneofBuilderContext", runtime.getObject(), new ObjectAllocator() {
    @Override
    public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) {
      return new RubyOneofBuilderContext(ruby, rubyClass);
    }
  });
  cRubyOneofBuidlerContext.defineAnnotatedMethods(RubyOneofBuilderContext.class);
}

public static void createRubyOneofDescriptor(Ruby runtime) {
  RubyModule protobuf = runtime.getClassFromPath("Google::Protobuf");
  RubyClass cRubyOneofDescriptor = protobuf.defineClassUnder("OneofDescriptor", runtime.getObject(), new ObjectAllocator() {
    @Override
    public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) {
      return new RubyOneofDescriptor(ruby, rubyClass);
    }
  });
  cRubyOneofDescriptor.defineAnnotatedMethods(RubyOneofDescriptor.class);
  cRubyOneofDescriptor.includeModule(runtime.getEnumerable());
}

public static void createRubyBuilder(Ruby runtime) {
  RubyModule protobuf = runtime.getClassFromPath("Google::Protobuf");
  RubyClass cBuilder = protobuf.defineClassUnder("Builder", runtime.getObject(), new ObjectAllocator() {
    @Override
    public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
      return new RubyBuilder(runtime, klazz);
    }
  });
  cBuilder.defineAnnotatedMethods(RubyBuilder.class);
}