jruby-win32ole 0.8.0

data/src/org/jruby/ext/win32ole/RubyInvocationProxy.java

@@ -0,0 +1,34 @@
+package org.jruby.ext.win32ole;
+
+import org.racob.com.InvocationProxy;
+import org.racob.com.Variant;
+import org.jruby.Ruby;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ */
+public class RubyInvocationProxy extends InvocationProxy {
+    private final Ruby runtime;
+    private final IRubyObject target;
+    
+    public RubyInvocationProxy(IRubyObject target) {
+        this.target = target;
+        this.runtime = target.getRuntime();
+    }
+
+    @Override
+    public Variant invoke(String methodName, Variant[] variantArgs) {
+        ThreadContext context = runtime.getCurrentContext();
+
+        int length = variantArgs.length;
+        IRubyObject[] args = new IRubyObject[length];
+        for (int i = 0; i < length; i++) {
+            args[i] = RubyWIN32OLE.fromVariant(runtime, variantArgs[i]);
+        }
+
+        target.callMethod(context, methodName, args);
+        return null;
+    }
+
+}

data/src/org/jruby/ext/win32ole/RubyWIN32OLE.java

@@ -0,0 +1,278 @@
+package org.jruby.ext.win32ole;
+
+import org.racob.com.Dispatch;
+import org.racob.com.EnumVariant;
+import org.racob.com.Variant;
+import java.util.Calendar;
+import java.util.Date;
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyInteger;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import win32ole.Win32oleService;
+
+/**
+ */
+public class RubyWIN32OLE extends RubyObject {
+    private static final Object[] EMPTY_OBJECT_ARGS = new Object[0];
+    private static final int[] EMPTY_ERROR_ARGS = new int[0];
+    
+    public static ObjectAllocator WIN32OLE_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new RubyWIN32OLE(runtime, klass);
+        }
+    };
+    
+    public Dispatch dispatch = null;
+
+    public RubyWIN32OLE(Ruby runtime, RubyClass metaClass) {
+        super(runtime, metaClass);
+    }
+
+    private RubyWIN32OLE(Ruby runtime, RubyClass metaClass, Dispatch dispatch) {
+        this(runtime, metaClass);
+
+        this.dispatch = dispatch;
+    }
+
+    public Dispatch getDispatch() {
+        return dispatch;
+    }
+
+    // Accessor for Ruby side of win32ole to get ahold of this object
+    @JRubyMethod()
+    public IRubyObject dispatch(ThreadContext context) {
+        return JavaUtil.convertJavaToUsableRubyObject(context.getRuntime(), dispatch);
+    }
+
+    @JRubyMethod()
+    public IRubyObject each(ThreadContext context, Block block) {
+        Ruby runtime = context.getRuntime();
+        EnumVariant enumVariant = dispatch.toEnumVariant();
+
+        // FIXME: when no block is passed handling
+        
+        while (enumVariant.hasMoreElements()) {
+            Variant value = enumVariant.nextElement();
+            block.yield(context, fromVariant(runtime, value));
+        }
+
+        return runtime.getNil();
+    }
+
+    @JRubyMethod(required = 3)
+    public IRubyObject _getproperty(ThreadContext context, IRubyObject dispid,
+            IRubyObject args, IRubyObject argTypes) {
+        RubyArray argsArray = args.convertToArray();
+        Object[] objectArgs = makeObjectArgs(argsArray);
+        int dispatchId = (int) RubyInteger.num2long(dispid);
+        
+        if (objectArgs.length == 0) {
+            return fromObject(context.getRuntime(), Dispatch.callO(dispatch, dispatchId));
+        } 
+
+        return fromVariant(context.getRuntime(),
+                Dispatch.call(dispatch, dispatchId, objectArgs));
+    }
+
+    @JRubyMethod(required = 1, rest = true)
+    public IRubyObject initialize(ThreadContext context, IRubyObject[] args) {
+        String id = args[0].convertToString().asJavaString();
+
+        dispatch = new Dispatch(toProgID(id));
+
+        return this;
+    }
+
+    @JRubyMethod(required = 1, rest = true)
+    public IRubyObject invoke(ThreadContext context, IRubyObject[] args) {
+        return method_missing(context, args);
+    }
+    
+    @JRubyMethod()
+    public IRubyObject _invoke(ThreadContext context, IRubyObject dispid,
+            IRubyObject args, IRubyObject typesArray) {
+        return invokeInternal(context, dispid, args, args, Dispatch.Method);
+    }
+
+    @JRubyMethod(required = 1, rest = true)
+    public IRubyObject method_missing(ThreadContext context, IRubyObject[] args) {
+        String methodName = args[0].asJavaString();
+        
+        if (methodName.endsWith("=")) return invokeSet(context, 
+                methodName.substring(0, methodName.length() - 1), args);
+
+        return invokeMethodOrGet(context, methodName, args);
+    }
+
+    @JRubyMethod()
+    public IRubyObject ole_free(ThreadContext context) {
+        dispatch.safeRelease();
+
+        return context.getRuntime().getNil();
+    }
+
+    @JRubyMethod(name = "[]", required = 1)
+    public IRubyObject op_aref(ThreadContext context, IRubyObject property) {
+        String propertyName = property.asJavaString();
+        
+        return fromVariant(context.getRuntime(), Dispatch.get(dispatch, propertyName));
+    }
+
+    @JRubyMethod(name = "[]=", required = 2)
+    public IRubyObject op_aset(ThreadContext context, IRubyObject property, IRubyObject value) {
+        String propertyName = property.asJavaString();
+
+        Dispatch.put(dispatch, propertyName, toObject(value));
+        return context.getRuntime().getNil();
+    }
+
+    @JRubyMethod()
+    public IRubyObject _setproperty(ThreadContext context, IRubyObject dispid,
+            IRubyObject args, IRubyObject argTypes) {
+        return invokeInternal(context, dispid, args, argTypes, Dispatch.Put);
+    }
+
+    @JRubyMethod(required = 1, rest = true)
+    public IRubyObject setproperty(ThreadContext context, IRubyObject[] args) {
+        String methodName = args[0].asJavaString();
+        
+        return invokeSet(context, methodName, args);
+    }
+
+    private IRubyObject invokeSet(ThreadContext context, String methodName, IRubyObject[] args) {
+        Object[] objectArgs = makeObjectArgs(args, 1);
+        int[] errorArgs = new int[objectArgs.length];
+
+        Dispatch.invoke(dispatch, methodName, Dispatch.Put, objectArgs, errorArgs);
+        return context.getRuntime().getNil();
+    }
+
+    private IRubyObject invokeInternal(ThreadContext context, IRubyObject dispid,
+            IRubyObject args, IRubyObject argTypes, int dispatchType) {
+        RubyArray argsArray = args.convertToArray();
+        int dispatchId = (int) RubyInteger.num2long(dispid);
+        Object[] objectArgs = makeObjectArgs(argsArray);
+        int[] errorArgs = makeErrorArgs(objectArgs.length);
+        Variant returnValue = Dispatch.invoke(dispatch, dispatchId, dispatchType,
+                objectArgs, errorArgs);
+
+        return fromVariant(context.getRuntime(), returnValue);
+    }
+    private int[] makeErrorArgs(int size) {
+        return size <= 0 ? EMPTY_ERROR_ARGS : new int[size];
+    }
+
+    private Object[] makeObjectArgs(IRubyObject[] rubyArgs, int startIndex) {
+        int length = rubyArgs.length;
+        if (length - startIndex <= 0) return EMPTY_OBJECT_ARGS;
+
+        Object[] objectArgs = new Object[length - startIndex];
+        for (int i = startIndex; i < length; i++) {
+            objectArgs[i - startIndex] = RubyWIN32OLE.toObject(rubyArgs[i]);
+        }
+
+        return objectArgs;
+    }
+
+    private Object[] makeObjectArgs(RubyArray argsArray) {
+        int length = argsArray.size();
+        if (length <= 0) return EMPTY_OBJECT_ARGS;
+
+        Object[] objectArgs = new Object[length];
+        for (int i = 0; i < length; i++) {
+            Object object = toObject(argsArray.eltInternal(i));
+            objectArgs[i] = object;
+        }
+
+        return objectArgs;
+    }
+
+    private IRubyObject invokeMethodOrGet(ThreadContext context, String methodName, IRubyObject[] args) {
+        if (args.length == 1) { // No-arg call
+            return fromObject(context.getRuntime(), Dispatch.callO(dispatch, methodName));
+        } 
+        return fromVariant(context.getRuntime(),
+                Dispatch.callN(dispatch, methodName, makeObjectArgs(args, 1)));
+    }
+
+    @Override
+    public Object toJava(Class klass) {
+        return dispatch;
+    }
+
+    public static Object toObject(IRubyObject rubyObject) {
+        return rubyObject.toJava(Object.class);
+    }
+
+    public static IRubyObject fromObject(Ruby runtime, Object object) {
+        if (object == null) return runtime.getNil();
+
+        if (object instanceof Boolean) {
+            return runtime.newBoolean(((Boolean) object).booleanValue());
+        } else if (object instanceof Dispatch) {
+            return new RubyWIN32OLE(runtime, Win32oleService.getMetaClass(), (Dispatch) object);
+        } else if (object instanceof Date) {
+            return date2ruby(runtime, (Date) object);
+        } else if (object instanceof Number) {
+            if (object instanceof Double) {
+                return runtime.newFloat(((Double) object).doubleValue());
+            } else if (object instanceof Float) {
+                return runtime.newFloat(((Float) object).doubleValue());
+            }
+
+            return runtime.newFixnum(((Number) object).intValue());
+        } else if (object instanceof String) {
+            return runtime.newString((String) object);
+        }
+
+        return JavaUtil.convertJavaToUsableRubyObject(runtime, object);
+    }
+
+    public static IRubyObject fromVariant(Ruby runtime, Variant variant) {
+        if (variant == null) return runtime.getNil();
+
+        switch (variant.getType()) {
+            case Variant.VariantBoolean:
+                return runtime.newBoolean(variant.getBoolean());
+            case Variant.VariantDispatch:
+                return new RubyWIN32OLE(runtime, Win32oleService.getMetaClass(), variant.getDispatch());
+            case Variant.VariantDate:
+                return date2ruby(runtime, variant.getDate());
+            case Variant.VariantInt:
+            case Variant.VariantShort:
+                return runtime.newFixnum(variant.getInt());
+            case Variant.VariantDouble:
+                return runtime.newFloat(variant.getDouble());
+            case Variant.VariantFloat:
+                return runtime.newFloat(variant.getFloat());
+            case Variant.VariantString:
+                return runtime.newString(variant.getString());
+        }
+
+        return JavaUtil.convertJavaToUsableRubyObject(runtime, variant.toJavaObject());
+    }
+
+    public static IRubyObject date2ruby(Ruby runtime, Date date) {
+        Calendar cal = Calendar.getInstance();
+
+        cal.setTime(date);
+
+        return runtime.newTime(cal.getTimeInMillis());
+    }
+
+    public static String toProgID(String id) {
+        if (id != null && id.startsWith("{{") && id.endsWith("}}")) {
+            return id.substring(2, id.length() - 2);
+        }
+
+        return id;
+    }
+}

