rjb 1.3.0-universal-darwin-10

data/ext/rjb.h

@@ -0,0 +1,163 @@
+/*
+ * Rjb - Ruby <-> Java Bridge
+ * Copyright(c) 2004,2005 arton
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * $Id: rjb.h 139 2010-09-21 17:32:57Z arton $
+ * $Log: rjb.h,v $
+ * Revision 1.1  2005/01/16 17:36:10  arton
+ * Initial revision
+ *
+ *
+ */
+
+#ifndef RJB_H
+#define RJB_H
+
+#if RJB_RUBY_VERSION_CODE < 190
+#if !defined(RHASH_TBL)
+#define RHASH_TBL(x) RHASH((x))->tbl
+#endif
+#endif
+
+#if !defined(RSTRING_LEN)
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+#if !defined(RSTRING_PTR)
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+#if !defined(RARRAY_LEN)
+#define RARRAY_LEN(s) (RARRAY(s)->len)
+#endif
+#if !defined(RARRAY_PTR)
+#define RARRAY_PTR(s) (RARRAY(s)->ptr)
+#endif
+
+#if !defined(COUNTOF)
+#define COUNTOF(x) (sizeof(x)/sizeof(x[0]))
+#endif
+
+#if !defined(_I64_MIN)
+#define _I64_MIN    (-9223372036854775807i64 - 1)
+#endif
+#if !defined(_I64_MAX)
+#define _I64_MAX      9223372036854775807i64
+#endif
+
+#if !defined(HAVE_LONG_LONG) && defined(__LP64__)
+#define HAVE_LONG_LONG 1
+#endif
+
+/* in load.c */
+extern int rjb_create_jvm(JNIEnv** pjenv, JavaVMInitArgs*, char*, VALUE);
+
+/* in rjb.c */
+extern JavaVM* rjb_jvm;
+extern jclass rjb_rbridge;
+extern jmethodID rjb_register_bridge;
+extern VALUE rjb_loaded_classes;
+extern jmethodID rjb_class_getName;
+extern jclass rjb_j_throwable;
+extern jmethodID rjb_throwable_getMessage;
+extern JNIEnv* rjb_attach_current_thread(void);
+extern jclass rjb_find_class(JNIEnv* jenv, VALUE name);
+extern void rjb_release_string(JNIEnv *jenv, jstring str, const char* chrs);
+extern VALUE rjb_load_vm_default();
+extern VALUE rjb_safe_funcall(VALUE args);
+extern VALUE jv2rv(JNIEnv* jenv, jvalue val);
+extern jobject get_systemloader(JNIEnv* jenv);
+extern jclass rjb_find_class_by_name(JNIEnv* jenv, const char* name);
+
+/* in rjbexception.c */
+extern VALUE rjb_get_exception_class(JNIEnv* jenv, jstring str);
+extern void rjb_check_exception(JNIEnv* jenv, int t);
+extern VALUE rjb_s_throw(int, VALUE*, VALUE);
+
+/* conversion functions */
+typedef void (*R2J)(JNIEnv*, VALUE, jvalue*, const char*, int);
+typedef VALUE (*J2R)(JNIEnv*, jvalue);
+typedef jarray (*R2JARRAY)(JNIEnv*, VALUE, const char*);
+typedef void (JNICALL *RELEASEARRAY)(JNIEnv*, jobject, void*, jint);
+typedef jlong (JNICALL *INVOKEAL)(JNIEnv*, jobject, jmethodID, const jvalue*);
+typedef jdouble (JNICALL *INVOKEAD)(JNIEnv*, jobject, jmethodID, const jvalue*);
+typedef jfloat (JNICALL *INVOKEAF)(JNIEnv*, jobject, jmethodID, const jvalue*);
+typedef jboolean (JNICALL *INVOKEAZ)(JNIEnv*, jobject, jmethodID, const jvalue*);
+typedef jshort (JNICALL *INVOKEAS)(JNIEnv*, jobject, jmethodID, const jvalue*);
+typedef jobject (JNICALL *INVOKEA)(JNIEnv*, jobject, jmethodID, const jvalue*);
+typedef VALUE (*CONV)(JNIEnv*, void*);
+
+/*
+ * internal method class
+ */
+struct cls_constructor {
+    jmethodID id;
+    int arg_count;
+    R2J* arg_convert;
+    char* method_signature;
+    char  result_signature;
+    char  result_arraydepth;
+};
+
+struct cls_method {
+    struct cls_constructor basic;
+    ID name;
+    int static_method;
+    off_t method;
+    J2R result_convert;
+    /* overload only */
+    struct cls_method* next;
+};
+
+/*
+ * internal field class
+ */
+struct cls_field {
+    ID name;
+    jfieldID id;
+    char* field_signature;
+    char  result_signature;
+    char  result_arraydepth;
+    R2J arg_convert;
+    J2R value_convert;
+    int readonly;
+    int static_field;
+};
+
+/*
+ * Object instance
+ */
+struct jvi_data {
+    jclass klass; /* class */
+    jobject obj; /* instance */
+    st_table* methods;
+    st_table* fields;
+};
+
+/*
+ * Class instance
+ */
+struct jv_data {
+    struct jvi_data idata;
+    st_table* static_methods;
+    struct cls_constructor** constructors;
+};
+
+/*
+ * Bridge instance
+ */
+struct rj_bridge {
+    jobject bridge;
+    jobject proxy;
+    VALUE wrapped;
+};
+
+#endif

