rubypython 0.3.2 → 0.5.0

data/lib/rubypython/python.rb

@@ -1,185 +1,198 @@
 require 'ffi'
-require 'open3'
 require 'rubypython/options'
+require 'rubypython/pythonexec'
 
 module RubyPython
-  #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
+  unless defined? PYTHON_RB
+    PYTHON_RB = __FILE__
+    PYTHON_RB.freeze
+  end
+
+  module Python; end
+end
 
+if RubyPython.load_ffi?
+  # This module provides access to the \Python C API functions via the Ruby
+  # FFI gem.
+  #
+  # === Documentation
+  # * {Python C API}[http://docs.python.org/c-api/]
+  # * {Ruby FFI}[http://rdoc.info/projects/ffi/ffi]
+  module RubyPython::Python # :nodoc: all
+    extend FFI::Library
+
+    EXEC = RubyPython::PythonExec.new(RubyPython.options[:python_exe])
+
+    PYTHON_LIB = EXEC.library
+    # FFI::DynamicLibrary::RTLD_LAZY | FFI::DynamicLibrary::RTLD_GLOBAL
+    ffi_lib_flags :lazy, :global
+    ffi_lib EXEC.library
+
+    # 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 # :nodoc:
+      layout :dummy_var, :int
     end
 
-  else
-    module Python; end
+    PY_FILE_INPUT = 257
+    PY_EVAL_INPUT = 258
+
+    # Function methods & constants
+    METH_VARARGS = 0x0001
+    attach_function :PyCFunction_New, [:pointer, :pointer], :pointer
+    callback :PyCFunction, [:pointer, :pointer], :pointer
+
+    attach_function :PyRun_String, [:string, :int, :pointer, :pointer], :pointer
+    attach_function :PyRun_SimpleString, [:string], :pointer
+    attach_function :Py_CompileString, [:string, :string, :int], :pointer
+    attach_function :PyEval_EvalCode, [:pointer, :pointer, :pointer], :pointer
+    attach_function :PyErr_SetString, [:pointer, :string], :void
+
+    # 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_Dir, [:pointer], :pointer
+
+    attach_function :PyObject_Compare, [:pointer, :pointer], :int
+
+    attach_function :PyObject_Call, [:pointer, :pointer, :pointer], :pointer
+    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
+    attach_function :PyString_AsStringAndSize, [:pointer, :pointer, :pointer], :int
+    attach_function :PyString_FromStringAndSize, [:buffer_in, :ssize_t], :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_variable :PyExc_Exception, DummyStruct.by_ref
+    attach_variable :PyExc_StopIteration, DummyStruct.by_ref
+    attach_function :PyErr_SetNone, [:pointer], :void
+    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 :PyBaseObject_Type, DummyStruct.by_value # built-in 'object' 
+    # attach_variable :PyBaseString_Type, DummyStruct.by_value
+    # attach_variable :PyBool_Type, DummyStruct.by_value
+    # attach_variable :PyBuffer_Type, DummyStruct.by_value
+    # attach_variable :PyByteArrayIter_Type, DummyStruct.by_value
+    # attach_variable :PyByteArray_Type, DummyStruct.by_value
+    attach_variable :PyCFunction_Type, DummyStruct.by_value
+    # attach_variable :PyCObject_Type, DummyStruct.by_value
+    # attach_variable :PyCallIter_Type, DummyStruct.by_value
+    # attach_variable :PyCapsule_Type, DummyStruct.by_value
+    # attach_variable :PyCell_Type, DummyStruct.by_value
+    # attach_variable :PyClassMethod_Type, DummyStruct.by_value
+    attach_variable :PyClass_Type, DummyStruct.by_value
+    # attach_variable :PyCode_Type, DummyStruct.by_value
+    # attach_variable :PyComplex_Type, DummyStruct.by_value
+    # attach_variable :PyDictItems_Type, DummyStruct.by_value
+    # attach_variable :PyDictIterItem_Type, DummyStruct.by_value
+    # attach_variable :PyDictIterKey_Type, DummyStruct.by_value
+    # attach_variable :PyDictIterValue_Type, DummyStruct.by_value
+    # attach_variable :PyDictKeys_Type, DummyStruct.by_value
+    # attach_variable :PyDictProxy_Type, DummyStruct.by_value
+    # attach_variable :PyDictValues_Type, DummyStruct.by_value
+    attach_variable :PyDict_Type, DummyStruct.by_value
+    # attach_variable :PyEllipsis_Type, DummyStruct.by_value
+    # attach_variable :PyEnum_Type, DummyStruct.by_value
+    # attach_variable :PyFile_Type, DummyStruct.by_value
+    attach_variable :PyFloat_Type, DummyStruct.by_value
+    # attach_variable :PyFrame_Type, DummyStruct.by_value
+    # attach_variable :PyFrozenSet_Type, DummyStruct.by_value
+    attach_variable :PyFunction_Type, DummyStruct.by_value
+    # attach_variable :PyGen_Type, DummyStruct.by_value
+    # attach_variable :PyGetSetDescr_Type, DummyStruct.by_value
+    # attach_variable :PyInstance_Type, DummyStruct.by_value
+    attach_variable :PyInt_Type, DummyStruct.by_value
+    attach_variable :PyList_Type, DummyStruct.by_value
+    attach_variable :PyLong_Type, DummyStruct.by_value
+    # attach_variable :PyMemberDescr_Type, DummyStruct.by_value
+    # attach_variable :PyMemoryView_Type, DummyStruct.by_value
+    attach_variable :PyMethod_Type, DummyStruct.by_value
+    # attach_variable :PyModule_Type, DummyStruct.by_value
+    # attach_variable :PyNullImporter_Type, DummyStruct.by_value
+    # attach_variable :PyProperty_Type, DummyStruct.by_value
+    # attach_variable :PyRange_Type, DummyStruct.by_value
+    # attach_variable :PyReversed_Type, DummyStruct.by_value
+    # attach_variable :PySTEntry_Type, DummyStruct.by_value
+    # attach_variable :PySeqIter_Type, DummyStruct.by_value
+    # attach_variable :PySet_Type, DummyStruct.by_value
+    # attach_variable :PySlice_Type, DummyStruct.by_value
+    # attach_variable :PyStaticMethod_Type, DummyStruct.by_value
+    attach_variable :PyString_Type, DummyStruct.by_value
+    # attach_variable :PySuper_Type, DummyStruct.by_value # built-in 'super' 
+    # attach_variable :PyTraceBack_Type, DummyStruct.by_value
+    attach_variable :PyTuple_Type, DummyStruct.by_value
+    attach_variable :PyType_Type, DummyStruct.by_value
+    # attach_variable :PyUnicode_Type, DummyStruct.by_value
+    # attach_variable :PyWrapperDescr_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, :ssize_t,
+             :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
   end
 end