data/src/win32ole/Win32oleService.java

@@ -0,0 +1,29 @@
+package win32ole;
+
+import org.racob.com.LibraryLoader;
+import java.io.IOException;import java.lang.ref.WeakReference;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.ext.win32ole.RubyWIN32OLE;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class Win32oleService implements BasicLibraryService {
+    static WeakReference<RubyClass> win32oleClass;
+
+    public boolean basicLoad(Ruby runtime) throws IOException {
+        LibraryLoader.loadLibrary();
+        RubyClass object = runtime.getObject();
+        RubyClass win32ole = runtime.defineClass("WIN32OLE", object,
+                RubyWIN32OLE.WIN32OLE_ALLOCATOR);
+
+        win32ole.defineAnnotatedMethods(RubyWIN32OLE.class);
+
+        win32oleClass = new WeakReference<RubyClass>(win32ole);
+
+        return true;
+    }
+
+    public static RubyClass getMetaClass() {
+        return win32oleClass.get();
+    }
+}

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification 
+name: jruby-win32ole
+version: !ruby/object:Gem::Version 
+  hash: 63
+  prerelease: false
+  segments: 
+  - 0
+  - 8
+  - 0
+  version: 0.8.0
+platform: ruby
+authors: 
+- Thomas E. Enebo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-21 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: A Gem for win32ole support on JRuby
+email: tom.enebo@gmail.com
+executables: 
+- make_data.rb
+- sample
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README
+- Rakefile
+- VERSION
+- bin/make_data.rb
+- bin/sample
+- build.xml
+- jruby-win32ole.gemspec
+- lib/jruby-win32ole.rb
+- lib/jruby-win32ole/version.rb
+- lib/racob-x64.dll
+- lib/racob-x86.dll
+- lib/racob.jar
+- lib/win32ole/utils.rb
+- lib/win32ole/win32ole.jar
+- lib/win32ole/win32ole_error.rb
+- lib/win32ole/win32ole_event.rb
+- lib/win32ole/win32ole_method.rb
+- lib/win32ole/win32ole_param.rb
+- lib/win32ole/win32ole_ruby.rb
+- lib/win32ole/win32ole_type.rb
+- lib/win32ole/win32ole_typelib.rb
+- lib/win32ole/win32ole_variable.rb
+- lib/win32ole/win32ole_variant.rb
+- nbproject/build-impl.xml
+- nbproject/genfiles.properties
+- nbproject/private/config.properties
+- nbproject/private/private.properties
+- nbproject/private/private.xml
+- nbproject/project.properties
+- nbproject/project.xml
+- samples/browser_connect.rb
+- samples/const_load.rb
+- samples/dir_enum_bench.rb
+- samples/dispatch_bench.rb
+- samples/file_system_object.rb
+- samples/fs.rb
+- samples/ie_plus_events.rb
+- samples/ie_simple.rb
+- samples/ie_simple_clsid.rb
+- samples/sbem.rb
+- samples/small_enum_bench.rb
+- src/org/jruby/ext/win32ole/RubyInvocationProxy.java
+- src/org/jruby/ext/win32ole/RubyWIN32OLE.java
+- src/win32ole/Win32oleService.java
+has_rdoc: true
+homepage: http://github.com/enebo/jruby-win32ole
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: jruby-win32ole
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A Gem for win32ole support on JRuby
+test_files: []
+