rubypython 0.2.0

data/ext/rubypython_bridge/rp_object.h

@@ -0,0 +1,46 @@
+#include "config.h"
+#include "ptor.h"
+#include "rtop.h"
+#include "cbridge.h"
+
+#ifndef _RP_OBJECT_H_
+#define _RP_OBJECT_H_
+
+struct RubyPyObj 
+{
+	PyObject* pObject;
+};
+
+typedef struct RubyPyObj PObj;
+
+void rp_obj_mark(PObj* self);
+
+void rp_obj_free(PObj* self);
+
+VALUE rp_obj_alloc(VALUE klass);
+
+PyObject* rp_obj_pobject(VALUE self);
+
+VALUE rp_obj_name(VALUE self);
+
+
+//Ruby wrapper for Python Modules
+VALUE rp_mod_init(VALUE self,VALUE mname);
+
+int rp_has_attr(VALUE self,ID func_hame);
+
+VALUE rp_mod_call_func(VALUE self,VALUE func_name,VALUE args);
+
+VALUE rp_mod_delegate(VALUE self,VALUE args);
+
+//Ruby wrapper for Python classes
+
+VALUE rp_cla_from_class(PyObject *pClass);
+
+VALUE rp_func_from_function(PyObject *pFunc);
+
+int rp_is_func(VALUE pObj);
+
+VALUE rp_obj_from_pyobject(PyObject *pObj);
+
+#endif /* _RP_OBJECT_H_ */

data/ext/rubypython_bridge/rtop.c

@@ -0,0 +1,151 @@
+#include "rtop.h"
+
+PyObject* rtop_string(VALUE rString)
+{
+	PyObject* pString;
+	char *cString;
+	char *cStringCopy;
+	cString=STR2CSTR(rString);
+	cStringCopy=malloc(strlen(cString)*sizeof(char));
+	strcpy(cStringCopy,cString);
+	pString=PyString_FromString(cStringCopy);
+	return pString;
+}
+
+
+PyObject* rtop_array_list(VALUE rArray)
+{
+	PyObject* pList;
+	int size=RARRAY(rArray)->len;
+	pList=PyList_New(size);
+	int i;
+	for(i=0;i<size;i++)
+	{
+		PyList_SetItem(pList,i,rtop_obj(rb_ary_entry(rArray,i),0));
+	}
+	return pList;
+}
+
+PyObject* rtop_array_tuple(VALUE rArray)
+{
+	PyObject *pTuple,*pList;
+	pList=rtop_array_list(rArray);
+	pTuple=PySequence_Tuple(pList);
+	Py_XDECREF(pList);
+	return pTuple;
+}
+
+PyObject* rtop_hash(VALUE rHash)
+{
+	PyObject *pDict,*pKey,*pVal;
+	VALUE rKeys=rb_funcall(rHash,rb_intern("keys"),0);
+	VALUE rKey,rVal;
+	int i;
+	
+	pDict=PyDict_New();
+	for(i=0;i<RARRAY(rKeys)->len;i++)
+	{
+		rKey=rb_ary_entry(rKeys,i);
+		rVal=rb_hash_aref(rHash,rKey);
+		PyDict_SetItem(pDict,rtop_obj(rKey,1),rtop_obj(rVal,0));
+	}
+	return pDict;
+}
+
+PyObject* rtop_fixnum(VALUE rNum)
+{
+	PyObject* pNum;
+	long cNum=NUM2LONG(rNum);
+	pNum=PyInt_FromLong(cNum);
+	return pNum;
+}
+
+PyObject* rtop_bignum(VALUE rNum)
+{
+	PyObject* pNum;
+	long cNum=NUM2LONG(rNum);
+	pNum=PyLong_FromLong(cNum);
+	return pNum;
+}
+
+PyObject* rtop_float(VALUE rNum)
+{
+	PyObject* pNum;
+	double cNum=NUM2DBL(rNum);
+	pNum=PyFloat_FromDouble(cNum);
+	return pNum;
+}
+
+PyObject* rtop_false()
+{
+	Py_RETURN_FALSE;
+}
+
+PyObject* rtop_true()
+{
+	Py_RETURN_TRUE;
+}
+
+PyObject* rtop_symbol(VALUE rSymbol)
+{
+	PyObject* pString;
+	pString=PyString_FromString(rb_id2name(rSymbol));
+	return pString;
+
+}
+PyObject* rtop_obj(VALUE rObj,int is_key)
+{
+	PyObject *pObj;
+	VALUE rInspect;
+	switch(TYPE(rObj))
+	{
+		case T_STRING:
+			pObj=rtop_string(rObj);
+			break;
+			
+		case T_ARRAY:
+			if(is_key) pObj=rtop_array_tuple(rObj);
+			else
+			{
+				pObj=rtop_array_list(rObj);
+			}
+			break;
+			
+		case T_HASH:
+			pObj=rtop_hash(rObj);
+			break;
+		
+		case T_FIXNUM:
+			pObj=rtop_fixnum(rObj);
+			break;
+		
+		case T_BIGNUM:
+			pObj=rtop_bignum(rObj);
+			break;
+		
+		case T_FLOAT:
+			pObj=rtop_float(rObj);
+			break;
+			
+		case T_NIL:
+			pObj=Py_None;
+			break;
+			
+		case T_TRUE:
+			pObj=rtop_true();
+			break;
+			
+		case T_FALSE:
+			pObj=rtop_false();
+			break;
+		
+		case T_SYMBOL:
+			pObj=rtop_symbol(rObj);
+			break;
+		
+		default:
+			rInspect=rb_inspect(rObj);
+			pObj=rtop_string(rInspect);
+	}
+	return pObj;
+}