data/ext/rjbexception.c

@@ -0,0 +1,160 @@
+/*
+ * Rjb - Ruby <-> Java Bridge
+ * Copyright(c) 2004,2005,2006,2010 arton
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * $Id: rjbexception.c 126 2010-07-22 13:58:15Z arton $
+ */
+
+#include "ruby.h"
+#include "extconf.h"
+#if RJB_RUBY_VERSION_CODE < 190
+#include "st.h"
+#else
+#include "ruby/st.h"
+#endif
+#include "jniwrap.h"
+#include "riconv.h"
+#include "rjb.h"
+
+static VALUE missing_delegate(int argc, VALUE* argv, VALUE self)
+{
+    ID rmid = rb_to_id(argv[0]);
+    return rb_funcall(rb_ivar_get(self, rb_intern("@cause")), rmid, argc - 1, argv + 1);
+}
+
+/*
+ * handle Java exception
+ *  At this time, the Java exception is defined without the package name.
+ *  This design may change in future release.
+ */
+VALUE rjb_get_exception_class(JNIEnv* jenv, jstring str)
+{
+    VALUE rexp;
+    char* pcls;
+    VALUE cname;
+    const char* p = (*jenv)->GetStringUTFChars(jenv, str, JNI_FALSE);
+    char* clsname = ALLOCA_N(char, strlen(p) + 1);
+    strcpy(clsname, p);
+    rjb_release_string(jenv, str, p);
+    pcls = strrchr(clsname, '.');
+    if (pcls)
+    {
+	pcls++;
+    }
+    else
+    {
+	pcls = clsname;
+    }
+    cname = rb_str_new2(pcls);
+    rexp = rb_hash_aref(rjb_loaded_classes, cname);
+    if (rexp == Qnil)
+    {
+	rexp = rb_define_class(pcls, rb_eStandardError);
+        rb_define_method(rexp, "method_missing", missing_delegate, -1);
+#if defined(HAVE_RB_HASH_ASET) || defined(RUBINIUS)
+	rb_hash_aset(rjb_loaded_classes, cname, rexp);
+#else
+#ifdef RHASH_TBL
+    st_insert(RHASH_TBL(rjb_loaded_classes), cname, rexp);
+#else
+    st_insert(RHASH(rjb_loaded_classes)->tbl, cname, rexp);
+#endif
+#endif
+	
+    }
+    return rexp;
+}
+
+/*
+ * throw newly created exception with supplied message.
+ */
+VALUE rjb_s_throw(int argc, VALUE* argv, VALUE self)
+{
+    VALUE klass;
+    VALUE message;
+    JNIEnv* jenv = NULL; 
+
+    rjb_load_vm_default();
+
+    jenv = rjb_attach_current_thread();
+    (*jenv)->ExceptionClear(jenv);
+
+    if (rb_scan_args(argc, argv, "11", &klass, &message) == 2)
+    {
+        jclass excep = rjb_find_class(jenv, klass);
+	if (excep == NULL)
+	{
+	    rb_raise(rb_eRuntimeError, "`%s' not found", StringValueCStr(klass));
+        }
+	(*jenv)->ThrowNew(jenv, excep, StringValueCStr(message));
+    }
+    else
+    {
+        struct jvi_data* ptr;
+	Data_Get_Struct(klass, struct jvi_data, ptr);
+	if (!(*jenv)->IsInstanceOf(jenv, ptr->obj, rjb_j_throwable))
+	{
+	    rb_raise(rb_eRuntimeError, "arg1 must be a throwable");
+	}
+	else
+	{
+  	    (*jenv)->Throw(jenv, ptr->obj);
+	}
+    }
+    return Qnil;
+}
+
+void rjb_check_exception(JNIEnv* jenv, int t)
+{
+    jthrowable exp = (*jenv)->ExceptionOccurred(jenv);
+    if (exp)
+    {
+	VALUE rexp = Qnil;
+        if (RTEST(ruby_verbose))
+	{
+	    (*jenv)->ExceptionDescribe(jenv);
+	}
+	(*jenv)->ExceptionClear(jenv);
+        if(1)
+	{
+ 	    char* msg = "unknown exception";
+	    jclass cls = (*jenv)->GetObjectClass(jenv, exp);
+ 	    jstring str = (*jenv)->CallObjectMethod(jenv, exp, rjb_throwable_getMessage);
+	    if (str)
+	    {
+	        const char* p = (*jenv)->GetStringUTFChars(jenv, str, JNI_FALSE);
+		msg = ALLOCA_N(char, strlen(p) + 1);
+		strcpy(msg, p);
+		rjb_release_string(jenv, str, p);
+	    }
+	    str = (*jenv)->CallObjectMethod(jenv, cls, rjb_class_getName);
+	    if (str)
+	    {
+		rexp = rjb_get_exception_class(jenv, str);
+	    }
+	    if (rexp == Qnil)
+	    {
+                (*jenv)->DeleteLocalRef(jenv, exp);
+		rb_raise(rb_eRuntimeError, "%s", msg);
+	    }
+	    else
+	    {
+                VALUE rexpi = rb_funcall(rexp, rb_intern("new"), 1, rb_str_new2(msg));
+                jvalue val;
+                val.l = exp;
+                rb_ivar_set(rexpi, rb_intern("@cause"), jv2rv(jenv, val));
+                rb_exc_raise(rexpi);
+	    }
+        }
+    }
+}

