rubypython 0.2.8 → 0.2.9

data/History.txt

@@ -1,3 +1,6 @@
+== 0.2.9 2009-10-19
+* Minor Enhancements
+	* Updated the C code to make it cleaner, more readable, and more maintainable.
 == 0.2.8 2009-10-05
 * Bug Fixes
 	* Some test files were improperly formatted (minor bug fix).
@@ -38,7 +41,7 @@
 	* Wrapped classes and instances should now behave as expected.
 	* Gave RubyPyClasses a "new" method for creating instances.
 	* Callable class can now be called provided that at least one argument is given
-	* A wrapped object's respond_to? method now has some relation to its actually methods.
+	* A wrapped object's respond_to? method now has some relation to its actual methods.
 	
 * Bug fixes
 	* Fixed bug with inspect method of RubyPyObject that caused a bus error when inspecting

data/Manifest.txt

@@ -1,4 +1,3 @@
-.autotest
 History.txt
 License.txt
 Manifest.txt
@@ -13,15 +12,28 @@ ext/rubypython_bridge/config.h
 ext/rubypython_bridge/extconf.rb
 ext/rubypython_bridge/ptor.c
 ext/rubypython_bridge/ptor.h
+ext/rubypython_bridge/rp_blankobject.c
+ext/rubypython_bridge/rp_blankobject.h
+ext/rubypython_bridge/rp_class.c
+ext/rubypython_bridge/rp_class.h
 ext/rubypython_bridge/rp_error.c
 ext/rubypython_bridge/rp_error.h
+ext/rubypython_bridge/rp_function.c
+ext/rubypython_bridge/rp_function.h
+ext/rubypython_bridge/rp_instance.c
+ext/rubypython_bridge/rp_instance.h
+ext/rubypython_bridge/rp_module.c
+ext/rubypython_bridge/rp_module.h
 ext/rubypython_bridge/rp_object.c
 ext/rubypython_bridge/rp_object.h
+ext/rubypython_bridge/rp_util.c
+ext/rubypython_bridge/rp_util.h
 ext/rubypython_bridge/rtop.c
 ext/rubypython_bridge/rtop.h
 ext/rubypython_bridge/rubypython_bridge.c
 ext/rubypython_bridge/rubypython_bridge.h
 lib/rubypython.rb
+lib/rubypython/session.rb
 lib/rubypython/version.rb
 lib/rubypython/wrapper_extensions.rb
 script/console
@@ -34,10 +46,13 @@ tasks/environment.rake
 tasks/extconf.rake
 tasks/extconf/rubypython_bridge.rake
 tasks/website.rake
+test/python_helpers/objects.py
+test/python_helpers/objects.pyc
 test/test.wav
 test/test_helper.rb
 test/test_rubypython.rb
 test/test_rubypython_bridge_extn.rb
+test/test_session.rb
 website/index.html
 website/index.txt
 website/javascripts/rounded_corners_lite.inc.js

data/PostInstall.txt

@@ -1,7 +1,7 @@
 
 For more information on RubyPython, see http://rubypython.rubyforge.org
 
-If you find a bug, or have any suggestions, email me at: achatesavc+rubypython@gmail.com
+If you find a bug, or have any suggestions, email me at: raineszm+rubypython@gmail.com
 
 If you would like to help develop RubyPython, also send me an email.
 

data/README.txt

@@ -22,8 +22,13 @@
 	RubyPython.stop
 	
 == REQUIREMENTS:
-	Python must be installed. Currently, RubyPython requires python2.5 but it may soon be  able to work with other versions. It should work fine with Python 2.4 but you may experience issues with lower versions. I have only tested it on Mac OSX 10.5, so I'm not sure what parts may need correcting for other systems. 
-
+	
+	* Python >=2.4, < 3.0
+	
+	Note: Rubypython has been test on Mac OS 10.5.x and 10.6.1 as well
+	as Ubuntu Jaunty 9.04.
+	
+	
 == INSTALL:
 
 	sudo gem install rubypython

data/config/hoe.rb

@@ -50,20 +50,20 @@ end
 
 # Generate all the Rake tasks
 # Run 'rake -T' to see list of generated tasks (from gem root directory)
