rubypython 0.2.8 → 0.2.9

data/ext/rubypython_bridge/ptor.h

@@ -1,31 +1,15 @@
 #include "config.h"
 
-#ifndef _RP_ERROR_H_
-#include "rp_error.h"
-#endif
-
 #ifndef _PTOR_H_
 #define _PTOR_H_
-	
 //Python to Ruby Conversion
-VALUE ptor_string(PyObject* pString);
-
-VALUE ptor_list(PyObject* pList);
-
-VALUE ptor_obj(PyObject* pObj);
-
-VALUE ptor_int(PyObject* pNum);
-
-VALUE ptor_long(PyObject* pNum);
-
-VALUE ptor_float(PyObject* pNum);
-
-VALUE ptor_tuple(PyObject* pTuple);
-
-VALUE ptor_dict(PyObject* pDict);
-
-VALUE ptor_obj_no_destruct(PyObject *pObj);
-
-
-
+VALUE ptorString(PyObject* pString);
+VALUE ptorList(PyObject* pList);
+VALUE ptorInt(PyObject* pNum);
+VALUE ptorLong(PyObject* pNum);
+VALUE ptorFloat(PyObject* pNum);
+VALUE ptorTuple(PyObject* pTuple);
+VALUE ptorDict(PyObject* pDict);
+VALUE ptorObject(PyObject* pObj);
+VALUE ptorObjectKeep(PyObject *pObj);
 #endif /* _PTOR_H_ */

data/ext/rubypython_bridge/rp_blankobject.c

@@ -0,0 +1,42 @@
+#include "rp_blankobject.h"
+
+RUBY_EXTERN VALUE mRubyPythonBridge;
+
+VALUE cBlankObject;
+
+// :nodoc:
+/* This functions is used as a predicate function. Every function name
+for which it returns true will be removed from the blank object
+dictionary.
+*/
+VALUE blank_undef_if(VALUE name, VALUE klass)
+{
+	VALUE mname = rb_funcall(name, rb_intern("to_s"), 0);
+	VALUE methodRe = rb_str_new2("(?:^__)|(?:\\?$)|(?:^send$)|(?:^class$)");
+	
+	if(rb_funcall(mname, rb_intern("match"), 1, methodRe) == Qnil)
+	{
+		rb_undef_method(klass, STR2CSTR(mname));
+		return Qtrue;
+	}
+	else
+	{
+		return Qfalse;
+	}
+}
+
+// :nodoc:
+VALUE blank_obj_prep(VALUE self)
+{
+	VALUE instance_methods = rb_funcall(self, rb_intern("instance_methods"), 0);
+	
+	rb_iterate(rb_each, instance_methods, blank_undef_if, self);
+	return self;
+}
+
+// :nodoc:
+inline void Init_BlankObject()
+{
+	cBlankObject = rb_define_class_under(mRubyPythonBridge,"BlankObject", rb_cObject);
+	blank_obj_prep(cBlankObject);
+}

data/ext/rubypython_bridge/rp_blankobject.h

@@ -0,0 +1,10 @@
+#include "config.h"
+
+#ifndef _RP_BLANKOBJECT_H_
+#define _RP_BLANKOBJECT_H_
+
+
+VALUE blank_undef_if(VALUE, VALUE);
+VALUE blank_obj_prep(VALUE);
+
+#endif

data/ext/rubypython_bridge/rp_class.c

