rubyuno 0.3.0

data/ext/rubyuno/adapter.cxx

@@ -0,0 +1,271 @@
+
+#include "rubyuno.hxx"
+
+#include <cppuhelper/typeprovider.hxx>
+#include <rtl/ustrbuf.hxx>
+
+#include <com/sun/star/beans/MethodConcept.hpp>
+#include <com/sun/star/reflection/ParamMode.hpp>
+#include <com/sun/star/uno/TypeClass.hpp>
+#include <com/sun/star/beans/XMaterialHolder.hpp>
+#include <com/sun/star/beans/XIntrospectionAccess.hpp>
+
+using com::sun::star::beans::UnknownPropertyException;
+using com::sun::star::beans::XIntrospectionAccess;
+using com::sun::star::beans::XMaterialHolder;
+using com::sun::star::lang::IllegalArgumentException;
+using com::sun::star::reflection::InvocationTargetException;
+using com::sun::star::script::CannotConvertException;
+using com::sun::star::uno::Any;
+using com::sun::star::uno::RuntimeException;
+using com::sun::star::uno::Sequence;
+using com::sun::star::uno::Type;
+
+using rtl::OUString;
+using rtl::OUStringBuffer;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::reflection;
+
+namespace rubyuno
+{
+
+ID
+oustring2ID(const OUString &aName)
+{
+	return rb_intern(OUStringToOString(aName, RTL_TEXTENCODING_ASCII_US).getStr());
+}
+
+Adapter::Adapter(const VALUE &obj, const Sequence< Type > &types)
+	: m_wrapped(obj), 
+	m_types(types)
+{
+}
+
+VALUE
+Adapter::getWrapped()
+{
+	return m_wrapped;
+}
+
+Sequence< Type >
+Adapter::getWrappedTypes()
+{
+	return m_types;
+}
+
+Adapter::~Adapter()
+{
+	// Adapter is deleted by the adapter factory.
+	// remove from adapterMap
+	Runtime runtime;
+	runtime.getImpl()->adapterMap.erase(m_wrapped);
+}
+
+
+void
+raiseUnoException(VALUE arg)
+	throw (InvocationTargetException)
+{
+	VALUE exc = rb_gv_get("$!");
+	
+	if (rb_obj_is_kind_of(exc, get_exception_class()))
+	{
+		Any a;
+		RubyunoInternal *rubyuno;
+		Data_Get_Struct(exc, RubyunoInternal, rubyuno);
+		Reference < XMaterialHolder > xHolder(rubyuno->invocation, UNO_QUERY);
+		if (xHolder.is())
+			throw xHolder->getMaterial().getValue();
+	}
+}
+
+VALUE
+call_apply(VALUE argv)
+{
+	return rb_apply(rb_ary_entry(argv, 0), rb_intern_str(rb_ary_entry(argv, 1)), rb_ary_entry(argv, 2));
+}
+
+
+Sequence< sal_Int16 >
+Adapter::getOutParamIndexes(const OUString &methodName)
+{
+	Sequence< sal_Int16 > ret;
+	
+	Runtime runtime;
+	Reference< XInterface > adapter = runtime.getImpl()->xAdapterFactory->createAdapter(this, m_types);
+	Reference< XIntrospectionAccess > introspection = runtime.getImpl()->xIntrospection->inspect(makeAny(adapter));
+	
+	if (! introspection.is())
+	{
+		throw RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM("rubyuno: failed to create adapter.")), Reference< XInterface >());
+	}
+	Reference< XIdlMethod > method = introspection->getMethod(methodName, com::sun::star::beans::MethodConcept::ALL);
+	if (! method.is())
+	{
+		throw RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM("rubyuno: Failed to get reflection for ")) + methodName, Reference< XInterface >());
+	}
+	Sequence< ParamInfo > info = method->getParameterInfos();
+	
+	int out = 0;
+	int i = 0;
+	for (i = 0; i < info.getLength(); i++)
+	{
+		if (info[i].aMode == ParamMode_OUT || 
+			info[i].aMode == ParamMode_INOUT)
+			out++;
+	}
+	if (out)
+	{
+		sal_Int16 j = 0;
+		ret.realloc(out);
+		for (i = 0; i < info.getLength(); i++)
+		{
+			if (info[i].aMode == ParamMode_OUT || 
+				info[i].aMode == ParamMode_INOUT)
+			{
+				ret[j] = i;
+				j++;
+			}
+		}
+	}
+	return ret;
+}
+
+
+Reference< XIntrospectionAccess >
+Adapter::getIntrospection()
+	throw (RuntimeException)
+{
+	return Reference< XIntrospectionAccess >();
+}
+
+
+Any
+Adapter::invoke(const OUString &  aFunctionName, const Sequence < Any > &aParams, Sequence < sal_Int16 > &aOutParamIndex, Sequence < Any > &aOutParam)
+	throw (IllegalArgumentException, CannotConvertException, 
+			InvocationTargetException, 	RuntimeException)
+{
+	if (aParams.getLength() == 1 && aFunctionName.compareToAscii("getSomething") == 0)
+	{
+		Sequence < sal_Int8 > id;
+		if (aParams[0] >>= id)
+			return makeAny(getSomething(id));
+	}
+	
+	Any retAny;
+	try
+	{
+		Runtime runtime;
+		VALUE args = rb_ary_new2(aParams.getLength());
+		for (int i = 0; i < aParams.getLength(); i++)
+		{
+			rb_ary_push(args, runtime.any_to_VALUE(aParams[i]));
+		}
+	
+		VALUE argv = rb_ary_new2(3);
+		rb_ary_push(argv, m_wrapped);
+		rb_ary_push(argv, ustring2RString(aFunctionName));
+		rb_ary_push(argv, args);
+		VALUE ret = rb_rescue((VALUE(*)(...))call_apply, argv, (VALUE(*)(...))raiseUnoException, 0);
+		
+		//ID id = oustring2ID(aFunctionName);
+		//VALUE ret = rb_apply(m_wrapped, id, args);
+		Any retAny = runtime.value_to_any(ret);
+		
+		if (retAny.getValueTypeClass() == com::sun::star::uno::TypeClass_SEQUENCE && 
+			aFunctionName.compareToAscii("getTypes") != 0 && 
+			aFunctionName.compareToAscii("getImplementationId"))
+		{
+			aOutParamIndex = getOutParamIndexes(aFunctionName);
+			if (aOutParamIndex.getLength())
+			{
+				Sequence< Any > seq;
+				if (! (retAny >>= seq))
+				{
+					throw RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM("rubyuno: failed to extract out values for method ")) + aFunctionName, Reference< XInterface >());
+				}
+			
+				if (! (seq.getLength() == aOutParamIndex.getLength() + 1))
+				{
+					throw RuntimeException(OUString( RTL_CONSTASCII_USTRINGPARAM("rubyuno: illegal number of out values for method ")) + aFunctionName, Reference< XInterface >());
+				}
+			
+				aOutParam.realloc(aOutParamIndex.getLength());
+				retAny = seq[0];
+				for (int i = 0; i < aOutParamIndex.getLength(); i++)
+				{
+					aOutParam[i] = seq[i + 1];
+				}
+			}
+		}
+	}
+	catch (RuntimeException &e)
+	{
+		printf("%s\n", OUStringToOString(e.Message, RTL_TEXTENCODING_ASCII_US).getStr());
+	}
+	return retAny;
+}
+
+void
+Adapter::setValue(const OUString &aPropertyName, const Any &aValue) 
+	throw (UnknownPropertyException, CannotConvertException, 
+			InvocationTargetException, RuntimeException)
+{
+	Runtime runtime;
+	OUStringBuffer buf(aPropertyName);
+	buf.appendAscii("=");
+	rb_funcall(m_wrapped, oustring2ID(buf.makeStringAndClear()), 1, runtime.any_to_VALUE(aValue));
+}
+
+Any
+Adapter::getValue(const OUString &aPropertyName)
+	throw (UnknownPropertyException, RuntimeException)
+{
+	Runtime runtime;
+	return runtime.value_to_any(rb_funcall(m_wrapped, oustring2ID(aPropertyName), 0));
+}
+
+sal_Bool
+Adapter::hasMethod(const OUString &aName)
+	throw (RuntimeException)
+{
+	if (rb_respond_to(m_wrapped, oustring2ID(aName)))
+		return sal_True;
+	return sal_False;
+}
+	
+sal_Bool
+Adapter::hasProperty(const OUString &aName)
+	throw (RuntimeException)
+{
+	if (rb_respond_to(m_wrapped, oustring2ID(aName)))
+		return sal_True;
+	else
+	{
+		OUStringBuffer buf(aName);
+		buf.appendAscii("=");
+		if (rb_respond_to(m_wrapped, oustring2ID(buf.makeStringAndClear())))
+			return sal_True;
+	}
+	return sal_False;
+}
+
+static cppu::OImplementationId g_Id(sal_False);
+
+Sequence < sal_Int8 >
+Adapter::getTunnelImplId()
+{
+	return g_Id.getImplementationId();
+}
+
+sal_Int64
+Adapter::getSomething(const Sequence < sal_Int8 > &aIdentifier)
+		throw (RuntimeException)
+{
+	if (aIdentifier == g_Id.getImplementationId())
+		return reinterpret_cast< sal_Int64 >(this);
+	return 0;
+}
+
+}
+

