rubypython 0.2.8 → 0.2.9

data/ext/rubypython_bridge/rubypython_bridge.c

@@ -1,6 +1,18 @@
 #include "rubypython_bridge.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" //Error propogation from Python to Ruby
+#include "rp_object.h"
+#include "rp_blankobject.h"
+#include "rp_util.h"
+#include "rp_module.h"
+#include "rp_class.h"
+#include "rp_function.h"
+
 VALUE mRubyPythonBridge;
+
 RUBY_EXTERN VALUE cRubyPyObject;
 RUBY_EXTERN VALUE cRubyPyModule;
 RUBY_EXTERN VALUE cRubyPyClass;
@@ -8,7 +20,8 @@ RUBY_EXTERN VALUE cBlankObject;
 
 
 /*
-call-seq: func(modname,funcname,*args)
+call - seq: func(modname, funcname, *args)
+
 Given a python module name _modname_ and a function name _funcname_ calls the given function
 with the supplied arguments.
 
@@ -17,28 +30,43 @@ Use builtins as the module for a built in function.
 */
 static VALUE func_with_module(VALUE self, VALUE args)
 {
-	int started_here=safe_start();
-	VALUE module,func,return_val;
-	if(RARRAY_LEN(args)<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);
+	// Before doing anything we attempt to start the interpreter
+	// Started here will be 1 if the interpreter is started by this
+	// function and zero otherwise
+	int started_here = rpSafeStart();
+	
+	VALUE module, func, return_val;
+	
+	// If we hav less than two arguments we cannot proceed.
+	// Perhaps it would make more sense to throw an error here.
+	if(RARRAY_LEN(args) < 2) return Qfalse;
+	
+	module = rb_ary_shift(args);
+	func = rb_ary_shift(args);
+	
+	// rpCallWithModule is defined in cbridge.c
+	return_val = rpCallWithModule(module, func, args);
+
+	// If we started the interpreter, we now halt it.
+	rpSafeStop(started_here);
+	
 	return return_val;
 }
 
+
 /*
-* call-seq: import(modname)
+* call - seq: import(modname)
 * 
 * Imports the python module _modname_ using the interpreter and returns a ruby wrapper
 */
-static VALUE rp_import(VALUE self,VALUE mname)
+static VALUE rp_import(VALUE self, VALUE mname)
 {
-	return rb_class_new_instance(1,&mname,cRubyPyModule);
+	return rb_class_new_instance(1,&mname, cRubyPyModule);
 }
 
+
 /*
-* call-seq: start()
+* call - seq: start()
 *
 * Starts the python interpreter
 */
@@ -51,11 +79,12 @@ VALUE rp_start(VALUE self)
 		return Qfalse;
 	}
 	Py_Initialize();
+	
 	return Qtrue;
 }
 
 /*
-* call-seq: stop()
+* call - seq: stop()
 *
 * Stop the python interpreter
 */
@@ -77,14 +106,13 @@ VALUE rp_stop(VALUE self)
 *
 * 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,"start",rp_start,0);
-	rb_define_module_function(mRubyPythonBridge,"stop",rp_stop,0);
-	rb_define_module_function(mRubyPythonBridge,"import",rp_import,1);
+	mRubyPythonBridge = rb_define_module("RubyPythonBridge");
+	rb_define_module_function(mRubyPythonBridge,"func", func_with_module,- 2);
+	rb_define_module_function(mRubyPythonBridge,"start", rp_start, 0);
+	rb_define_module_function(mRubyPythonBridge,"stop", rp_stop, 0);
+	rb_define_module_function(mRubyPythonBridge,"import", rp_import, 1);
 	Init_BlankObject();
 	Init_RubyPyObject();
 	Init_RubyPyModule();
@@ -93,4 +121,4 @@ void Init_rubypython_bridge()
 	Init_RubyPyError();
 	Init_RubyPyInstance();
 	
-}
+}

data/ext/rubypython_bridge/rubypython_bridge.h

@@ -1,11 +1,10 @@
+#include "config.h"
+
 #ifndef RUBY_19
+
+#ifndef RARRAY_LEN
 #define RARRAY_LEN(arr) (RARRAY(arr)->len)
 #define RARRAY_PTR(arr) (RARRAY(arr)->ptr)
 #endif
-#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"
+#endif

data/lib/rubypython.rb

@@ -80,7 +80,7 @@ module RubyPython
   #   RubyPython.stop
   #   
   # Also see, _stop_