@@ -0,0 +1,56 @@
+#include "rp_class.h"
+
+#include "rp_module.h"
+#include "rp_object.h"
+
+RUBY_EXTERN VALUE mRubyPythonBridge;
+RUBY_EXTERN VALUE ePythonError;
+RUBY_EXTERN VALUE cRubyPyObject;
+RUBY_EXTERN VALUE cBlankObject;
+
+VALUE cRubyPyClass;
+
+VALUE rpClassFromPyObject(PyObject *pClass)
+{
+	PObj* self;
+	PyObject* pClassDict;
+	VALUE rDict;
+	VALUE rClass = rb_class_new_instance(0, NULL, cRubyPyClass);
+
+	Data_Get_Struct(rClass, PObj, self);
+	self->pObject = pClass;
+	
+	pClassDict = PyObject_GetAttrString(pClass,"__dict__");
+	Py_XINCREF(pClassDict);
+	
+	rDict = rpObjectFromPyObject
+(pClassDict);
+	rb_iv_set(rClass,"@pdict", rDict);
+	
+	return rClass;
+}
+
+static
+VALUE rpClassNew(VALUE self, VALUE args)
+{
+	PyObject* pSelf;
+
+	pSelf = rpObjectGetPyObject(self);
+	
+	return rpCall(pSelf, args);
+}
+
+/*
+A wrapper class for Python classes and instances.
+
+This allows objects which cannot easily be converted to native Ruby types to still be accessible
+from within ruby. Most users need not concern themselves with anything about this class except
+its existence.
+
+*/
+void Init_RubyPyClass()
+{
+	cRubyPyClass = rb_define_class_under(mRubyPythonBridge,"RubyPyClass", cRubyPyObject);
+	rb_define_method(cRubyPyClass,"method_missing", rpModuleDelegate,- 2);
+	rb_define_method(cRubyPyClass,"new", rpClassNew,- 2);
+}

data/ext/rubypython_bridge/rp_class.h

@@ -0,0 +1,6 @@
+#include "config.h"
+
+#ifndef _RP_CLASS_H_
+#define _RP_CLASS_H_
+VALUE rpClassFromPyObject(PyObject*);
+#endif

data/ext/rubypython_bridge/rp_error.c

@@ -1,23 +1,33 @@
 #include "rp_error.h"
 
 VALUE ePythonError;
+VALUE eRubyPyError;
 
-void rp_pythonerror()
+void rpPythonError()
 {
 	PyObject *pType,*pValue,*pTraceback;
 	PyObject *pTypeName;
+	
 	PyErr_Fetch(&pType,&pValue,&pTraceback);
-	pTypeName=PyObject_GetAttrString(pType,"__name__");
+	
+	pTypeName = PyObject_GetAttrString(pType,"__name__");
 	Py_XDECREF(pType);
-	rb_raise(ePythonError,"%s:(%s)\n",STR2CSTR(ptor_obj(pTypeName)),STR2CSTR(rb_inspect(ptor_obj(pValue))));
+	
+	rb_raise(ePythonError,"%s:(%s)\n", STR2CSTR(ptorObject(pTypeName)), STR2CSTR(rb_inspect(ptorObject(pValue))));
+	
 	Py_XDECREF(pTraceback);
 }
 
+void rpRubyPyError(char* eString) {
+	rb_raise(eRubyPyError, eString);
+}
+
 /*
 Used to pass error information back into Ruby should an error occur in the embedded Python
 interpreter.
 */
 void Init_RubyPyError()
 {
-	ePythonError=rb_define_class("PythonError",rb_eException);
+	ePythonError = rb_define_class("PythonError", rb_eException);
+	eRubyPyError = rb_define_class("RubyPyError", rb_eException);
 }

data/ext/rubypython_bridge/rp_error.h

@@ -3,6 +3,8 @@
 #ifndef _RP_ERROR_H_
 #define _RP_ERROR_H_
 
-void rp_pythonerror();
+void rpPythonError();
+
+void rpRubyPyError(char*);
 
 #endif /* _RP_ERROR_H_ */

data/ext/rubypython_bridge/rp_function.c

@@ -0,0 +1,31 @@
+#include "rp_function.h"
+#include "rp_object.h"
+
+RUBY_EXTERN VALUE mRubyPythonBridge;
+RUBY_EXTERN VALUE cRubyPyObject;
+
+VALUE cRubyPyFunction;
+
+VALUE rpFunctionFromPyObject(PyObject *pFunc)
+{
+	PObj* self;
+	VALUE rFunc = rb_class_new_instance(0, NULL, cRubyPyFunction);
+	
+	Data_Get_Struct(rFunc, PObj, self);
+	
+	self->pObject = pFunc;
+	
+	return rFunc;
+}
+
+
+// 
+// A wrapper class for Python functions and methods.
+// 
+// This is used internally to aid RubyPyClass in delegating method calls.
+// 
+
+void Init_RubyPyFunction()
+{
+	cRubyPyFunction = rb_define_class_under(mRubyPythonBridge,"RubyPyFunction", cRubyPyObject);
+}