-$hoe = Hoe.new(GEM_NAME, VERS) do |p|
-  p.developer(AUTHOR, EMAIL)
-  p.description = DESCRIPTION
-  p.summary = DESCRIPTION
-  p.url = HOMEPATH
-  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
-  p.test_globs = ["test/**/test_*.rb"]
-  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
-
+$hoe = Hoe.spec(GEM_NAME) do
+  self.developer(AUTHOR, EMAIL)
+  self.description = DESCRIPTION
+  self.summary = DESCRIPTION
+  self.url = HOMEPATH
+  self.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  self.test_globs = ["test/**/test_*.rb"]
+  self.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+  self.version = VERS
   # == Optional
-  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  self.changes = self.paragraphs_of("History.txt", 0..1).join("\n\n")
   #p.extra_deps = EXTRA_DEPENDENCIES
 
-  p.spec_extras = {
+  self.spec_extras = {
     :requirements => ["Python, ~>2.4"]
   }    # A hash of extra values to set in the gemspec.
   end
@@ -72,4 +72,4 @@ CHANGES = $hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
 PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
 $hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
 $hoe.rsync_args = '-av --delete --ignore-errors'
-$hoe.spec.post_install_message = File.open(File.dirname(__FILE__) + "/../PostInstall.txt").read rescue ""
+$hoe.spec.post_install_message = File.open(File.dirname(__FILE__) + "/../PostInstall.txt").read rescue ""

data/ext/rubypython_bridge/cbridge.c

@@ -1,147 +1,149 @@
 #include "cbridge.h"
 
-#define SAFE_START(reg) do { \
-	reg=0; \
-	if(!Py_IsInitialized())\
-	{\
-		Py_Initialize();\
-		reg=1;\
-	}\
-} while(0)
-
-#define SAFE_END(reg) do {\
-	if(reg && Py_IsInitialized()) \
-	{\
-		Py_Finalize(); \
-	} \
-	} while(0)
-	
-int safe_start()
+#import "rtop.h"
+
+/* Attempt to initialize the embedded python interpreter.
+  Return 1 if we initialize it here and 0 if the interpreter is
+  already running.
+*/
+int rpSafeStart()
 {
 	int here;
-	SAFE_START(here);
+	
+	if(!Py_IsInitialized())
+	{
+		Py_Initialize();
+		here = 1;
+	}
+	
 	return here;
 }
 
-void safe_stop(int here)
+/* Attempt to stop the embedded python interpreter.*/
+void rpSafeStop(int here)
 {
-	SAFE_END(here);
+	
+	if(here && Py_IsInitialized())
+	{
+		Py_Finalize();
+	}
 }
 
-
-
-VALUE rp_call_func_with_module_name(VALUE module,VALUE name,VALUE args)
+VALUE rpCall(PyObject* pFunc,  VALUE args)
 {
-	char* func_name=STR2CSTR(name);
-	VALUE rArgs;
-	VALUE rReturn;
-	if(!(TYPE(args)==T_ARRAY))
+	VALUE rArgs, rReturn;
+	PyObject *pReturn, *pArgs;
+
+/* 	Check to see if the passed argument is an array. If it is we
+ * 	box it in another array so that the presentation of
+ * 	arguments is the same i.e. each method is supllied with an
+ * 	array of arguments.
+ */
+	if(!(TYPE(args) == T_ARRAY))
 	{
-		rArgs=rb_ary_new();
-		rb_ary_push(rArgs,args);
+		
+		rArgs = rb_ary_new();
+		rb_ary_push(rArgs, args);
 	}
 	else
 	{
-		rArgs=args;
+		rArgs = args;
 	}
+
+	// Convert the supplied arguments to python objects
+	pArgs = rtopObject(rArgs, 1);
+	
+	// Execute the function and obtain a pointer to the return object
+	pReturn = PyObject_CallObject(pFunc, pArgs);
 	
-	PyObject *pModuleName,*pModule,*pFunc,*pArgs,*pReturn;
-	if(rb_eql(module,rb_str_new2("builtins")))
-	{
-		module=rb_str_new2("__builtins__");
-	}
-	pModuleName=rtop_obj(module,0);
-	pModule=PyImport_Import(pModuleName);
-	Py_XDECREF(pModuleName);
 	if(PyErr_Occurred())
 	{
-		rp_pythonerror();
+		Py_XDECREF(pArgs);
+		Py_XDECREF(pReturn);
+		rpPythonError();
 		return Qnil;
 	}
+
+	rReturn = ptorObjectKeep(pReturn);	
+	Py_XDECREF(pArgs);
+
+	return rReturn;
+}
+
+VALUE rpCallWithModule(VALUE module, VALUE name, VALUE args)
+{
+
+	VALUE rArgs;
+	VALUE rReturn;
+
+	PyObject *pModule, *pFunc, *pArgs, *pReturn;
+
+
+	// Load the requested python module
+	pModule = rpGetModule(module);
 	
+	// Get a pointer to the requested function
+	pFunc = rpGetFunctionWithModule(pModule, name);
 	
-	pFunc=PyObject_GetAttrString(pModule,func_name);
-	
-	pArgs=rtop_obj(rArgs,1);
+	Py_XDECREF(pModule);
 	
-	pReturn=PyObject_CallObject(pFunc,pArgs);
+	rReturn = rpCall(pFunc, args);
 	
+	// Check for an error and do any necessary cleanup before
+	// propagating error
 	if(PyErr_Occurred())
 	{
-		Py_XDECREF(pReturn);
-		Py_XDECREF(pArgs);
 		Py_XDECREF(pFunc);
-		Py_XDECREF(pModule);
-		rp_pythonerror();
+		rpPythonError();
 		return Qnil;
 	}
 	
-	rReturn=ptor_obj(pReturn);
-	
-	Py_XDECREF(pArgs);
+	// Cleanup temporary objects
 	Py_XDECREF(pFunc);
-	Py_XDECREF(pModule);
+
 	return rReturn;
 }
 