data/lib/rubypython/pythonerror.rb

@@ -1,78 +1,69 @@
 require 'rubypython/python'
 require 'rubypython/macros'
 
+# Raised when an error occurs in the \Python interpreter.
+class RubyPython::PythonError < RuntimeError
+  # Creates the PythonError.
+  # [typeName] The class name of the \Python error.
+  # [msg] The message attached to the \Python error.
+  def initialize(typeName, msg)
+    @type = typeName
+    super([typeName, msg].join(': '))
+  end
 
-module RubyPython
-  
-  #Raised when an error occurs in the Python interpreter.
-  class PythonError < Exception
-    
-    #@param [String] typeName the class name of the Python error
-    #@param [String] msg the message attached to the Python error
-    def initialize(typeName, msg)
-      @type = typeName
-      super([typeName, msg].join(': '))
-    end
-
-    #This method should be called when an error has occured in the
-    #Python interpreter. This acts as factory function for PythonError
-    #objects. The function fetchs calls {fetch} to get the error
-    #information from the Python interpreter and uses this to build
-    #a PythonError object. It then calls {clear} to clear the error
-    #flag of the python interpreter
-    #@return [PythonError] an error enscapsulating the Python error
-    def self.handle_error
-      rbType, rbValue, rbTraceback = fetch()
-
-      if not rbValue.null?
-        msg = rbValue.getAttr("__str__").callObject PyObject.buildArgTuple
-        msg = msg.rubify
-      else
-        msg = nil
-      end
-      
-      #Decrease the reference count. This will happen anyway when they go
-      #out of scope but might as well.
-      rbValue.xDecref
-      rbTraceback.xDecref
-      pyName = rbType.getAttr("__name__")
+  # This method should be called when an error has occurred in the \Python
+  # interpreter. This acts as factory function for PythonError objects. The
+  # function fetches calls +#fetch+ to get the error information from the
+  # \Python interpreter and uses this to build a PythonError object. It then
+  # calls +#clear to clear the error flag in the python interpreter. After
+  # the error flag has been cleared, the PythonError object is returned.
+  def self.handle_error
+    rbType, rbValue, rbTraceback = fetch()
 
