rubypython 0.2.0

data/ext/rubypython_bridge/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+dir_config("rubypython_bridge")
+find_library("python2.5",nil)
+find_header("python2.5/Python.h")
+
+create_makefile("rubypython_bridge")

data/ext/rubypython_bridge/ptor.c

@@ -0,0 +1,178 @@
+#include "ptor.h"
+
+VALUE ptor_string(PyObject* pString)
+{
+	if(!PyString_Check(pString)) return Qnil;
+	
+	char *cstr;
+	cstr=malloc(PyString_Size(pString)*sizeof(char));
+	strcpy(cstr,PyString_AsString(pString));
+	return rb_str_new2(cstr);
+}
+
+VALUE ptor_list(PyObject* pList)
+{
+	if(!PyList_Check(pList)) return Qnil;
+	VALUE rArray;
+	VALUE rElement;
+	PyObject* element;
+	int i=0;
+	
+	rArray=rb_ary_new();
+	int list_size=PyList_Size(pList);
+	for(i=0;i<list_size;i++)
+	{
+		element=PyList_GetItem(pList,i);
+		Py_INCREF(element);
+		rElement=ptor_obj(element);
+		rb_ary_push(rArray,rElement);
+	}
+	return rArray;
+}
+
+VALUE ptor_int(PyObject* pNum)
+{
+	VALUE rNum;
+	if(!PyInt_Check(pNum)) return Qnil;
+	rNum=INT2NUM(PyInt_AsLong(pNum));
+	return rNum;
+	
+}
+
+VALUE ptor_long(PyObject* pNum)
+{
+	VALUE rNum;
+	long cNum;
+	if(!PyLong_Check(pNum)) return Qnil;
+	cNum=PyLong_AsLong(pNum);
+	if(PyErr_ExceptionMatches(PyExc_OverflowError))
+	{
+		raise_PyError();
+		return Qnil;
+	}
+	rNum=INT2NUM(cNum);
+	return rNum;
+	
+}
+
+VALUE ptor_float(PyObject* pNum)
+{
+	VALUE rNum;
+	if(!PyFloat_Check(pNum)) return Qnil;
+	rNum=rb_float_new(PyFloat_AsDouble(pNum));
+	return rNum;
+}
+
+VALUE ptor_tuple(PyObject* pTuple)
+{
+	VALUE rArray;
+	PyObject* pList;
+	if(!PyTuple_Check(pTuple)) return Qnil;
+	pList=PySequence_List(pTuple);
+	rArray=ptor_list(pList);
+	Py_DECREF(pList);
+	return rArray;
+}
+
+
+VALUE ptor_dict(PyObject* pDict)
+{
+	VALUE rHash;
+	if(!PyDict_Check(pDict)) return Qnil;
+	rHash=rb_hash_new();
+	PyObject *key,*val;
+	Py_ssize_t pos=0;
+	VALUE rKey,rVal;
+	while(PyDict_Next(pDict,&pos,&key,&val))
+	{
+		Py_XINCREF(key);
+		Py_XINCREF(val);
+		rKey=ptor_obj(key);
+		rVal=ptor_obj(val);
+		if(rKey==Qnil) continue;
+		rb_hash_aset(rHash,rKey,rVal);
+	}
+	return rHash;
+}
+
+static VALUE ptor_obj_core(PyObject *pObj,int destructive)
+{
+	VALUE rObj;
+	if(PyObject_TypeCheck(pObj,&PyString_Type))
+	{
+		rObj=ptor_string(pObj);
+		if(destructive) Py_DECREF(pObj);
+		return rObj;
+	}
+	
+	if(PyObject_TypeCheck(pObj,&PyList_Type))
+	{
+		rObj=ptor_list(pObj);
+		if(destructive) Py_DECREF(pObj);
+		return rObj;
+	}
+	if(PyObject_TypeCheck(pObj,&PyInt_Type))
+	{
+		rObj=ptor_int(pObj);
+		if(destructive) Py_DECREF(pObj);
+		return rObj;
+	}
+	if(PyObject_TypeCheck(pObj,&PyLong_Type))
+	{
+		rObj=ptor_long(pObj);
+		if(destructive) Py_DECREF(pObj);
+		return rObj;
+	}
+	if(PyObject_TypeCheck(pObj,&PyFloat_Type))
+	{
+		rObj=ptor_float(pObj);
+		if(destructive) Py_DECREF(pObj);
+		return rObj;
+	}
+	if(PyObject_TypeCheck(pObj,&PyTuple_Type))
+	{
+		rObj=ptor_tuple(pObj);
+		if(destructive) Py_DECREF(pObj);
+		return rObj;
+	}
+	if(PyObject_TypeCheck(pObj,&PyDict_Type))
+	{
+		rObj=ptor_dict(pObj);
+		if(destructive) Py_DECREF(pObj);
+		return rObj;
+	}
+
+	if(pObj==Py_True)
+	{
+		if(destructive) Py_DECREF(Py_True);
+		return Qtrue;
+	}
+	if(pObj==Py_False)
+	{
+		if(destructive) Py_DECREF(Py_False);
+		return Qfalse;
+	}
+	if(pObj==Py_None)
+	{
+		return Qnil;
+	}
+	if(PyFunction_Check(pObj)||PyMethod_Check(pObj)||!PyObject_HasAttrString(pObj,"__dict__"))
+	{
+		return rp_func_from_function(pObj);
+
+	}	
+	return rp_cla_from_class(pObj);
+}
+VALUE ptor_obj_no_destruct(PyObject *pObj)
+{
+	VALUE rObj;
+	rObj=ptor_obj_core(pObj,0);
+	return rObj;
+}
+VALUE ptor_obj(PyObject* pObj)
+{
+	VALUE rObj;
+	rObj=ptor_obj_core(pObj,1);
+	return rObj;
+}
+