data/ext/rubypython_bridge/rtop.h

@@ -0,0 +1,22 @@
+#include "config.h"
+
+#ifndef _RP_ERROR_H_
+#include "rp_error.h"
+#endif
+
+#ifndef _RTOP_H_
+#define _RTOP_H_
+PyObject* rtop_string(VALUE rString);
+PyObject* rtop_array_list(VALUE rArray);
+PyObject* rtop_array_tuple(VALUE rArray);
+PyObject* rtop_hash(VALUE rHash);
+PyObject* rtop_fixnum(VALUE rNum);
+PyObject* rtop_bignum(VALUE rNum);
+PyObject* rtop_float(VALUE rNum);
+PyObject* rtop_false(void);
+PyObject* rtop_true(void);
+PyObject* rtop_symbol(VALUE rSymbol);
+
+PyObject* rtop_obj(VALUE rObj,int is_key);
+
+#endif /* _RTOP_H_ */

data/ext/rubypython_bridge/rubypython_bridge.c

@@ -0,0 +1,100 @@
+#include "rubypython_bridge.h"
+
+VALUE mRubyPythonBridge;
+extern VALUE cRubyPyObject;
+extern VALUE cRubyPyModule;
+extern VALUE cRubyPyClass;
+
+static VALUE func_with_module(VALUE self, VALUE args)
+{
+	int started_here=safe_start();
+	VALUE module,func,return_val;
+	if(RARRAY(args)->len<2) return Qfalse;
+	module=rb_ary_shift(args);
+	func=rb_ary_shift(args);
+	return_val=rp_call_func_with_module_name(module,func,args);
+	safe_stop(started_here);
+	return return_val;
+}
+
+static VALUE rp_import_module(VALUE self,VALUE module)
+{
+	VALUE instance=rb_class_instance_new(1,&module,cRubyPyModule);
+	return instance;
+}
+
+
+
+/*
+* call-seq: import(modname)
+* 
+* imports a python file_module using the interpreter and returns a ruby wrapper
+
+*/
+static VALUE rp_import(VALUE self,VALUE mname)
+{
+	return rb_class_new_instance(1,&mname,cRubyPyModule);
+}
+
+static VALUE rp_python_block(VALUE self)
+{
+	rb_funcall(self,rb_intern("start"),0);
+	rb_obj_instance_eval(0,NULL,self);
+	rb_funcall(self,rb_intern("stop"),0);
+	
+}
+
+
+
+/*
+* call-seq: start()
+*
+* Starts the python interpreter
+* 	RubyPythonBridge.start
+*/
+VALUE rp_start(VALUE self)
+{
+	
+
+	if(Py_IsInitialized())
+	{
+		return Qfalse;
+	}
+	Py_Initialize();
+	return Qtrue;
+}
+
+VALUE rp_stop(VALUE self)
+{
+	
+	if(Py_IsInitialized())
+	{
+		Py_Finalize();
+		return Qtrue;
+	}
+	return Qfalse;
+	
+}
+
+
+/*
+* Module containing an interface to the the python interpreter.
+*
+* Use RubyPython instead.
+*/
+
+void Init_rubypython_bridge()
+{
+	mRubyPythonBridge=rb_define_module("RubyPythonBridge");
+	rb_define_module_function(mRubyPythonBridge,"func",func_with_module,-2);
+	rb_define_module_function(mRubyPythonBridge,"import_module",rp_import_module,1); 
+	rb_define_module_function(mRubyPythonBridge,"start",rp_start,0);
+	rb_define_module_function(mRubyPythonBridge,"stop",rp_stop,0);
+	rb_define_module_function(mRubyPythonBridge,"run",rp_python_block,0);
+	rb_define_module_function(mRubyPythonBridge,"import",rp_import,1);
+	Init_RubyPyObject();
+	Init_RubyPyModule();
+	Init_RubyPyClass();
+	Init_RubyPyFunction();
+	Init_RubyPyError();
+}