-  def self.start() # true||false
+  def self.start() #=> true||false
     RubyPythonBridge.start
   end
   
@@ -117,7 +117,7 @@ module RubyPython
   # Simply starts the interpreter, runs the supplied block, and stops the interpreter.
   def self.session(&block)
     start
-    retval=block.call
+    retval = block.call
     stop
     return retval
   end

data/lib/rubypython/session.rb

@@ -0,0 +1,4 @@
+require File::expand_path(File.dirname(__FILE__) + '/../rubypython.rb') if RubyPython.nil?
+RubyPython.start
+
+at_exit {RubyPython.stop}

data/lib/rubypython/version.rb

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

data/test/python_helpers/objects.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python
+
+def identity(object):
+    return object
+
+class RubyPythonMockObject:
+    STRING = "STRING"
+    STRING_LIST = ["STRING1", "STRING2"]
+    INT = 1
+    INT_LIST = [1,1]
+    FLOAT = 1.0
+    FLOAT_LIST = [1.0,1.0]

data/test/test_rubypython.rb

@@ -16,86 +16,136 @@ class TestRubypython < Test::Unit::TestCase
   def test_delegation
     RubyPython.start
     cPickle=RubyPython.import("cPickle")
-    assert_instance_of(RubyPythonBridge::RubyPyModule,cPickle)
-    assert_equal({"a"=>"n", [1, "2"]=>4},cPickle.loads("(dp1\nS'a'\nS'n'\ns(I1\nS'2'\ntp2\nI4\ns."))
+    
+    assert_instance_of(RubyPythonBridge::RubyPyModule,
+                       cPickle,
+                       "Module object not returned by import.")
+    
+    assert_equal({"a"=>"n", [1, "2"]=>4},
+                 cPickle.loads("(dp1\nS'a'\nS'n'\ns(I1\nS'2'\ntp2\nI4\ns."),
+                 "Python pickle load test returned incorrect objects.")
+
     dumped_array=cPickle.dumps([1,2,3,4])
-    assert_equal([1,2,3,4],cPickle.loads(dumped_array))
-    assert_raise NoMethodError do
+    
+    assert_equal([1,2,3,4],
+                 cPickle.loads(dumped_array),
+                 "Pickled information was not retrieved correctly.")
+    
+    assert_raise(NoMethodError, "Rubypython failed to raise NoMethodError on call to nonexistent method") do
       cPickle.splack
     end
-    assert_instance_of(RubyPythonBridge::RubyPyClass,cPickle.PicklingError)
+    
+    assert_instance_of(RubyPythonBridge::RubyPyClass,
+                       cPickle.PicklingError,
+                       "Wrapped Python class was not of type RubyPyClass.")
+    
     cPickle.free_pobj
+    
     ObjectSpace.each_object(RubyPythonBridge::RubyPyObject) do |o|
       o.free_pobj
     end
-    assert(RubyPython.stop)
+    
+    assert(RubyPython.stop,"Interpreter did not halt correctly.")
   end
 
   def test_two_imports
     RubyPython.start
-    RubyPython.import "cPickle"
-    RubyPython.import "urllib"
+    assert_nothing_raised("Error raised on imports") do
+      RubyPython.import "cPickle"
+      RubyPython.import "urllib"
+    end
     RubyPython.stop
   end
 
   def test_propogate_python_error
     RubyPython.start
-    assert_raise PythonError do
+    
+    assert_raise(PythonError,"rubypython failed to propogate python error.") do
       RubyPython.import "slasdfj"
     end
+    
     RubyPython.stop
   end
 
   def test_run_method
     unpickled=nil
+    
     RubyPython.run do
       cPickle=import "cPickle"
       cPickle.inspect
       unpickled=cPickle.loads("(dp1\nS'a'\nS'n'\ns(I1\nS'2'\ntp2\nI4\ns.")
     end
-    assert_equal({"a"=>"n", [1, "2"]=>4},unpickled)
-    assert(!RubyPython.stop)
+    
+    assert_equal({"a"=>"n", [1, "2"]=>4},
+                 unpickled,
+                 "Incorrect object returned from cPickle.")
+    
+    assert(!RubyPython.stop, "RubyPython did not seem to halt at the correct time.")
   end
 
   def test_instance_method_delegation
     RubyPython.start
+    
     wave=RubyPython.import "wave"
     w=wave.open("test/test.wav","rb")