data/ext/rubypython_bridge/ptor.h

@@ -0,0 +1,31 @@
+#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);
+
+
+
+#endif /* _PTOR_H_ */

data/ext/rubypython_bridge/rp_error.c

@@ -0,0 +1,23 @@
+#include "rp_error.h"
+
+VALUE ePythonError;
+
+void rp_pythonerror()
+{
+	PyObject *pType,*pValue,*pTraceback;
+	PyObject *pTypeName;
+	PyErr_Fetch(&pType,&pValue,&pTraceback);
+	pTypeName=PyObject_GetAttrString(pType,"__name__");
+	Py_XDECREF(pType);
+	rb_raise(ePythonError,"%s:(%s)\n",STR2CSTR(ptor_obj(pTypeName)),STR2CSTR(ptor_obj(pValue)));
+	Py_XDECREF(pTraceback);
+}
+
+/*
+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);
+}

data/ext/rubypython_bridge/rp_error.h

@@ -0,0 +1,8 @@
+#include "config.h"
+
+#ifndef _RP_ERROR_H_
+#define _RP_ERROR_H_
+
+void rp_pythonerror();
+
+#endif /* _RP_ERROR_H_ */

data/ext/rubypython_bridge/rp_object.c

@@ -0,0 +1,237 @@
+#include "rp_object.h"
+#include "stdio.h"
+
+extern VALUE mRubyPythonBridge;
+
+VALUE cRubyPyObject;
+VALUE cRubyPyModule;
+VALUE cRubyPyClass;
+VALUE cRubyPyFunction;
+
+void rp_obj_mark(PObj* self)
+{}
+
+void rp_obj_free(PObj* self)
+{
+	if(Py_IsInitialized()&&self->pObject)
+	{
+		Py_XDECREF(self->pObject);
+	}
+	free(self);
+}
+
+
+/*
+Decreases the reference count on the object wrapped by this instance.
+This is used for cleanup in RubyPython.stop. RubyPyObject instance automatically
+decrease the reference count on their associated objects before they are garbage collected.
+*/
+VALUE rp_obj_free_pobj(VALUE self)
+{
+	PObj *cself;
+	Data_Get_Struct(self,PObj,cself);
+	if(Py_IsInitialized()&&cself->pObject)
+	{
+		Py_XDECREF(cself->pObject);
+		cself->pObject=NULL;
+		return Qtrue;
+	}
+	return Qfalse;
+}
+
+VALUE rp_obj_alloc(VALUE klass)
+{
+	PObj* self=ALLOC(PObj);
+	self->pObject=NULL;
+	return Data_Wrap_Struct(klass,rp_obj_mark,rp_obj_free,self);
+}
+
+
+PyObject* rp_obj_pobject(VALUE self)
+{
+	PObj *cself;
+	Data_Get_Struct(self,PObj,cself);
+	return cself->pObject;
+}
+
+/*
+Returns the name of the Python object which this instance wraps.
+
+*/
+VALUE rp_obj_name(VALUE self)
+{
+	if(Py_IsInitialized())
+	{
+	PyObject *pObject;
+	pObject=rp_obj_pobject(self);
+	return ptor_obj(PyObject_GetAttrString(pObject,"__name__"));		
+	}
+	return rb_str_new2("__FREED__");
+
+}
+
+VALUE rp_obj_from_pyobject(PyObject *pObj)
+{
+	PObj* self;
+	VALUE rObj=rb_class_new_instance(0,NULL,cRubyPyObject);
+	Data_Get_Struct(rObj,PObj,self);
+	self->pObject=pObj;
+	return rObj;
+}
+
+
+VALUE rp_cla_from_class(PyObject *pClass)
+{
+	PObj* self;
+	VALUE rClass=rb_class_new_instance(0,NULL,cRubyPyClass);
+	Data_Get_Struct(rClass,PObj,self);
+	self->pObject=pClass;
+	return rClass;
+}
+
+VALUE rp_func_from_function(PyObject *pFunc)
+{
+	PObj* self;
+	VALUE rFunc=rb_class_new_instance(0,NULL,cRubyPyFunction);
+	Data_Get_Struct(rFunc,PObj,self);
+	self->pObject=pFunc;
+	return rFunc;
+}
+
+VALUE rp_mod_call_func(VALUE self,VALUE func_name,VALUE args)
+{
+	PObj *cself;
+	Data_Get_Struct(self,PObj,cself);
+	PyObject *pModule,*pFunc;
+	VALUE rReturn;
+	
+	pModule=cself->pObject;
+	pFunc=rp_get_func_with_module(pModule,func_name);
+	rReturn=rp_call_func(pFunc,args);
+	Py_XDECREF(pFunc);
+	
+	return rReturn;
+	
+}
+
+int rp_has_attr(VALUE self,VALUE func_name)
+{
+	
+	PObj *cself;
+	VALUE rName;
+	Data_Get_Struct(self,PObj,cself);
+	rName=rb_funcall(func_name,rb_intern("to_s"),0);
+	if(PyObject_HasAttrString(cself->pObject,STR2CSTR(rName))) return 1;
+	return 0;
+}
+
+//:nodoc:
+VALUE rp_mod_init(VALUE self, VALUE mname)
+{
+	PObj* cself;
+	Data_Get_Struct(self,PObj,cself);
+	cself->pObject=rp_get_module(mname);
+	VALUE rDict;
+	PyObject *pModuleDict;
+	pModuleDict=PyModule_GetDict(cself->pObject);
+	Py_XINCREF(pModuleDict);
+	rDict=rp_cla_from_class(pModuleDict);
+	rb_iv_set(self,"@pdict",rDict);
+	return self;
+}
+
+//Not completely accurate
+int rp_is_func(VALUE pObj)
+{
+	PObj* self;
+	Data_Get_Struct(pObj,PObj,self);
+	Py_XINCREF(self->pObject);
+	return (PyFunction_Check(self->pObject)||PyMethod_Check(self->pObject));
+}
+
+//:nodoc:
+VALUE rp_mod_delegate(VALUE self,VALUE args)
+{
+	VALUE name,name_string,rDict,result;
+	PObj *pDict;
+	PyObject *pCalled;
+	if(!rp_has_attr(self,rb_ary_entry(args,0)))
+	{		
+		int argc;
+		
+		VALUE *argv;
+		argc=RARRAY(args)->len;
+		argv=ALLOC_N(VALUE,argc);
+		MEMCPY(argv,RARRAY(args)->ptr,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");
+	Data_Get_Struct(rDict,PObj,pDict);
+	pCalled=PyDict_GetItemString(pDict->pObject,STR2CSTR(name_string));
+	result=ptor_obj_no_destruct(pCalled);
+	if(rb_obj_is_instance_of(result,cRubyPyFunction))
+	{
+		return rp_call_func(pCalled,args);
+	}
+	return result;
+	
+}
+
+/*
+A wrapper class for Python objects that allows them to manipulated from within ruby.
+
+Important wrapper functionality is found in the RubyPyModule, RubyPyClass, and RubyPyFunction
+classes which wrap Python objects of similar names.
+
+*/
+inline void Init_RubyPyObject()
+{
+	cRubyPyObject=rb_define_class_under(mRubyPythonBridge,"RubyPyObject",rb_cObject);
+	rb_define_alloc_func(cRubyPyObject,rp_obj_alloc);
+	rb_define_method(cRubyPyObject,"free_pobj",rp_obj_free_pobj,0);
+	rb_define_method(cRubyPyObject,"__name",rp_obj_name,0);
+	
+}
+
+
+/*
+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",rp_mod_init,1);
+	rb_define_method(cRubyPyModule,"method_missing",rp_mod_delegate,-2);
+}
+
+/*
+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);
+}
+
+// 
+// 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);
+}