-      rbType.xDecref
-      rbName = pyName.rubify
-      pyName.xDecref
+    if not rbValue.null?
+      msg = rbValue.getAttr("__str__").callObject RubyPython::PyObject.buildArgTuple
+      msg = msg.rubify
+    else
+      msg = nil
+    end
 
-      PythonError.clear
+    # Decrease the reference count. This will happen anyway when they go out
+    # of scope but might as well.
+    rbValue.xDecref
+    rbTraceback.xDecref
+    pyName = rbType.getAttr("__name__")
 
-      PythonError.new(rbName, msg)
-    end
+    rbType.xDecref
+    rbName = pyName.rubify
+    pyName.xDecref
 
-    #A wrapper to the Python C API PyErr_Fetch function.
-    #@return [Array<PyObject>] an array containing three {PyObject} instances.
-    #   representing the Type, Value, and stacktrace of the python
-    #   error respectively.
-    def self.fetch
-      typePointer = FFI::MemoryPointer.new :pointer
-      valuePointer = FFI::MemoryPointer.new :pointer
-      tracebackPointer = FFI::MemoryPointer.new :pointer
+    RubyPython::PythonError.clear
+    RubyPython::PythonError.new(rbName, msg)
+  end
 
-      Python.PyErr_Fetch typePointer, valuePointer, tracebackPointer
+  # A wrapper to the \Python C API +PyErr_Fetch+ function. Returns an array
+  # with three PyObject instances, representing the Type, the Value, and the
+  # stack trace of the Python error.
+  def self.fetch
+    typePointer = FFI::MemoryPointer.new :pointer
+    valuePointer = FFI::MemoryPointer.new :pointer
+    tracebackPointer = FFI::MemoryPointer.new :pointer
 
-      rbType = PyObject.new typePointer.read_pointer
-      rbValue = PyObject.new valuePointer.read_pointer
-      rbTraceback = PyObject.new tracebackPointer.read_pointer
-      [rbType, rbValue, rbTraceback]
-    end
+    RubyPython::Python.PyErr_Fetch typePointer, valuePointer, tracebackPointer
 
-    #Determines whether an error has occured in the python interpreter.
-    def self.error?
-      !Python.PyErr_Occurred.null?
-    end
+    rbType = RubyPython::PyObject.new typePointer.read_pointer
+    rbValue = RubyPython::PyObject.new valuePointer.read_pointer
+    rbTraceback = RubyPython::PyObject.new tracebackPointer.read_pointer
+    [rbType, rbValue, rbTraceback]
+  end
 
-    #Resets the Python interpreter error flag
-    #@return [void]
-    def self.clear
-      Python.PyErr_Clear
-    end
+  # Determines whether an error has occurred in the \Python interpreter.
+  def self.error?
+    !RubyPython::Python.PyErr_Occurred.null?
+  end
 
+  # Resets the \Python interpreter error flag
+  def self.clear
+    RubyPython::Python.PyErr_Clear
   end
 end