data/lib/rjb.rb

@@ -0,0 +1,98 @@
+=begin
+  Copyright(c) 2006-2010 arton
+=end
+
+require 'rbconfig'
+
+module RjbConf
+  dir = File.join(File.dirname(File.dirname(__FILE__)), 'data')
+  if File.exist?(dir)
+    datadir = dir
+  else
+    datadir = RbConfig::CONFIG['datadir']
+  end
+  BRIDGE_FILE = File.join(datadir, 'rjb', 'jp', 'co', 'infoseek', 'hp',
+                          'arton', 'rjb', 'RBridge.class')
+  unless File.exist?(BRIDGE_FILE)
+    raise 'bridge file not found'
+  end
+end
+
+require 'rjbcore'
+
+module Rjb
+  module MODIFIER
+    def self.STATIC
+      8
+    end
+    def self.PUBLIC
+      1
+    end
+  end
+
+  module JMethod
+    def instance_method?(m)
+      m.modifiers & MODIFIER.STATIC == 0
+    end
+    def public_method?(m)
+      (m.modifiers & MODIFIER.PUBLIC) == MODIFIER.PUBLIC
+    end
+    def jmethods(org, klass, &blk)
+      (org + klass.getMethods.select do |m|
+         blk.call(m)
+      end.map do |m|
+        m.name
+      end).uniq
+    end
+    def format_sigs(s)
+      if s.size < 0
+        ''
+      elsif s.size == 1
+        s[0]
+      else
+        "[#{s.map{|m|m.nil? ? 'void' : m}.join(', ')}]"
+      end
+    end
+  end
+
+  class Rjb_JavaClass
+    include JMethod
+    def public_methods(inh = true)
+      jmethods(super(inh), self) do |m|
+        !instance_method?(m) && public_method?(m)
+      end
+    end
+    def methods(inh = true)
+      jmethods(super(inh), self) do |m|
+        !instance_method?(m) && public_method?(m)
+      end
+    end
+    def java_methods
+      jmethods([], self) do |m|
+        !instance_method?(m) && public_method?(m)
+      end.map do |m|
+        "#{m}(#{format_sigs(self.static_sigs(m))})"
+      end
+    end
+  end
+  class Rjb_JavaProxy
+    include JMethod
+    def public_methods(inh = true)
+      jmethods(super(inh), getClass) do |m|
+        instance_method?(m) && public_method?(m)
+      end
+    end
+    def methods(inh = true)
+      jmethods(super(inh), getClass) do |m|
+        instance_method?(m) && public_method?(m)
+      end
+    end
+    def java_methods
+      jmethods([], getClass) do |m|
+        instance_method?(m) && public_method?(m)
+      end.map do |m|
+        "#{m}(#{format_sigs(getClass.sigs(m))})"
+      end
+    end
+  end
+end