-PyObject* rp_get_module(VALUE mname)
+PyObject* rpGetModule(VALUE mname)
 {
-	if(rb_eql(mname,rb_str_new2("builtins")))
+	PyObject *pModule, *pModuleName;
+
+	// A little syntatic sugar here. We will allow users access the
+	// __builtins__ module under the name builtins
+	// FIXME: replace this with a call to rb_get_module
+	if(rb_eql(mname, rb_str_new2("builtins")))
 	{
-		mname=rb_str_new2("__builtins__");
+		mname = rb_str_new2("__builtins__");
 	}
-	PyObject *pModule,*pModuleName;
-	pModuleName=rtop_string(mname);
-	pModule=PyImport_Import(pModuleName);
+
+	pModuleName = rtopString(mname);
+	pModule = PyImport_Import(pModuleName);
 	Py_XDECREF(pModuleName);
+
 	if(PyErr_Occurred())
 	{
 		Py_XDECREF(pModule);
-		rp_pythonerror();
+		rpPythonError();
 		return Py_None;
 	}
+
 	return pModule;
 }
 
-PyObject* rp_get_func_with_module(PyObject* pModule,VALUE name)
+PyObject* rpGetFunctionWithModule(PyObject* pModule, VALUE name)
 {
 	PyObject *pFunc;
-	pFunc=PyObject_GetAttrString(pModule,STR2CSTR(name));
+
+	pFunc = PyObject_GetAttrString(pModule, STR2CSTR(name));
+
 	if(PyErr_Occurred())
 	{
 		Py_XDECREF(pFunc);
-		rp_pythonerror();
+		rpPythonError();
 		return Py_None;
 	}
+
 	return pFunc;
 }
 
-VALUE rp_call_func(PyObject* pFunc, VALUE args)
-{
-	VALUE rArgs,rReturn;
-	PyObject *pReturn,*pArgs;
-	if(!(TYPE(args)==T_ARRAY))
-	{
-		
-		rArgs=rb_ary_new();
-		rb_ary_push(rArgs,args);
-	}
-	else
-	{
-		rArgs=args;
-	}
-	pArgs=rtop_obj(rArgs,1);
-	pReturn=PyObject_CallObject(pFunc,pArgs);
-	
-	if(PyErr_Occurred())
-	{
-		Py_XDECREF(pArgs);
-		Py_XDECREF(pReturn);
-		rp_pythonerror();
-		return Qnil;
-	}
-	rReturn=ptor_obj_no_destruct(pReturn);
-	
-	Py_XDECREF(pArgs);
-	return rReturn;
-}
+

data/ext/rubypython_bridge/cbridge.h

@@ -1,25 +1,15 @@
 #include "config.h"
-#include "ptor.h"
-#include "rtop.h"
-#include "rp_error.h"
 
 #ifndef _BRIDGE_H_
 #define _BRIDGE_H_
+int rpSafeStart();
+void rpSafeStop(int);
 
-int safe_start();
-
-void safe_stop(int here);
-
-
-VALUE rp_call_func_with_module_name(VALUE module,VALUE name,VALUE args);
-
-PyObject* rp_get_module(VALUE mname);
-
-PyObject* rp_get_func_with_module(PyObject* pModule,VALUE name);
-
-VALUE rp_call_func(PyObject* pFunc, VALUE args);
-
+VALUE rpCallWithModule(VALUE, VALUE, VALUE);
+VALUE rpCall(PyObject*, VALUE);
 