-    assert_equal(9600,w.getframerate)
+    assert_equal(9600,
+                 w.getframerate,
+                 "Wrapped wave library incorrectly passing framerate.")
     w.close
+    
     RubyPython.stop
   end
 
   def test_pymain_delegation
     RubyPython.start
-    assert_equal(42.to_f,PyMain.float(42))
+    
+    assert_equal(42.to_f,
+                 PyMain.float(42),
+                 "Integer conversion problems in Python.")
+    
     RubyPython.stop
   end
 
   def test_block_syntax
     returned=""
+    
     RubyPython.start
-    returned=PyMain.float(22) do |f|
+    
+    returned = PyMain.float(22) do |f|
       f*2
     end
-    assert_equal(44.0,returned)
+    
+    assert_equal(44.0,
+                 returned,
+                 "Wrapped Python object failed to correctly utilize block syntax.")
+    
     RubyPython.stop
   end
   
   def test_session_function
     RubyPython.session do
+      
       cPickle=RubyPython.import "cPickle"
+      
       cPickle.inspect
-      assert_equal({"a"=>"n", [1, "2"]=>4},cPickle.loads("(dp1\nS'a'\nS'n'\ns(I1\nS'2'\ntp2\nI4\ns."))
+      
+      assert_equal({"a"=>"n", [1, "2"]=>4},
+                   cPickle.loads("(dp1\nS'a'\nS'n'\ns(I1\nS'2'\ntp2\nI4\ns."),
+                   "cPickle misbehaved in session block.")
     end
   end
 
   
   def test_setter_ary
     RubyPython.session do
+      
       sys=RubyPython.import 'sys'
-      sys.path=[""]
-      assert_equal([""],sys.path)
+      
+      sys.path=[".",".."]
+      
+      assert_equal([".",".."],
+                   sys.path,
+                   "Ruby failed to modify Python object as expected.")
     end
   end
   
@@ -104,8 +154,62 @@ class TestRubypython < Test::Unit::TestCase
       urllib2=RubyPython.import "urllib2"
       req=urllib2.Request("google.com")
       req.headers={:a=>"2","k"=>4}
-      assert_equal({"a"=>"2","k"=>4},req.headers)
+      assert_equal({"a"=>"2","k"=>4},
+                   req.headers,
+                   "Python dictionary not set as expected.")
+    end
+  end
+  
+  def test_set_twice
+    RubyPython.session do
+      sys = RubyPython.import 'sys'
+      
+      sys.path = ['.']
+      
+      sys.path = ['..']
+      
+      assert_equal(['..'],
+                   sys.path,
+                   "Ruby failed to modify Python object as expected.")
+      
     end
   end
 
 end
+
+class TestWithCustomObject < Test::Unit::TestCase
+  def setup
+    RubyPython.start
+    sys = RubyPython.import 'sys'
+    sys.path = ['./test/python_helpers']
+    @objects = RubyPython.import 'objects'
+  end
+  
+  def teardown
+    RubyPython.stop
+  end
+  
+  def test_string_access
+    assert_equal("STRING",
+           @objects.RubyPythonMockObject.STRING,
+           "String class members not being converted correctly.")
+    rbString = @objects.RubyPythonMockObject.STRING
+  end
+  
+  def test_string_ary_access
+    assert_equal(["STRING1", "STRING2"],
+                 @objects.RubyPythonMockObject.STRING_LIST,
+                 "List of strings class member not being converted correctly.")
+    rbStringList = @objects.RubyPythonMockObject.STRING_LIST
+  end
+  
+  def test_string_ary_modify
+    rbStringList = @objects.RubyPythonMockObject.STRING_LIST
+    rbStringList.push"NEW_STRING"
+    @objects.RubyPythonMockObject.STRING_LIST = rbStringList
+    assert_equal("NEW_STRING",
+                @objects.RubyPythonMockObject.STRING_LIST[2],
+                "Failed to add object to list.")
+  end
+end
+

data/test/test_rubypython_bridge_extn.rb

@@ -6,30 +6,51 @@ require "rubypython_bridge.so"
 class TestRubyPythonBridgeExtn < Test::Unit::TestCase
   
   def test_func_with_module
-    pickle_return=RubyPythonBridge.func("cPickle","loads","(dp1\nS'a'\nS'n'\ns(I1\nS'2'\ntp2\nI4\ns.")
+    pickle_return = RubyPythonBridge.func("cPickle",
+                                          "loads",  "(dp1\nS'a'\nS'n'\ns(I1\nS'2'\ntp2\nI4\ns.")
+    
     assert_equal({"a"=>"n", [1, "2"]=>4},pickle_return)
   end
   
   def test_start_stop