data/lib/rjbextension.rb

@@ -0,0 +1,128 @@
+=begin
+Copyright(c) 2010 arton
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
+
+$Id: rjbextension.rb 147 2010-10-23 05:10:33Z arton $
+
+ This file is from Andreas Ronge project neo4j
+   http://github.com/andreasronge/neo4j/blob/rjb/lib/rjb_ext.rb
+
+Copyright (c) 2008 Andreas Ronge
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+=end
+
+# Loads the JVM with the given <tt>classpath</tt> and arguments to the jre.
+# All needed .jars should be included in <tt>classpath</tt>.
+
+module Kernel
+  alias rjb_original_require require
+
+  def require(path)
+    rjb_original_require(path)
+  rescue LoadError
+    # check that it's not a jar file
+    raise unless path =~ /\.jar/
+
+    # This will maybe use the wrong jar file from a previous version of the GEM
+    # puts "LOAD PATH #{$LOAD_PATH}" 
+    found_path = $LOAD_PATH.reverse.find{|p| File.exist?(File.join(p,path))}
+    raise unless found_path
+
+    abs_path = File.join(found_path, path)
+    # check that the file exists
+    raise unless  File.exist?(abs_path)
+
+    # try to load it using RJB
+    if Rjb::loaded?
+      Rjb::add_jar abs_path
+    else
+      Rjb::add_classpath abs_path
+    end
+  end
+
+  def load_jvm(jargs = [])
+    return if Rjb::loaded?
+    classpath = ENV['CLASSPATH'] ||= ''
+    Rjb::load(classpath, jargs)
+  end
+end
+
+class JavaPackage
+
+  def initialize(pack_name, parent_pack = nil)
+    @pack_name = pack_name
+    @parent_pack = parent_pack
+    @cache = {}
+  end
+
+  def method_missing(m, *args)
+    # return if possible old module/class
+    @cache[m] ||= create_package_or_class(m)
+  end
+  def create_package_or_class(m)
+    method = m.to_s
+    if class?(method)
+      Rjb::import("#{self}.#{method}")
+    else
+      JavaPackage.new(method, self)
+    end
+  end
+
+  def to_s
+    if @parent_pack
+      "#{@parent_pack.to_s}.#@pack_name"
+    else
+      "#@pack_name"
+    end
+  end
+
+  def class?(a)
+    first_letter = a[0,1]
+    first_letter >= 'A' && first_letter <= 'Z'
+  end
+
+  @@cache = {}
+  def self.new(pack_name, parent_pack = nil)
+    @@cache[pack_name] ||= super
+  end
+end
+
+module RjbConf
+  # make them as singleton
+  ORG = JavaPackage.new('org')
+  JAVA = JavaPackage.new('java')
+end
+
+def org
+  RjbConf::ORG
+end
+
+def java
+  RjbConf::JAVA
+end