+PyObject* rpGetModule(VALUE);
+PyObject* rpGetFunctionWithModule(PyObject*, VALUE);
 #endif /* _BRIDGE_H_ */
 
 

data/ext/rubypython_bridge/ptor.c

@@ -1,183 +1,237 @@
 #include "ptor.h"
 
-VALUE ptor_string(PyObject* pString)
+
+/* Note:
+   The conversion functions for the builtin types are just that,
+   conversion functions. They create a new Ruby object equivalent to
+   the given Python object, they do not wrap the Python object.
+
+ */
+
+VALUE ptorString(PyObject* pString)
 {
+  // Make sure pString is actually a string
 	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);
+	// Allocate a new string for Ruby and return it.
+	// Note that this is a new object, not a wrapper around a
+	// python object
+	char* cStr;
+	char* cStrCopy;
+	
+	cStr = PyString_AsString(pString);
+	
+	cStrCopy = malloc(PyString_Size(pString) * sizeof(char));
+
+	strcpy(cStrCopy, cStr);
+	
+	
+	return rb_str_new2(cStrCopy);
 }
 
-VALUE ptor_list(PyObject* pList)
+VALUE ptorList(PyObject* pList)
 {
+  // Verify that pList is a python list
 	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++)
+
+	int i = 0;
+
+	// Allocate a new Ruby array
+	rArray = rb_ary_new();
+
+	// Iteratively add converted elements to the new Ruby list
+	int list_size = PyList_Size(pList);
+	for(i = 0; i < list_size; i++)
 	{
-		element=PyList_GetItem(pList,i);
+		element = PyList_GetItem(pList, i);
 		Py_INCREF(element);
-		rElement=ptor_obj(element);
-		rb_ary_push(rArray,rElement);
+		rElement = ptorObject(element);
+		rb_ary_push(rArray, rElement);
 	}
 	return rArray;
 }
 
-VALUE ptor_int(PyObject* pNum)
+VALUE ptorInt(PyObject* pNum)
 {
-	VALUE rNum;
 	if(!PyInt_Check(pNum)) return Qnil;
-	rNum=INT2NUM(PyInt_AsLong(pNum));
+	
+	VALUE rNum;
+  
+	rNum = INT2NUM(PyInt_AsLong(pNum));
 	return rNum;
 	
 }
 
-VALUE ptor_long(PyObject* pNum)
+VALUE ptorLong(PyObject* pNum)
 {
+	if(!PyLong_Check(pNum)) return Qnil;
+
 	VALUE rNum;
 	long cNum;
-	if(!PyLong_Check(pNum)) return Qnil;
-	cNum=PyLong_AsLong(pNum);
+
+	cNum = PyLong_AsLong(pNum);
+
 	if(PyErr_ExceptionMatches(PyExc_OverflowError))
 	{
-		rp_pythonerror();
+		rpPythonError();
 		return Qnil;
 	}
-	rNum=INT2NUM(cNum);
+
+	rNum = INT2NUM(cNum);
+
 	return rNum;
 	
 }
 
-VALUE ptor_float(PyObject* pNum)
+VALUE ptorFloat(PyObject* pNum)
 {
-	VALUE rNum;
 	if(!PyFloat_Check(pNum)) return Qnil;
-	rNum=rb_float_new(PyFloat_AsDouble(pNum));
+
+	VALUE rNum;
+
+	rNum = rb_float_new(PyFloat_AsDouble(pNum));
+
 	return rNum;
 }
 
-VALUE ptor_tuple(PyObject* pTuple)
+VALUE ptorTuple(PyObject* pTuple)
 {
+	if(!PyTuple_Check(pTuple)) return Qnil;
+
 	VALUE rArray;
 	PyObject* pList;
-	if(!PyTuple_Check(pTuple)) return Qnil;
-	pList=PySequence_List(pTuple);
-	rArray=ptor_list(pList);
+
+	pList = PySequence_List(pTuple);
+	rArray = ptorList(pList);
 	Py_DECREF(pList);
+
 	return rArray;
 }
 
 