-    assert(RubyPythonBridge.start)
-    assert(!RubyPythonBridge.start)
-    assert(RubyPythonBridge.stop)
-    assert(!RubyPythonBridge.stop)
+    assert(RubyPythonBridge.start, "Embedded python interpreter failed to start correctly.")
+    
+    assert(!RubyPythonBridge.start, "Interpreter attempted to start while running.")
+    
+    assert(RubyPythonBridge.stop, "Interpreter failed to halt.")
+    
+    assert(!RubyPythonBridge.stop, "Interpreter ran into trouble while halting.")
   end
   
   def test_new_instance
     RubyPythonBridge.start
-    urllib2=RubyPythonBridge.import "urllib2"
-    assert_instance_of(RubyPythonBridge::RubyPyClass,urllib2.Request)
-    assert_instance_of(RubyPythonBridge::RubyPyInstance,urllib2.Request("google.com"))
+    
+    urllib2 = RubyPythonBridge.import "urllib2"
+    
+    assert_instance_of(RubyPythonBridge::RubyPyClass,
+                       urllib2.Request,
+                       "Wrapped Python class not of correct type.")
+    
+    assert_instance_of(RubyPythonBridge::RubyPyInstance,
+                       urllib2.Request("google.com"),
+                       "Wrapped python instance not of correct type.")
+    
     RubyPythonBridge.stop
   end
   
   def test_new_instance_with_new_method
     RubyPythonBridge.start
+    
     urllib2=RubyPythonBridge.import "urllib2"
-    assert_instance_of(RubyPythonBridge::RubyPyClass,urllib2.Request)
-    assert_instance_of(RubyPythonBridge::RubyPyInstance,urllib2.Request.new("google.com"))
+    
+    assert_instance_of(RubyPythonBridge::RubyPyClass,
+                       urllib2.Request,
+                       "Wrapped Python class not of correct type.")
+    
+    assert_instance_of(RubyPythonBridge::RubyPyInstance,
+                       urllib2.Request.new("google.com"),
+                       "New call misbehaving of wrapped class.")
+    
     RubyPythonBridge.stop
   end
   
@@ -49,27 +70,39 @@ class TestRubyPythonBridgeWithCPickle < Test::Unit::TestCase
   end
   
   def test_mod_respond_to
-    assert(@cPickle.respond_to? :loads)
+    assert(@cPickle.respond_to?(:loads),
+           "Ruby respond to method not working on wrapped module.")
   end
   
   def test_data_passing
-    assert_equal({"a"=>"n", [1, "2"]=>4},@cPickle.loads("(dp1\nS'a'\nS'n'\ns(I1\nS'2'\ntp2\nI4\ns."))
-    dumped_array=@cPickle.dumps([1,2,3,4])
-    assert_equal(@cPickle.loads(dumped_array),[1,2,3,4])
+    assert_equal({"a"=>"n", [1, "2"]=>4},
+                 @cPickle.loads( "(dp1\nS'a'\nS'n'\ns(I1\nS'2'\ntp2\nI4\ns."),
+                 "Data returned from wrapped cPickle is incorrect." )
+    
+    orig_array = [1,2,3,4]
+    dumped_array = @cPickle.dumps(orig_array)
+    
+    assert_equal(orig_array,
+                 @cPickle.loads(dumped_array),
+                 "Array returned from cPickle is not equivalent to input array.")
   end
   
-  def test_method_missing
-    assert_raise NoMethodError do
+  def test_unknown_method
+    assert_raise(NoMethodError, "Missing method failed to raise NoMethodError") do
       @cPickle.splack
     end
   end
   
   def test_class_wrapping
-    assert_instance_of(RubyPythonBridge::RubyPyClass,@cPickle.PicklingError)
+    assert_instance_of(RubyPythonBridge::RubyPyClass,
+                       @cPickle.PicklingError,
+                       "Wrapped class is not an instance of RubyPyClass.")
   end
   
-  def test_module_method_wrapping
-    assert_instance_of(RubyPythonBridge::RubyPyModule,@cPickle)
+  def test_module_wrapping
+    assert_instance_of(RubyPythonBridge::RubyPyModule,
+                       @cPickle,
+                       "Wrapped module is not of class RubyPyModule.")
   end
   
 end