data/ext/rubypython_bridge/rubypython_bridge.h

@@ -0,0 +1,7 @@
+#include "config.h"
+
+#include "ptor.h" //PyObject to VALUE conversion
+#include "rtop.h" //VALUE to PyObject conversion
+#include "cbridge.h" //General interface functions
+#include "rp_error.h"
+#include "rp_object.h"

data/ext/rubypython_bridge/test.rb

@@ -0,0 +1,25 @@
+require "rubypython_bridge"
+p RubyPythonBridge.func_with_module("cPickle","loads","(dp1\nS'a'\nS'n'\ns(I1\nS'2'\ntp2\nI4\ns.")
+RubyPythonBridge.start
+CPickle=RubyPythonBridge.import("cPickle")
+p CPickle
+p CPickle.loads("(dp1\nS'a'\nS'n'\ns(I1\nS'2'\ntp2\nI4\ns.")
+p dumped_array=CPickle.dumps([1,2,3,4])
+p CPickle.loads(dumped_array)
+begin
+  p CPickle.splack
+rescue
+  p $!
+end
+p CPickle.PicklingError
+# p CPickle.instance_variable_get("@pdict")
+# CPickle.free_pobj
+ObjectSpace.each_object(RubyPythonBridge::RubyPyModule) do |o|
+  o.free_pobj
+end
+p RubyPythonBridge.stop
+
+RubyPythonBridge.start
+RubyPythonBridge.import "urllib"
+RubyPythonBridge.import "cPickle"
+RubyPythonBridge.stop

data/lib/rubypython.rb

@@ -0,0 +1,84 @@
+require 'rubypython_bridge.so'
+require 'wrapper_extension'
+
+
+=begin rdoc
+This module provides the direct user interface for the RubyPython extension.
+
+The majority of the functionality lies in the _RubyPythonBridge_ module, which is provided
+by the C extension. However, the end user should only worry about dealing with the RubyPython
+module as that is designed for user interaction. Furthermore the RubyPythonBridge is somewhat
+bad with memory management and using it directly may result in some strange crashes.
+
+==Usage  
+It is important to remember that the Python Interpreter must be started before the bridge
+is functional. This may be done by two methods. One is to use the +start+ function.
+This will start the embedded interpreter. If this approach is used, the user should
+remember to call RubyPython.stop when they are finished with Python.
+Example:
+  RubyPython.start
+  cPickle=RubyPython.import "cPickle"
+  puts cPickle.dumps "RubyPython is awesome!"
+  RubyPython.stop
+  
+The other method is preferable if one wants a simpler approach. This other method is to use
+<tt>RubyPython.run</tt>. run takes a block which is evaluated in the scope of the RubyPython module.
+In addition, the interpreter is started before the block is run and halted at its completion.
+This allows one to do something like the following:
+  RubyPython.run do
+    cPickle=import "cPickle"
+    puts cPickle.dumps "RubyPython is still awesome!"
+  end
+
+==Errors
+The RubyPythonModule defines a new error object, PythonError. Should any error occur within
+the Python interpreter, the class and value of the error will be passed back into ruby within
+the text of the raised PythonError.
+  irb(main):001:0> RubyPython.start
+  => true
+  irb(main):002:0> RubyPython.import "does not exist"
+  PythonError: ImportError:(No module named does not exist)
+
+  	from ./rubypython.rb:66:in `initialize'
+  	from ./rubypython.rb:66:in `import'
+  	from ./rubypython.rb:66:in `import'
+  	from (irb):2
+=end
+module RubyPython
+  
+  # Used to started the python interpreter. Delegates to RubyPythonBridge
+  # 
+  #   RubyPython.start
+  #   --Some python code--
+  #   RubyPython.stop
+  #   
+  # Also see, _stop_
+  def self.start() # true||false
+    RubyPythonBridge.start
+  end
+  
+  
+
+  # Used to end the python session. Adds some cleanup on top of RubyPythonBridge.stop
+  def self.stop() #=> true,false
+    ObjectSpace.each_object(RubyPythonBridge::RubyPyObject) do |o|
+      o.free_pobj
+    end
+    RubyPythonBridge.stop
+  end
+  
+  # Import the python module +mod+ and return it wrapped as a ruby object
+  def self.import(mod)
+    RubyPythonBridge.import(mod)
+  end
+  
+  # Handles the setup and cleanup involved with using the interpreter for you.
+  # Note that all Python object will be effectively scope to within the block
+  # as the embedded interpreter will be halted at its end.
+  def self.run(&block)
+    start
+    module_eval(&block)
+    stop
+  end
+
+end

data/lib/rubypython/version.rb

@@ -0,0 +1,9 @@
+module RubyPython
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end