-VALUE ptor_dict(PyObject* pDict)
+VALUE ptorDict(PyObject* pDict)
 {
-	VALUE rHash;
 	if(!PyDict_Check(pDict)) return Qnil;
-	rHash=rb_hash_new();
+
+	VALUE rHash;
+	VALUE rKey, rVal;
 	PyObject *key,*val;
-	Py_ssize_t pos=0;
-	VALUE rKey,rVal;
+	Py_ssize_t pos = 0;
+
+	rHash = rb_hash_new();
+
 	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);
+		rKey = ptorObject(key);
+		rVal = ptorObject(val);
+		if(rKey == Qnil) continue;
+		rb_hash_aset(rHash, rKey, rVal);
 	}
+
 	return rHash;
 }
 
-static VALUE ptor_obj_core(PyObject *pObj,int destructive)
+static VALUE ptorObjectBasic(PyObject *pObj, int destructive)
 {
 	VALUE rObj;
+
+	// Test the Python object vs various types and convert / wrap it
+	// appropriately. If the destructive flag is set, we destroy
+	// the original.
+
 	if(PyObject_TypeCheck(pObj,&PyString_Type))
 	{
-		rObj=ptor_string(pObj);
+		rObj = ptorString(pObj);
 		if(destructive) Py_DECREF(pObj);
 		return rObj;
 	}
 	
 	if(PyObject_TypeCheck(pObj,&PyList_Type))
 	{
-		rObj=ptor_list(pObj);
+		rObj = ptorList(pObj);
 		if(destructive) Py_DECREF(pObj);
 		return rObj;
 	}
 	if(PyObject_TypeCheck(pObj,&PyInt_Type))
 	{
-		rObj=ptor_int(pObj);
+		rObj = ptorInt(pObj);
 		if(destructive) Py_DECREF(pObj);
 		return rObj;
 	}
 	if(PyObject_TypeCheck(pObj,&PyLong_Type))
 	{
-		rObj=ptor_long(pObj);
+		rObj = ptorLong(pObj);
 		if(destructive) Py_DECREF(pObj);
 		return rObj;
 	}
 	if(PyObject_TypeCheck(pObj,&PyFloat_Type))
 	{
-		rObj=ptor_float(pObj);
+		rObj = ptorFloat(pObj);
 		if(destructive) Py_DECREF(pObj);
 		return rObj;
 	}
 	if(PyObject_TypeCheck(pObj,&PyTuple_Type))
 	{
-		rObj=ptor_tuple(pObj);
+		rObj = ptorTuple(pObj);
 		if(destructive) Py_DECREF(pObj);
 		return rObj;
 	}
 	if(PyObject_TypeCheck(pObj,&PyDict_Type))
 	{
-		rObj=ptor_dict(pObj);
+		rObj = ptorDict(pObj);
 		if(destructive) Py_DECREF(pObj);
 		return rObj;
 	}
 
-	if(pObj==Py_True)
+	if(pObj == Py_True)
 	{
 		if(destructive) Py_DECREF(Py_True);
 		return Qtrue;
 	}
-	if(pObj==Py_False)
+	if(pObj == Py_False)
 	{
 		if(destructive) Py_DECREF(Py_False);
 		return Qfalse;
 	}
-	if(pObj==Py_None)
+	if(pObj == Py_None)
 	{
 		return Qnil;
 	}
 	if(PyFunction_Check(pObj)||PyMethod_Check(pObj)||!PyObject_HasAttrString(pObj,"__dict__"))
 	{
-		return rp_func_from_function(pObj);
+		return rpFunctionFromPyObject(pObj);
 
 	}
 	if(PyInstance_Check(pObj))
 	{
-		rObj=rp_inst_from_instance(pObj);
+		rObj = rpInstanceFromPyObject(pObj);
 		return rObj;
 	}
-	return rp_cla_from_class(pObj);
+
+	// Fallthrough behavior: The object is a class which should be wrapped
+	return rpClassFromPyObject(pObj);
 }
-VALUE ptor_obj_no_destruct(PyObject *pObj)
+
+// Convert a Python object to a Ruby object and destroy the original
+VALUE ptorObjectKeep(PyObject *pObj)
 {
 	VALUE rObj;
-	rObj=ptor_obj_core(pObj,0);
+	rObj = ptorObjectBasic(pObj, 0);
 	return rObj;
 }
-VALUE ptor_obj(PyObject* pObj)
+
+
+// Convert a Python object to a Ruby object while keeping the original
+VALUE ptorObject(PyObject* pObj)
 {
 	VALUE rObj;
-	rObj=ptor_obj_core(pObj,1);
+	rObj = ptorObjectBasic(pObj, 1);
 	return rObj;
 }