data/ext/rubyuno/extconf.rb

@@ -0,0 +1,125 @@
+require 'mkmf'
+require 'open3'
+
+# IDL Headers
+IDL_TYPES = [
+  "com.sun.star.beans.MethodConcept", 
+  "com.sun.star.beans.PropertyAttribute", 
+  "com.sun.star.beans.XIntrospection", 
+  "com.sun.star.beans.XIntrospectionAccess", 
+  "com.sun.star.beans.XMaterialHolder", 
+  "com.sun.star.container.XEnumerationAccess", 
+  "com.sun.star.container.XHierarchicalNameAccess", 
+  "com.sun.star.container.XIndexContainer", 
+  "com.sun.star.container.XNameContainer", 
+  "com.sun.star.lang.XMultiServiceFactory", 
+  "com.sun.star.lang.XServiceInfo", 
+  "com.sun.star.lang.XSingleComponentFactory", 
+  "com.sun.star.lang.XSingleServiceFactory", 
+  "com.sun.star.lang.XTypeProvider", 
+  "com.sun.star.lang.XUnoTunnel", 
+  "com.sun.star.reflection.InvocationTargetException", 
+  "com.sun.star.reflection.ParamMode", 
+  "com.sun.star.reflection.XConstantTypeDescription", 
+  "com.sun.star.reflection.XConstantsTypeDescription", 
+  "com.sun.star.reflection.XEnumTypeDescription", 
+  "com.sun.star.reflection.XIdlReflection", 
+  "com.sun.star.reflection.XInterfaceTypeDescription2", 
+  "com.sun.star.reflection.XTypeDescription", 
+  "com.sun.star.registry.XRegistryKey", 
+  "com.sun.star.script.InvocationInfo", 
+  "com.sun.star.script.MemberType", 
+  "com.sun.star.script.XInvocation2", 
+  "com.sun.star.script.XInvocationAdapterFactory2", 
+  "com.sun.star.script.XTypeConverter", 
+  "com.sun.star.script.provider.ScriptFrameworkErrorException", 
+  "com.sun.star.uno.XAggregation", 
+  "com.sun.star.uno.TypeClass", 
+  "com.sun.star.uno.XComponentContext", 
+  "com.sun.star.uno.XWeak", 
+]
+
+CPPU_INCLUDE = './include'
+CPPUMAKER = 'cppumaker'
+CPPUMAKER_FLAG = "#{CPPU_INCLUDE}/flag"
+SETSDKENV = 'setsdkenv_unix'
+
+def missing(item)
+  die "couldn't find #{item} (required)"
+end
+
+def die(msg)
+  puts msg
+  exit
+end
+
+def find_environment(var)
+  checking_for checking_message(var, "environment") do
+    !ENV[var].nil?
+  end
+end
+
+c = RbConfig::CONFIG
+host = c['host']
+
+missing(CPPUMAKER) unless find_executable(CPPUMAKER)
+setsdkenv_path = checking_for checking_message(SETSDKENV) do
+  `find / -name #{SETSDKENV} &2>/dev/null`.chomp
+end
+missing(SETSDKENV) unless setsdkenv_path
+
+# Collected needed environment variables
+sdk_home = ENV['OO_SDK_HOME']
+ure_home = ENV['OO_SDK_URE_HOME']
+base_path = ENV['OFFICE_BASE_PROGRAM_PATH']
+environment_ready = true
+%w(OO_SDK_HOME OO_SDK_URE_HOME OFFICE_BASE_PROGRAM_PATH).each do |env|
+  #environment_ready &&= find_environment(env)
+  res = find_environment(env)
+  environment_ready &&= res
+end
+
+unless environment_ready
+  message "collecting ENV values:\n"
+  IO.popen("#{setsdkenv_path} >/dev/null", "w") {} # Ensure the SDK is set up
+  res = Open3.popen3("/opt/openoffice.org/basis3.4/sdk/setsdkenv_unix") do |i, o, e|
+    i.puts "echo $OO_SDK_HOME"
+    i.puts "echo $OO_SDK_URE_HOME"
+    i.puts "echo $OFFICE_BASE_PROGRAM_PATH"
+    i.close_write
+    o.readlines
+  end
+  sdk_home, ure_home, base_path = res[-5..-2].map(&:chomp)
+  message "$OO_SDK_HOME=#{sdk_home}\n"
+  message "$OO_SDK_URE_HOME=#{ure_home}\n"
+  message "$OFFICE_BASE_PROGRAM_PATH=#{base_path}\n"
+end
+
+unless File.exists?(CPPUMAKER_FLAG)
+  message "generating C++ representation for OpenOffice IDL types... "
+  ure_types = host['linux'] ? "#{ure_home}/share/misc/types.rdb" : "#{ure_home}/misc/types.rdb"
+  office_types = "#{base_path}/offapi.rdb"
+  IO.popen("/opt/openoffice.org/basis3.4/sdk/setsdkenv_unix >/dev/null", "w") do |shell|
+    shell.puts "#{CPPUMAKER} -Gc -BUCR -O#{CPPU_INCLUDE} -T\"#{IDL_TYPES.join(';')}\" \"#{ure_types}\" \"#{office_types}\""
+    shell.puts "touch #{CPPUMAKER_FLAG}"
+  end
+  
+  message "ok\n"
+end
+
+if host['mswin']
+  sdk_lib = "/LIBPATH:\"#{sdk_home}/lib\""
+  ure_lib = ""
+  sdk_libs = " icppuhelper.lib icppu.lib isal.lib isalhelper.lib msvcprt.lib msvcrt.lib kernel32.lib" # 
+else
+  sdk_lib = "-L\"#{sdk_home}/lib\""
+  ure_lib = "-L\"#{ure_home}/lib\""
+  sdk_libs = " -luno_cppuhelpergcc3 -luno_cppu -luno_salhelpergcc3 -luno_sal -lm "
+end
+
+$warnflags = $warnflags.split.reject{|w| w['declaration-after-statement'] || w['implicit-function-declaration'] }.join(" ") # Remove invalid warnings
+$INCFLAGS << " -I#{sdk_home}/include -I#{CPPU_INCLUDE} "
+$LOCAL_LIBS << "#{sdk_lib} #{ure_lib} #{sdk_libs}"
+$CFLAGS << " -fno-strict-aliasing -DUNX -DGCC -DLINUX -DCPPU_ENV=gcc3 "
+
+create_makefile('rubyuno/rubyuno')

