rubypython 0.3.1 → 0.3.2

data/lib/rubypython/python.rb

@@ -1,162 +1,185 @@
 require 'ffi'
 require 'open3'
+require 'rubypython/options'
 
 module RubyPython
-  #This module provides access to the Python C API functions via the Ruby ffi
-  #gem. Documentation for these functions may be found [here](http://docs.python.org/c-api/). Likewise the FFI gem documentation may be found [here](http://rdoc.info/projects/ffi/ffi).
-  module Python
-    extend FFI::Library
-
-    # This much we can assume works without anything special at all.
-    PYTHON_VERSION = Open3.popen3("python --version") { |i,o,e| e.read }.chomp.split[1].to_f
-    PYTHON_NAME = "python#{PYTHON_VERSION}"
-    LIB_NAME = "#{FFI::Platform::LIBPREFIX}#{PYTHON_NAME}"
-    LIB_EXT = FFI::Platform::LIBSUFFIX
-    PYTHON_SYS_PREFIX = %x{#{PYTHON_NAME} -c "import sys; print(sys.prefix)"}.chomp
-
-    # Here's where we run into problems, as not everything works quite the
-    # way we expect it to.
-    #
-    # The default libname will be something like libpython2.6.so (or .dylib)
-    # or maybe even python2.6.dll on Windows.
-    libname = "#{LIB_NAME}.#{LIB_EXT}"
-
-    # We may need to look in multiple locations for Python, so let's build
-    # this as an array.
-    locations = [ File.join(PYTHON_SYS_PREFIX, "lib", libname) ]
-
-    if FFI::Platform.mac?
-      # On the Mac, let's add a special case that has even a different
-      # libname. This may not be fully useful on future versions of OS X,
-      # but it should work on 10.5 and 10.6. Even if it doesn't, the next
-      # step will (/usr/lib/libpython<version>.dylib is a symlink to the
-      # correct location).
-      locations << File.join(PYTHON_SYS_PREFIX, "Python")
-      # Let's also look in the location that was originally set in this
-      # library:
-      File.join(PYTHON_SYS_PREFIX, "lib", "#{PYTHON_NAME}", "config",
-                libname)
-    end
-
-    if FFI::Platform.unix?
-      # On Unixes, let's look in alternative places, too. Just in case.
-      locations << File.join("/opt/local/lib", libname)
-      locations << File.join("/opt/lib", libname)
-      locations << File.join("/usr/local/lib", libname)
-      locations << File.join("/usr/lib", libname)
-    end
-
-    # Get rid of redundant locations.
-    locations.uniq!
-
-    dyld_flags = FFI::DynamicLibrary::RTLD_LAZY | FFI::DynamicLibrary::RTLD_GLOBAL
-    exceptions = []
-
-    locations.each do |location|
-      begin
-        @ffi_libs = [ FFI::DynamicLibrary.open(location, dyld_flags) ]
-        LIB = location
-        break
-      rescue LoadError => ex
-        @ffi_libs = nil
-        exceptions << ex
-      end
-    end
-
-    raise exceptions.first if @ffi_libs.nil?
-
-    #The class is a little bit of a hack to extract the address of global
-    #structs. If someone knows a better way please let me know.
-    class DummyStruct < FFI::Struct
-      layout :dummy_var, :int
-    end
+  #Check to see whether the Python Library has been loaded yet. If not 
+  #then we dfer loading the library until this file has been reloaded.
+  if @loaded
+    #This module provides access to the Python C API functions via the Ruby ffi
+    #gem. Documentation for these functions may be found [here](http://docs.python.org/c-api/). Likewise the FFI gem documentation may be found [here](http://rdoc.info/projects/ffi/ffi).
+    module Python
+      extend FFI::Library
+
+      PYTHON_EXE = RubyPython.options[:python_exe] || 'python'
+      # This much we can assume works without anything special at all.
+      PYTHON_VERSION = Open3.popen3("#{PYTHON_EXE} --version") { |i,o,e| e.read }.chomp.split[1].to_f
+      PYTHON_NAME = "python#{PYTHON_VERSION}"
+      LIB_NAME = "#{FFI::Platform::LIBPREFIX}#{PYTHON_NAME}"
+      LIB_EXT = FFI::Platform::LIBSUFFIX
+      PYTHON_SYS_PREFIX = %x{#{PYTHON_NAME} -c "import sys; print(sys.prefix)"}.chomp
+
+        # Here's where we run into problems, as not everything works quite the
+        # way we expect it to.
+        #
+        # The default libname will be something like libpython2.6.so (or .dylib)
+        # or maybe even python2.6.dll on Windows.
+        libname = "#{LIB_NAME}.#{LIB_EXT}"
+
+        # We may need to look in multiple locations for Python, so let's build
+        # this as an array.
+        locations = [ File.join(PYTHON_SYS_PREFIX, "lib", libname) ]
+
+        if FFI::Platform.mac?
+          # On the Mac, let's add a special case that has even a different
+          # libname. This may not be fully useful on future versions of OS X,
+          # but it should work on 10.5 and 10.6. Even if it doesn't, the next
+          # step will (/usr/lib/libpython<version>.dylib is a symlink to the
+          # correct location).
+          locations << File.join(PYTHON_SYS_PREFIX, "Python")
+          # Let's also look in the location that was originally set in this
+          # library:
+          File.join(PYTHON_SYS_PREFIX, "lib", "#{PYTHON_NAME}", "config",
+                    libname)
+        end
+
+        if FFI::Platform.unix?
+          # On Unixes, let's look in alternative places, too. Just in case.
+          locations << File.join("/opt/local/lib", libname)
+          locations << File.join("/opt/lib", libname)
+          locations << File.join("/usr/local/lib", libname)
+          locations << File.join("/usr/lib", libname)
+        end
+
+        # Get rid of redundant locations.
+        locations.uniq!
+
+        dyld_flags = FFI::DynamicLibrary::RTLD_LAZY | FFI::DynamicLibrary::RTLD_GLOBAL
+        exceptions = []
+
+        locations.each do |location|
+          begin
+            @ffi_libs = [ FFI::DynamicLibrary.open(location, dyld_flags) ]
+            LIB = location
+            break
+          rescue LoadError => ex
+            @ffi_libs = nil
+            exceptions << ex
+          end
+        end
+
+        raise exceptions.first if @ffi_libs.nil?
+
+        #The class is a little bit of a hack to extract the address of global
+        #structs. If someone knows a better way please let me know.
+        class DummyStruct < FFI::Struct
+          layout :dummy_var, :int
+        end
+
+        #Python interpreter startup and shutdown
+        attach_function :Py_IsInitialized, [], :int
+        attach_function :Py_Initialize, [], :void
+        attach_function :Py_Finalize, [], :void
+
+        #Module methods
+        attach_function :PyImport_ImportModule, [:string], :pointer
+
+        #Object Methods
+        attach_function :PyObject_HasAttrString, [:pointer, :string], :int
+        attach_function :PyObject_GetAttrString, [:pointer, :string], :pointer
+        attach_function :PyObject_SetAttrString, [:pointer, :string, :pointer], :int
+
+        attach_function :PyObject_Compare, [:pointer, :pointer], :int
+
+        attach_function :PyObject_CallObject, [:pointer, :pointer], :pointer
+        attach_function :PyCallable_Check, [:pointer], :int
+
+        ###Python To Ruby Conversion
+        #String Methods
+        attach_function :PyString_AsString, [:pointer], :string
+        attach_function :PyString_FromString, [:string], :pointer
+
+        #List Methods
+        attach_function :PyList_GetItem, [:pointer, :int], :pointer
+        attach_function :PyList_Size, [:pointer], :int
+        attach_function :PyList_New, [:int], :pointer
+        attach_function :PyList_SetItem, [:pointer, :int, :pointer], :void
+
+        #Integer Methods
+        attach_function :PyInt_AsLong, [:pointer], :long
+        attach_function :PyInt_FromLong, [:long], :pointer
+
+        attach_function :PyLong_AsLong, [:pointer], :long
+        attach_function :PyLong_FromLong, [:pointer], :long
+
+        #Float Methods
+        attach_function :PyFloat_AsDouble, [:pointer], :double
+        attach_function :PyFloat_FromDouble, [:double], :pointer
+
+        #Tuple Methods
+        attach_function :PySequence_List, [:pointer], :pointer
+        attach_function :PySequence_Tuple, [:pointer], :pointer
+        attach_function :PyTuple_Pack, [:int, :varargs], :pointer
+
+        #Dict/Hash Methods
+        attach_function :PyDict_Next, [:pointer, :pointer, :pointer, :pointer], :int
+        attach_function :PyDict_New, [], :pointer
+        attach_function :PyDict_SetItem, [:pointer, :pointer, :pointer], :int
+        attach_function :PyDict_Contains, [:pointer, :pointer], :int
+        attach_function :PyDict_GetItem, [:pointer, :pointer], :pointer
+
+        #Function Constants
+        METH_VARARGS = 1
+        attach_function :PyCFunction_New, [:pointer, :pointer], :pointer
+        callback :PyCFunction, [:pointer, :pointer], :pointer
+
+        #Error Methods
+        attach_function :PyErr_Fetch, [:pointer, :pointer, :pointer], :void
+        attach_function :PyErr_Occurred, [], :pointer
+        attach_function :PyErr_Clear, [], :void
+
+        #Reference Counting
+        attach_function :Py_IncRef, [:pointer], :void
+        attach_function :Py_DecRef, [:pointer], :void
+
+        #Type Objects
+        attach_variable :PyString_Type, DummyStruct.by_value
+        attach_variable :PyList_Type, DummyStruct.by_value
+        attach_variable :PyInt_Type, DummyStruct.by_value
+        attach_variable :PyLong_Type, DummyStruct.by_value
+        attach_variable :PyFloat_Type, DummyStruct.by_value
+        attach_variable :PyTuple_Type, DummyStruct.by_value
+        attach_variable :PyDict_Type, DummyStruct.by_value
+        attach_variable :PyFunction_Type, DummyStruct.by_value
+        attach_variable :PyCFunction_Type, DummyStruct.by_value
+        attach_variable :PyMethod_Type, DummyStruct.by_value
+        attach_variable :PyType_Type, DummyStruct.by_value
+        attach_variable :PyClass_Type, DummyStruct.by_value
+
+        attach_variable :Py_TrueStruct, :_Py_TrueStruct, DummyStruct.by_value
+        attach_variable :Py_ZeroStruct, :_Py_ZeroStruct, DummyStruct.by_value
+        attach_variable :Py_NoneStruct, :_Py_NoneStruct, DummyStruct.by_value
+
+        #This is an implementation of the basic structure of a Python PyObject
+        #struct. The C struct is actually much larger, but since we only access
+        #the first two data members via FFI and always deal with struct pointers
+        #there is no need to mess around with the rest of the object.
+        class PyObjectStruct < FFI::Struct
+          layout :ob_refcnt, :int,
+            :ob_type, :pointer
+        end
+
+        #This struct is used when defining Python methods. 
+        class PyMethodDef < FFI::Struct
+          layout :ml_name, :pointer,
+            :ml_meth, :PyCFunction,
+            :ml_flags, :int,
+            :ml_doc, :pointer
+        end
 
-    #Python interpreter startup and shutdown
-    attach_function :Py_IsInitialized, [], :int
-    attach_function :Py_Initialize, [], :void
-    attach_function :Py_Finalize, [], :void
-
-    #Module methods
-    attach_function :PyImport_ImportModule, [:string], :pointer
-
-    #Object Methods
-    attach_function :PyObject_HasAttrString, [:pointer, :string], :int
-    attach_function :PyObject_GetAttrString, [:pointer, :string], :pointer
-    attach_function :PyObject_SetAttrString, [:pointer, :string, :pointer], :int
-
-    attach_function :PyObject_Compare, [:pointer, :pointer], :int
-
-    attach_function :PyObject_CallObject, [:pointer, :pointer], :pointer
-    attach_function :PyCallable_Check, [:pointer], :int
-
-    ###Python To Ruby Conversion
-    #String Methods
-    attach_function :PyString_AsString, [:pointer], :string
-    attach_function :PyString_FromString, [:string], :pointer
-
-    #List Methods
-    attach_function :PyList_GetItem, [:pointer, :int], :pointer
-    attach_function :PyList_Size, [:pointer], :int
-    attach_function :PyList_New, [:int], :pointer
-    attach_function :PyList_SetItem, [:pointer, :int, :pointer], :void
-
-    #Integer Methods
-    attach_function :PyInt_AsLong, [:pointer], :long
-    attach_function :PyInt_FromLong, [:long], :pointer
-
-    attach_function :PyLong_AsLong, [:pointer], :long
-    attach_function :PyLong_FromLong, [:pointer], :long
-
-    #Float Methods
-    attach_function :PyFloat_AsDouble, [:pointer], :double
-    attach_function :PyFloat_FromDouble, [:double], :pointer
-
-    #Tuple Methods
-    attach_function :PySequence_List, [:pointer], :pointer
-    attach_function :PySequence_Tuple, [:pointer], :pointer
-    attach_function :PyTuple_Pack, [:int, :varargs], :pointer
-
-    #Dict/Hash Methods
-    attach_function :PyDict_Next, [:pointer, :pointer, :pointer, :pointer], :int
-    attach_function :PyDict_New, [], :pointer
-    attach_function :PyDict_SetItem, [:pointer, :pointer, :pointer], :int
-    attach_function :PyDict_Contains, [:pointer, :pointer], :int
-    attach_function :PyDict_GetItem, [:pointer, :pointer], :pointer
-
-    #Error Methods
-    attach_function :PyErr_Fetch, [:pointer, :pointer, :pointer], :void
-    attach_function :PyErr_Occurred, [], :pointer
-    attach_function :PyErr_Clear, [], :void
-
-    #Reference Counting
-    attach_function :Py_IncRef, [:pointer], :void
-    attach_function :Py_DecRef, [:pointer], :void
-
-    #Type Objects
-    attach_variable :PyString_Type, DummyStruct.by_value
-    attach_variable :PyList_Type, DummyStruct.by_value
-    attach_variable :PyInt_Type, DummyStruct.by_value
-    attach_variable :PyLong_Type, DummyStruct.by_value
-    attach_variable :PyFloat_Type, DummyStruct.by_value
-    attach_variable :PyTuple_Type, DummyStruct.by_value
-    attach_variable :PyDict_Type, DummyStruct.by_value
-    attach_variable :PyFunction_Type, DummyStruct.by_value
-    attach_variable :PyMethod_Type, DummyStruct.by_value
-    attach_variable :PyType_Type, DummyStruct.by_value
-    attach_variable :PyClass_Type, DummyStruct.by_value
-
-    attach_variable :Py_TrueStruct, :_Py_TrueStruct, DummyStruct.by_value
-    attach_variable :Py_ZeroStruct, :_Py_ZeroStruct, DummyStruct.by_value
-    attach_variable :Py_NoneStruct, :_Py_NoneStruct, DummyStruct.by_value
-
-    #This is an implementation of the basic structure of a Python PyObject
-    #struct. The C struct is actually much larger, but since we only access
-    #the first two data members via FFI and always deal with struct pointers
-    #there is no need to mess around with the rest of the object.
-    class PyObjectStruct < FFI::Struct
-      layout :ob_refcnt, :int,
-        :ob_type, :pointer
     end
 
+  else
+    module Python; end
   end
 end

data/lib/rubypython/rubypyproxy.rb

@@ -13,6 +13,56 @@ module RubyPython
   #
   #Note: All RubyPyProxy objects become invalid when the Python interpreter
   #is halted.
+  #
+  #Calling Methods With Blocks
+  #-----------------------------
+  #Any method which is forwarded to a Python object may be called with 
+  #a block. The result of the method will passed as the argument to 
+  #that block.
+  #
+  #@example Supplying a block to a method call
+  #  irb(main):001:0> RubyPython.start
+  #  => true
+  #  irb(main):002:0> RubyPython::PyMain.float(10) do |f|
+  #  irb(main):003:1*     2*f.rubify
+  #  irb(main):004:1> end
+  #  => 20.0
+  #  irb(main):005:0> RubyPython.stop
+  #  => true
+  #
+  #
+  #Passing Procs and Methods to methods
+  #-------------------------------------
+  #RubyPython now supports passing Proc and Method objects to Python 
+  #methods. The Proc or Method object must be passed explicitly. As 
+  #seen above, supplying a block to a method will result in the return 
+  #value of the method call being passed to the block.
+  #
+  #When a Proc or Method is supplied as a callback, then arguments that 
+  #it will be called with will be wrapped Python objects.
+  #
+  #@example Passing a Proc to Python
+  #  #Python Code
+  #  def apply_callback(callback, argument):
+  #    return callback(argument)
+  #
+  #  #IRB Session
+  #  irb(main):001:0> RubyPython.start
+  #  => true
+  #  irb(main):002:0> sys = RubyPython.import 'sys'
+  #  => <module 'sys' (built-in)>
+  #  irb(main):003:0> sys.path.append('.')
+  #  => None
+  #  irb(main):004:0> sample = RubyPython.import 'sample'
+  #  => <module 'sample' from './sample.pyc'>
+  #  irb(main):005:0> callback = Proc.new do |arg|
+  #  irb(main):006:1*   arg * 2
+  #  irb(main):007:1> end
+  #  => #<Proc:0x000001018df490@(irb):5>
+  #  irb(main):008:0> sample.apply_callback(callback, 21).rubify
+  #  => 42
+  #  irb(main):009:0> RubyPython.stop
+  #
   class RubyPyProxy < BlankObject
     include Operators
 
@@ -119,27 +169,23 @@ module RubyPython
     end
 
     #Returns the string representation of the wrapped object via a call to the
-    #object's \_\_repr\_\_ method. Falls back on the default Ruby behavior when
-    #this method cannot be found.
+    #object's \_\_repr\_\_ method. 
     #
     #@return [String]
     def inspect
-      self.__repr__.rubify rescue _inspect
-    rescue
-      class << self; define_method :_inspect, RubyPyProxy.find_hidden_method(:inspect); end
-      _inspect
+      self.__repr__.rubify
+    rescue PythonError, NoMethodError
+      RubyPython::PyMain.repr(self).rubify
     end
 
     #Returns the string representation of the wrapped object via a call to the
-    #object's \_\_str\_\_ method. Falls back on the default Ruby behavior when
-    #this method cannot be found.
+    #object's \_\_str\_\_ method. 
     #
     #@return [String]
     def to_s
-      self.__str__.rubify rescue _to_s
-    rescue
-      class << self; define_method :_to_s, RubyPyProxy.find_hidden_method(:to_s); end
-      _to_s
+      self.__str__.rubify
+    rescue PythonError, NoMethodError
+      RubyPython::PyMain.str(self).rubify
     end
 
     #Converts the wrapped Python object to a Ruby Array. Note that this only converts
@@ -147,7 +193,7 @@ module RubyPython
     #objects which have an \_\_iter\_\_ method may be converted using to_a.
     #
     #Note that for Dict objects, this method returns what you would get in
-    #Python, not in Ruby i.e. a_dict.to_a returns an array of the
+    #Python, not in Ruby i.e. a\_dict.to\_a returns an array of the
     #dictionary's keys.
     #@return [Array<RubyPyProxy>]
     #@example List
@@ -173,7 +219,7 @@ module RubyPython
     #    => [1, 'three']
     #    irb(main):005:0> RubyPython.stop
     #    => true
-    
+    #
     def to_a
       iter = self.__iter__
       ary = []

data/lib/rubypython/version.rb

@@ -3,7 +3,7 @@ module RubyPython
   module VERSION
     MAJOR = 0
     MINOR = 3
-    TINY  = 1
+    TINY  = 2
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
 end

data/lib/rubypython.rb

@@ -1,4 +1,5 @@
 require 'rubypython/core_ext/string'
+require 'rubypython/options'
 require 'rubypython/python'
 require 'rubypython/pythonerror'
 require 'rubypython/pyobject'
@@ -35,6 +36,7 @@ require 'rubypython/pymainclass'
 #{RubyPython.legacy_mode}.
 module RubyPython
 
+
   class << self
 
     #Determines whether RubyPython is operating in Normal Mode or Legacy Mode.
@@ -64,14 +66,24 @@ module RubyPython
 
     #Starts ups the Python interpreter. This method **must** be run
     #before using any Python code. The only alternatives are use of the
-    #{session} and {run} methods.
+    #{session} and {run} methods. If the Python interpreter needs to 
+    #be loaded or reloaded, it will be done here.
     #@return [Boolean] returns true if the interpreter was started here
     #    and false otherwise
     def start
+      unless @loaded
+        @loaded = true
+        reload_library
+      end
       if Python.Py_IsInitialized != 0
         return false
       end
+      if @reload
+        reload_library
+        @reload = false
+      end
       Python.Py_Initialize
+      notify :start
       true
     end
 
@@ -82,11 +94,8 @@ module RubyPython
     #    and false otherwise
     def stop
       if Python.Py_IsInitialized !=0
-        PyMain.main = nil
-        PyMain.builtin = nil
-        RubyPython::Operators.send :class_variable_set, '@@operator', nil
         Python.Py_Finalize
-        RubyPython::PyObject::AutoPyPointer.current_pointers.clear
+        notify :stop
         return true
       end
       false
@@ -121,10 +130,47 @@ module RubyPython
 
     #The same as {session} except that the block is executed within the scope 
     #of the RubyPython module.
+    #@return the result of evaluating the  given block.
     def run(&block)
       start
       result = module_eval(&block)
       stop
+      result
+    end
+
+    private
+
+    def add_observer(object)
+      @observers ||= []
+      @observers << object
+      true
+    end
+
+    def notify(status)
+      if not @observers.nil?
+        @observers.each do |o|
+          o.update status
+        end
+      end
     end
+
+    def reload_library
+      remove_const :Python
+      load 'rubypython/python.rb'
+      true
+    end
+
   end
+
+  [
+    PyMain,
+    Operators,
+    PyObject::AutoPyPointer
+  ].each do |observer|
+    add_observer observer
+  end
+
+
 end
+
+  

data/spec/callback_spec.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe 'Callbacks' do
+  include TestConstants
+  
+  before do
+    RubyPython.start
+    @sys = RubyPython.import 'sys'
+    @sys.path.append './spec/python_helpers'
+    @objects = RubyPython.import 'objects'
+  end
+
+  after do
+    RubyPython.start
+  end
+
+  [
+    [ 'procs', AProc ],
+    [ 'methods', AMethod]
+  ].each do |rb_type, rb_object|
+    it "accepts #{rb_type} as functions" do
+      [
+        [2, 2],
+        ["a", "Word"],
+        [ [1, 2], [3, 4] ]
+      ].each do |args|
+        @objects.apply_callback(rb_object, args).should == rb_object.call(*args)
+      end
+    end
+  end
+
+  [
+    ["an int", AnInt],
+    ["a float", AFloat],
+    ["a string", AString],
+    ["an array", AnArray],
+    ["an array", AnArray],
+    ["a hash", AConvertedHash],
+    ["true", true],
+    ["false", false],
+    ["nil", nil]
+  ].each do |rb_type, rb_value|
+    it "is able to return #{rb_type}" do
+      callback = Proc.new do 
+        rb_value
+      end
+
+      @objects.apply_callback(callback, []).should == rb_value
+    end
+  end
+
+  it "is able to be stored by python variables" do
+    mockObject = @objects.RubyPythonMockObject.new
+    mockObject.callback = AProc
+  end
+
+  it "is callable as a python instance variable" do
+    mockObject = @objects.RubyPythonMockObject.new
+    mockObject.callback = AProc
+    mockObject.callback(2, 2).rubify.should == 4
+  end
+
+end