data/ext/rubypython_bridge/rp_function.h

@@ -0,0 +1,6 @@
+#include "config.h"
+
+#ifndef _RP_FUNCTION_H_
+#define _RP_FUNCTION_H_
+VALUE rpFunctionFromPyObject(PyObject*);
+#endif

data/ext/rubypython_bridge/rp_instance.c

@@ -0,0 +1,165 @@
+#include "rp_instance.h"
+
+#include "rp_object.h"
+#include "rp_function.h"
+
+RUBY_EXTERN VALUE mRubyPythonBridge;
+
+RUBY_EXTERN VALUE cRubyPyObject;
+RUBY_EXTERN VALUE cRubyPyFunction;
+
+VALUE cRubyPyInstance;
+
+VALUE rpInstanceFromPyObject(PyObject* pInst)
+{
+	PObj* self;
+	PyObject *pClassDict,*pClass,*pInstDict;
+	VALUE rInstDict, rClassDict;	
+	VALUE rInst = rb_class_new_instance(0, NULL, cRubyPyInstance);
+
+	Data_Get_Struct(rInst, PObj, self);
+	self->pObject = pInst;
+	
+	pClass = PyObject_GetAttrString(pInst,"__class__");
+	pClassDict = PyObject_GetAttrString(pClass,"__dict__");
+	pInstDict = PyObject_GetAttrString(pInst,"__dict__");
+	
+	Py_XINCREF(pClassDict);
+	Py_XINCREF(pInstDict);
+	
+	rClassDict = rpObjectFromPyObject(pClassDict);
+	rInstDict = rpObjectFromPyObject(pInstDict);
+	
+	rb_iv_set(rInst,"@pclassdict", rClassDict);
+	rb_iv_set(rInst,"@pinstdict", rInstDict);
+	
+	return rInst;
+}
+
+static
+VALUE rpInstanceSetAttr(VALUE self, VALUE args)
+{
+	VALUE name, name_string, rClassDict, result, rInstDict;
+	VALUE ret;
+	
+	int instance;
+	char* cname;
+	
+	PObj *pClassDict,*pInstDict,*pDict;
+	
+	PyObject* pName;
+	
+	name = rb_ary_shift(args);
+	name_string = rb_funcall(name, rb_intern("to_s"), 0);
+	
+	rb_funcall(name_string, rb_intern("chop!"), 0);
+	
+	if(!rpHasSymbol(self, name_string))
+	{		
+		int argc;		
+		VALUE* argv;
+		
+		argc = RARRAY_LEN(args);
+		argv = ALLOC_N(VALUE, argc);
+		MEMCPY(argv, RARRAY_PTR(args), VALUE, argc);
+		return rb_call_super(argc, argv);
+	}
+	
+	cname = STR2CSTR(name_string);
+	
+	if((NUM2INT(rb_funcall(args, rb_intern("size"), 0)) == 1))
+	{
+		args = rb_ary_entry(args, 0);
+	}
+	
+	rClassDict = rb_iv_get(self,"@pclassdict");
+	rInstDict = rb_iv_get(self,"@pinstdict");
+	
+	Data_Get_Struct(rClassDict, PObj, pClassDict);
+	Data_Get_Struct(rInstDict, PObj, pInstDict);
+	
+	pName = PyString_FromString(cname);
+	
+	if(PyDict_Contains(pInstDict->pObject, pName))
+	{
+		pDict = pInstDict;
+
+	}
+	else
+	{
+		pDict = pClassDict;
+		
+	}
+	
+	Py_XDECREF(pName);
+	PyDict_SetItemString(pDict->pObject, STR2CSTR(name_string), rtopObject(args, 0));
+	
+	return Qtrue;
+}
+
+//:nodoc:
+static
+VALUE rpInstanceDelegate(VALUE self, VALUE args)
+{
+	VALUE name, name_string, rClassDict, result, rInstDict;
+	VALUE ret;
+	char* cname;
+	PObj *pClassDict,*pInstDict;
+	PyObject* pCalled;
+	
+	if(rpSymbolIsSetter(args))
+	{
+		return rpInstanceSetAttr(self, args);
+	}
+	
+	if(!rpHasSymbol(self, rb_ary_entry(args, 0)))
+	{		
+		int argc;
+		VALUE* argv;
+		
+		argc = RARRAY_LEN(args);
+		argv = ALLOC_N(VALUE, argc);
+		MEMCPY(argv, RARRAY_PTR(args), VALUE, argc);
+		return rb_call_super(argc, argv);
+	}
+	
+	name = rb_ary_shift(args);
+	name_string = rb_funcall(name, rb_intern("to_s"), 0);
+	cname = STR2CSTR(name_string);
+		
+	rClassDict = rb_iv_get(self,"@pclassdict");
+	rInstDict = rb_iv_get(self,"@pinstdict");
+	
+	Data_Get_Struct(rClassDict, PObj, pClassDict);
+	Data_Get_Struct(rInstDict, PObj, pInstDict);
+	
+	pCalled = PyDict_GetItemString(pInstDict->pObject, cname);
+	
+	if(!pCalled)
+	{
+		pCalled = PyDict_GetItemString(pClassDict->pObject, cname);
+	}
+	
+	Py_XINCREF(pCalled);
+	result = ptorObjectKeep(pCalled);
+	
+	if(rb_obj_is_instance_of(result, cRubyPyFunction))
+	{
+		Py_XINCREF(rpObjectGetPyObject(self));
+		rb_ary_unshift(args, self);
+		ret = rpCall(pCalled, args);
+		return ret;
+	}
+	
+	return result;
+	
+}
+
+
+void Init_RubyPyInstance()
+{
+	cRubyPyInstance = rb_define_class_under(mRubyPythonBridge,"RubyPyInstance", cRubyPyObject);
+	rb_define_method(cRubyPyInstance,"method_missing", rpInstanceDelegate,- 2);
+}
+
+