data/ext/rubyuno/libruno.def

@@ -0,0 +1,26 @@
+EXPORTS
+oustring_to_rb_str
+rb_str_to_oustring
+ascii_rb_str_to_oustring
+ascii_oustring_to_rb_str
+bytes_to_rb_str
+init_external_encoding
+get_uno_module
+get_proxy_class
+get_enum_class
+get_type_class
+get_char_class
+get_struct_class
+get_exception_class
+get_any_class
+get_bytes_class
+get_interface_class
+get_css_uno_exception_class
+get_uno_error_class
+create_module
+find_class
+runo_new_type
+runo_new_enum
+valueToOUString
+any_to_VALUE
+

data/ext/rubyuno/loader.cxx

@@ -0,0 +1,184 @@
+/**************************************************************
+ * Copyright 2011 Tsutomu Uchino
+ *
+ * Licensed 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.
+ * 
+ *************************************************************/
+
+#include "rubyuno.hxx"
+
+#include <osl/module.hxx>
+#include <osl/process.h>
+#include <osl/thread.h>
+#include <osl/file.hxx>
+
+#include <cppuhelper/implementationentry.hxx>
+#include <rtl/ustrbuf.hxx>
+
+#include <com/sun/star/uno/XInterface.hpp>
+
+using com::sun::star::uno::Reference;
+using com::sun::star::uno::Sequence;
+using com::sun::star::uno::XComponentContext;
+using com::sun::star::uno::XInterface;
+
+using rtl::OUString;
+using rtl::OUStringToOString;
+using rtl::OUStringBuffer;
+
+#define IMPLE_NAME "mytools.loader.Ruby"
+#define SERVICE_NAME "com.sun.star.loader.Ruby"
+
+namespace rubyunoloader
+{
+
+static void 
+getLibraryPath(OUString &path) throw (com::sun::star::uno::RuntimeException)
+{
+    OUString libUrl;
+    ::osl::Module::getUrlFromAddress(
+        reinterpret_cast< oslGenericFunction >(getLibraryPath), libUrl);
+    libUrl = libUrl.copy(0, libUrl.lastIndexOf('/'));
+    osl::FileBase::RC e = osl::FileBase::getSystemPathFromFileURL(libUrl, path);
+    if (e != osl::FileBase::E_None)
+    {
+        throw com::sun::star::uno::RuntimeException(
+            OUString(RTL_CONSTASCII_USTRINGPARAM(
+                "failed to retrieve path to the loader.")), 
+            Reference< XInterface >());
+    }
+}
+
+static int ruby_state = 1;
+
+static void 
+load_modules(VALUE args)
+{
+    rb_require(RSTRING_PTR(rb_ary_entry(args, 0)));
+    rb_require(RSTRING_PTR(rb_ary_entry(args, 1)));
+    rb_require(RSTRING_PTR(rb_ary_entry(args, 2)));
+}
+
+
+Reference< XInterface > 
+createInstanceWithContext(const Reference< XComponentContext > &ctx)
+{
+    Reference< XInterface > ret;
+    if (ruby_state == 1)
+    {
+        OUStringBuffer buf;
+        OUString sysPath;
+        getLibraryPath(sysPath);
+        
+        RUBY_INIT_STACK;
+        ruby_init();
+        ruby_init_loadpath();
+        
+        if (! rubyuno::Runtime::isInitialized())
+        {
+            try
+            {
+                rubyuno::Runtime::initialize(ctx);
+            }
+            catch (com::sun::star::uno::RuntimeException &e)
+            {
+                return ret;
+            }
+        }
+        VALUE argv = rb_ary_new2(3);
+        buf.append(sysPath);
+        buf.appendAscii("/rubyuno.so");
+        rb_ary_store(argv, 0, rubyuno::oustring_to_rb_str(buf.makeStringAndClear()));
+        buf.append(sysPath);
+        buf.appendAscii("/lib.rb");
+        rb_ary_store(argv, 1, rubyuno::oustring_to_rb_str(buf.makeStringAndClear()));
+        buf.append(sysPath);
+        buf.appendAscii("/rubyloader.rb");
+        rb_ary_store(argv, 2, rubyuno::oustring_to_rb_str(buf.makeStringAndClear()));
+        int state;
+        rb_protect((VALUE(*)(VALUE))load_modules, argv, &state);
+        ruby_state = state; // 0 sucess
+        if (state)
+        {
+            rb_p(rb_gv_get("$!"));
+        }
+    }
+    if (ruby_state == 0 && rubyuno::Runtime::isInitialized())
+    {
+        rubyuno::Runtime runtime;
+        VALUE loader_module = rb_const_get(
+                    rb_cObject, rb_intern("RubyLoader"));
+        VALUE loader_imple = rb_const_get(
+                    loader_module, rb_intern("RubyLoaderImpl"));
+        VALUE ctx_val = runtime.any_to_VALUE(makeAny(ctx));
+        VALUE args[1];
+        args[0] = ctx_val;
+        VALUE loader = rb_class_new_instance(1, args, loader_imple);
+        runtime.value_to_any(loader) >>= ret;
+    }
+    return ret;
+}
+
+
+OUString
+getImplementationName()
+{
+    return OUString(RTL_CONSTASCII_USTRINGPARAM(IMPLE_NAME));
+}
+
+Sequence< OUString >
+getSupportedServiceNames()
+{
+    OUString name(RTL_CONSTASCII_USTRINGPARAM(SERVICE_NAME));
+    return Sequence< OUString >(&name, 1);
+}
+
+} // rubyunoloader
+
+static struct cppu::ImplementationEntry g_entries[] = 
+{
+    {
+        rubyunoloader::createInstanceWithContext, 
+        rubyunoloader::getImplementationName, 
+        rubyunoloader::getSupportedServiceNames, 
+        cppu::createSingleComponentFactory, 
+        0, 
+        0
+    }, 
+    {0, 0, 0, 0, 0, 0}
+};
+
+
+extern "C"
+{
+
+void SAL_CALL
+component_getImplementationEnvironment(const sal_Char **ppEnvTypeName, uno_Environment **)
+{
+    *ppEnvTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME;
+}
+/*
+sal_Bool SAL_CALL
+component_writeInfo(void *pServiceManager, void *pRegistryKey)
+{
+    return cppu::component_writeInfoHelper(pServiceManager, pRegistryKey, g_entries);
+}
+*/
+void* SAL_CALL
+component_getFactory(const sal_Char *pImplName, void *pServiceManager, void *pRegistryKey)
+{
+    return cppu::component_getFactoryHelper(pImplName, pServiceManager, pRegistryKey, g_entries);
+}
+
+}