data/ext/rubypython_bridge/rp_instance.h

@@ -0,0 +1,6 @@
+#include "config.h"
+
+#ifndef _RP_INSTANCE_H_
+#define _RP_INSTANCE_H_
+VALUE rpInstanceFromPyObject(PyObject*);
+#endif

data/ext/rubypython_bridge/rp_module.c

@@ -0,0 +1,159 @@
+#include "rp_module.h"
+
+#include "rp_object.h"
+#include "rp_function.h"
+
+VALUE cRubyPyModule;
+
+RUBY_EXTERN VALUE mRubyPythonBridge;
+RUBY_EXTERN VALUE cRubyPyFunction;
+RUBY_EXTERN VALUE cRubyPyClass;
+RUBY_EXTERN VALUE cRubyPyObject;
+
+static
+VALUE rpModuleCallFunction(VALUE self, VALUE func_name, VALUE args)
+{
+	PyObject *pModule,*pFunc;
+	VALUE rReturn;
+	
+	pModule = rpObjectGetPyObject(self);
+	
+	pFunc = rpGetFunctionWithModule(pModule, func_name);
+	rReturn = rpCall(pFunc, args);
+	Py_XDECREF(pFunc);
+	
+	return rReturn;
+	
+}
+
+//:nodoc:
+static
+VALUE rpModuleInit(VALUE self, VALUE mname)
+{
+	PObj* cself;
+	VALUE rDict;
+	PyObject *pModuleDict;
+	
+	Data_Get_Struct(self, PObj, cself);
+	cself->pObject = rpGetModule(mname);
+	
+	pModuleDict = PyModule_GetDict(cself->pObject);
+	Py_XINCREF(pModuleDict);
+	
+	rDict = rpObjectFromPyObject(pModuleDict);
+	
+	rb_iv_set(self,"@pdict", rDict);
+	
+	return self;
+}
+
+static
+VALUE rpModuleSetAttr(VALUE self, VALUE args)
+{
+	VALUE rDict;
+	PyObject* pDict;
+	
+	VALUE mname = rb_ary_shift(args);
+	VALUE name_string = rb_funcall(mname, rb_intern("to_s"), 0);
+	
+	//The method name ends with "=" because it is a setter.
+	//We must chop that off before we pass the string to python.
+	rb_funcall(name_string, rb_intern("chop!"), 0);
+	
+	//The wrapped python object does not have method or attribute with the
+	//request named. Check for it in the Ruby superclass.
+	if(!rpHasSymbol(self, name_string))
+	{		
+		int argc;
+		
+		VALUE* argv;
+		argc = RARRAY_LEN(args);
+		
+		argv = ALLOC_N(VALUE, argc);
+		MEMCPY(argv, RARRAY_PTR(args), VALUE, argc);
+		
+		return rb_call_super(argc, argv);
+	}
+	
+	if(NUM2INT(rb_funcall(args, rb_intern("size"), 0)) == 1)
+	{
+		args = rb_ary_entry(args, 0);
+	}
+	
+	rDict = rb_iv_get(self,"@pdict");
+	
+	pDict = rpObjectGetPyObject(rDict);
+	
+	PyDict_SetItemString(pDict, STR2CSTR(name_string), rtopObject(args, 0));
+	
+	return Qtrue;
+}
+
+//:nodoc:
+VALUE rpModuleDelegate(VALUE self, VALUE args)
+{
+	VALUE name, name_string, rDict, result;
+	VALUE ret;
+	PyObject *pCalled, *pDict;
+	
+	if(rpSymbolIsSetter(args))
+	{
+		return rpModuleSetAttr(self, args);
+	}
+	
+	// if(rpSymbolIsDoubleBang)
+	// {
+	// 	return rp_mod_attr_db(args);
+	// }
+	if(!rpHasSymbol(self, rb_ary_entry(args, 0)))
+	{		
+		int argc;
+		
+		VALUE *argv;
+		argc = RARRAY_LEN(args);
+		argv = ALLOC_N(VALUE, argc);
+		MEMCPY(argv, RARRAY_PTR(args), VALUE, argc);
+		return rb_call_super(argc, argv);
+	}
+	name = rb_ary_shift(args);
+	name_string = rb_funcall(name, rb_intern("to_s"), 0);
+		
+	rDict = rb_iv_get(self,"@pdict");
+	
+	pDict = rpObjectGetPyObject(rDict);
+	
+	pCalled = PyDict_GetItemString(pDict, STR2CSTR(name_string));
+	Py_XINCREF(pCalled);
+	
+	result = ptorObjectKeep(pCalled);
+	
+	if(rb_obj_is_instance_of(result, cRubyPyFunction))
+	{
+		ret = rpCall(pCalled, args);
+		return ret;
+	}
+	else if(rb_obj_is_instance_of(result, cRubyPyClass)&&(rb_funcall(args, rb_intern("empty?"), 0) == Qfalse)&&PyCallable_Check(pCalled))
+	{
+		ret = rpCall(pCalled, args);
+		return ret;
+	}
+	
+	return result;
+	
+}
+
+
+/*
+A wrapper class for Python Modules.
+
+Methods calls are delegated to the equivalent Python methods / functions. Attribute references
+return either the equivalent attribute converted to a native Ruby type, or wrapped reference 
+to a Python object. RubyPyModule instances should be created through the use of RubyPython.import.
+
+*/
+void Init_RubyPyModule()
+{
+	cRubyPyModule = rb_define_class_under(mRubyPythonBridge,"RubyPyModule", cRubyPyObject);
+	rb_define_method(cRubyPyModule,"initialize", rpModuleInit, 1);
+	rb_define_method(cRubyPyModule,"method_missing", rpModuleDelegate,- 2);
+}