rubypython 0.3.2 → 0.5.0

data/lib/rubypython/blankobject.rb

@@ -1,21 +1,23 @@
 require 'blankslate'
 
-module RubyPython
-  #An object to be used as a base class for Proxy classes.
-  #It is necessary to define this because no such class exists in Ruby
-  #1.8.x
-  class BlankObject < BlankSlate
-    class << self
-      def hide(name)
-        if instance_methods.include?(name) and
-          name.to_s !~ /^(__|instance_eval|object_id)/
+# This document is the basis of the RubyPyProxy precisely because it hides
+# the implementation of so many things that should be forwarded on to the
+# Python object. This class is for internal use only.
+#
+# Note that in Ruby 1.9, BasicObject might be a better choice, but there are
+# some decisions made in the rest of the library that make this harder. I
+# don't see a clean way to integrate both Ruby 1.8 and 1.9 support for this.
+class RubyPython::BlankObject < ::BlankSlate #:nodoc:
+  class << self
+    def hide(name)
+      if instance_methods.include?(name) and
+        name.to_s !~ /^(__|instance_eval|object_id)/
           @hidden_methods ||= {}
-          @hidden_methods[name.to_sym] = instance_method(name)
-          undef_method name
-        end
+        @hidden_methods[name.to_sym] = instance_method(name)
+        undef_method name
       end
     end
-
-    instance_methods.each { |m| hide(m) }
   end
+
+  instance_methods.each { |m| hide(m) }
 end

data/lib/rubypython/conversion.rb

@@ -1,215 +1,284 @@
 require 'rubypython/python'
 require 'rubypython/macros'
-module RubyPython
-  #This modules encapsulates the work of converting between native Ruby and
-  #Python types. Unsupported conversions raise {UnsupportedConversion}. 
-  module Conversion
 
-    #Raised when RubyPython does not know how to convert an object from Python
-    #to Ruby or vice versa
-    class UnsupportedConversion < Exception; end
+# Acts as a namespace for methods to bidirectionally convert between native
+# Ruby types and native \Python types. Unsupported conversions raise
+# UnsupportedConversion.
+#
+# The methods in this module should be considered internal implementation to
+# RubyPython as they all return FFI pointers to \Python objects.
+module RubyPython::Conversion
+  # Raised when RubyPython does not know how to convert an object from
+  # \Python to Ruby or vice versa.
+  class UnsupportedConversion < Exception; end
 
-    def self.rtopString(rString)
-      Python.PyString_FromString(rString)
-    end
+  # Convert a Ruby string to a \Python string. Returns an FFI::Pointer to
+  # a PyStringObject.
+  def self.rtopString(rString)
+    size = rString.respond_to?(:bytesize) ? rString.bytesize : rString.size
+    RubyPython::Python.PyString_FromStringAndSize(rString, size)
+  end
 
-    def self.rtopArrayToList(rArray)
-      size = rArray.length
-      pList = Python.PyList_New size
-      rArray.each_with_index do |el, i|
-        Python.PyList_SetItem pList, i, rtopObject(el)
-      end
-      pList
+  # Convert a Ruby Array to \Python List. Returns an FFI::Pointer to
+  # a PyListObject.
+  def self.rtopArrayToList(rArray)
+    size = rArray.length
+    pList = RubyPython::Python.PyList_New size
+    rArray.each_with_index do |el, i|
+      RubyPython::Python.PyList_SetItem pList, i, rtopObject(el)
     end
+    pList
+  end
 
-    def self.rtopArrayToTuple(rArray)
-      pList = rtopArrayToList(rArray)
-      pTuple = Python.PySequence_Tuple(pList)
-      Python.Py_DecRef(pList)
-      pTuple
-    end
+  # Convert a Ruby Array to \Python Tuple. Returns an FFI::Pointer to a
+  # PyTupleObject.
+  def self.rtopArrayToTuple(rArray)
+    pList = rtopArrayToList(rArray)
+    pTuple = RubyPython::Python.PySequence_Tuple(pList)
+    RubyPython::Python.Py_DecRef(pList)
+    pTuple
+  end
 
-    def self.rtopHash(rHash)
-      pDict = Python.PyDict_New
-      rHash.each do |k,v|
-        Python.PyDict_SetItem pDict, rtopObject(k, key=true), rtopObject(v)
-      end
-      pDict
+  # Convert a Ruby Hash to a \Python Dict. Returns an FFI::Pointer to a
+  # PyDictObject.
+  def self.rtopHash(rHash)
+    pDict = RubyPython::Python.PyDict_New
+    rHash.each do |k,v|
+      RubyPython::Python.PyDict_SetItem pDict, rtopObject(k, key = true),
+        rtopObject(v)
     end
+    pDict
+  end
 
-    def self.rtopFixnum(rNum)
-      Python.PyInt_FromLong(rNum)
-    end
+  # Convert a Ruby Fixnum to a \Python Int. Returns an FFI::Pointer to a
+  # PyIntObject.
+  def self.rtopFixnum(rNum)
+    RubyPython::Python.PyInt_FromLong(rNum)
+  end
 
-    def self.rtopBigNum(rNum)
-      Python.PyLong_FromLong(rNum)
-    end
+  # Convert a Ruby Bignum to a \Python Long. Returns an FFI::Pointer to a
+  # PyLongObject.
+  def self.rtopBigNum(rNum)
+    RubyPython::Python.PyLong_FromLong(rNum)
+  end
 
-    def self.rtopFloat(rNum)
-      Python.PyFloat_FromDouble(rNum)
-    end
+  # Convert a Ruby float to a \Python Float. Returns an FFI::Pointer to a
+  # PyFloatObject.
+  def self.rtopFloat(rNum)
+    RubyPython::Python.PyFloat_FromDouble(rNum)
+  end
 
-    def self.rtopFalse
-      Macros.Py_RETURN_FALSE
-    end
+  # Returns a \Python False value (equivalent to Ruby's +false+). Returns an
+  # FFI::Pointer to Py_ZeroStruct.
+  def self.rtopFalse
+    RubyPython::Macros.Py_RETURN_FALSE
+  end
 
-    def self.rtopTrue
-      Macros.Py_RETURN_TRUE
-    end
+  # Returns a \Python True value (equivalent to Ruby's +true+). Returns an
+  # FFI::Pointer to Py_TrueStruct.
+  def self.rtopTrue
+    RubyPython::Macros.Py_RETURN_TRUE
+  end
 
-    def self.rtopNone
-      Macros.Py_RETURN_NONE
-    end
+  # Returns a \Python None value (equivalent to Ruby's +nil+). Returns an
+  # FFI::Pointer to Py_NoneStruct.
+  def self.rtopNone
+    RubyPython::Macros.Py_RETURN_NONE
+  end
 
-    def self.rtopSymbol(rSymbol)
-      Python.PyString_FromString rSymbol.to_s
-    end
+  # Convert a Ruby Symbol to a \Python String. Returns an FFI::Pointer to a
+  # PyStringObject.
+  def self.rtopSymbol(rSymbol)
+    RubyPython::Python.PyString_FromString rSymbol.to_s
+  end
 
-    def self.rtopProc(rObj)
-      pyMethodDef = Python::PyMethodDef.new
-      callback = Proc.new do |py_self, py_args|
-        ret = rObj.call(*RubyPyProxy.new(py_args).to_a)
-        PyObject.convert(ret)[0].pointer
-      end
-      pyMethodDef[:ml_name] = FFI::MemoryPointer.from_string "Proc::#{rObj.object_id}"
-      pyMethodDef[:ml_meth] = callback
-      pyMethodDef[:ml_flags] = Python::METH_VARARGS
-      pyMethodDef[:ml_doc] = nil
+  # Convert a Ruby Proc to a \Python Function. Returns an FFI::Pointer to a
+  # PyCFunction.
+  def self.rtopFunction(rObj)
+    proc = FFI::Function.new(:pointer, [:pointer, :pointer]) do |p_self, p_args|
+      retval = rObj.call(*ptorTuple(p_args))
+      pObject = retval.is_a?(RubyPython::RubyPyProxy) ? retval.pObject : RubyPython::PyObject.new(retval)
 
-      Python::PyCFunction_New pyMethodDef, nil
+      # make sure the refcount is >1 when pObject is destroyed
+      pObject.xIncref
+      pObject.pointer
     end
 
-    #If possible converts a ruby type to an equivalent
-    #python native type.
-    #@param rObj a native ruby type
-    #@param [Boolean] is_key whether this object will be used as a key in a
-    #  python dict.
-    #@return [FFI::Pointer] a pointer to a C PyObject\*
-    #@raise [UnsupportedConversion]
-    def self.rtopObject(rObj, is_key=false)
-      case rObj
-      when String
-        rtopString rObj
-      when Array
-        # If this object is going to be used as a
-        # hash key we should make it a tuple instead
-        # of a list
-        if is_key
-          rtopArrayToTuple rObj
-        else
-          rtopArrayToList rObj
-        end
-      when Hash
-        rtopHash rObj
-      when Fixnum
-        rtopFixnum rObj
-      when Bignum
-        rtopBignum rObj
-      when Float
-        rtopFloat rObj
-      when true
-        rtopTrue
-      when false
-        rtopFalse
-      when Symbol
-        rtopSymbol rObj
-      when nil
-        rtopNone
-      when Proc, Method
-        raise UnsupportedConversion.new("Python to Ruby callbacks not suppported in legacy mode") if RubyPython.legacy_mode
-        rtopProc rObj
+    defn = RubyPython::Python::PyMethodDef.new
+    defn[:ml_name] = FFI::MemoryPointer.from_string("RubyPython::Proc::%s" % rObj.object_id)
+    defn[:ml_meth] = proc
+    defn[:ml_flags] = RubyPython::Python::METH_VARARGS
+    defn[:ml_doc] = nil
+
+    return RubyPython::Python.PyCFunction_New(defn, nil)
+  end
+
+  # This will attempt to convert a Ruby object to an equivalent \Python
+  # native type. Returns an FFI::Pointer to a \Python object (the
+  # appropriate Py…Object C structure). If the conversion is unsuccessful,
+  # will raise UnsupportedConversion.
+  #
+  # [rObj]    A native Ruby object.
+  # [is_key]  Set to +true+ if the provided Ruby object will be used as a
+  #           key in a \Python +dict+. (This primarily matters for Array
+  #           conversion.)
+  def self.rtopObject(rObj, is_key = false)
+    case rObj
+    when String
+      rtopString rObj
+    when Array
+      # If this object is going to be used as a hash key we should make it a
+      # tuple instead of a list
+      if is_key
+        rtopArrayToTuple rObj
       else
-        raise UnsupportedConversion.new("Unsupported type for RTOP conversion." )
+        rtopArrayToList rObj
       end
+    when Hash
+      rtopHash rObj
+    when Fixnum
+      rtopFixnum rObj
+    when Bignum
+      rtopBignum rObj
+    when Float
+      rtopFloat rObj
+    when true
+      rtopTrue
+    when false
+      rtopFalse
+    when Symbol
+      rtopSymbol rObj
+    when Proc, Method
+      if RubyPython.legacy_mode
+        raise UnsupportedConversion.new("Callbacks are not supported in Legacy Mode.")
+      end
+      rtopFunction rObj
+    when Method
+      rtopFunction rObj
+    when nil
+      rtopNone
+    when RubyPython::PyObject
+      rObj.pointer
+    else
+      raise UnsupportedConversion.new("Unsupported type #{rObj.class} for conversion.")
     end
+  end
 
-    def self.ptorString(pString)
-      Python.PyString_AsString(pString)
-    end
+  # Convert an FFI::Pointer to a \Python String (PyStringObject) to a Ruby
+  # String.
+  def self.ptorString(pString)
+    strPtr  = FFI::MemoryPointer.new(:pointer)
+    sizePtr = FFI::MemoryPointer.new(:ssize_t)
 
-    def self.ptorList(pList)
-      rb_array = []
-      list_size = Python.PyList_Size(pList)
+    RubyPython::Python.PyString_AsStringAndSize(pString, strPtr, sizePtr)
 
-      list_size.times do |i|
-        element = Python.PyList_GetItem(pList, i)
-        Python.Py_IncRef element
-        rObject = ptorObject(element)
-        rb_array.push rObject
-      end
+    size = case FFI.find_type(:ssize_t)
+           when FFI.find_type(:long)
+             sizePtr.read_long
+           when FFI.find_type(:int)
+             sizePtr.read_int
+           when FFI.find_type(:long_long)
+             sizePtr.read_long_long
+           else
+             nil
+           end
 
-      rb_array
-    end
+    strPtr.read_pointer.read_string(size)
+  end
 
-    def self.ptorInt(pNum)
-      Python.PyInt_AsLong pNum
-    end
+  # Convert an FFI::Pointer to a \Python List (PyListObject) to a Ruby
+  # Array.
+  def self.ptorList(pList)
+    rb_array = []
+    list_size = RubyPython::Python.PyList_Size(pList)
 
-    def self.ptorLong(pNum)
-      Python.PyLong_AsLong(pNum)
-      #TODO Overflow Checking
+    list_size.times do |i|
+      element = RubyPython::Python.PyList_GetItem(pList, i)
+      # PyList_GetItem returns borrowed ref
+      RubyPython::Python.Py_IncRef element
+      rObject = ptorObject(element)
+      rb_array.push rObject
     end
 
-    def self.ptorFloat(pNum)
-      Python.PyFloat_AsDouble(pNum)
-    end
+    rb_array
+  end
 
-    def self.ptorTuple(pTuple)
-      pList = Python.PySequence_List pTuple
-      rArray = ptorList pList
-      Python.Py_DecRef pList
-      rArray
-    end
+  # Convert an FFI::Pointer to a \Python Int (PyIntObject) to a Ruby Fixnum.
+  def self.ptorInt(pNum)
+    RubyPython::Python.PyInt_AsLong(pNum)
+  end
 
-    def self.ptorDict(pDict)
-      rb_hash = {}
+  # Convert an FFI::Pointer to a \Python Long (PyLongObject) to a Ruby
+  # Fixnum. This version does not do overflow checking, but probably should.
+  def self.ptorLong(pNum)
+    RubyPython::Python.PyLong_AsLong(pNum)
+    # TODO Overflow Checking
+  end
 
-      pos = FFI::MemoryPointer.new :ssize_t
-      pos.write_int 0
-      key = FFI::MemoryPointer.new :pointer
-      val = FFI::MemoryPointer.new :pointer
+  # Convert an FFI::Pointer to a \Python Float (PyFloatObject) to a Ruby
+  # Float.
+  def self.ptorFloat(pNum)
+    RubyPython::Python.PyFloat_AsDouble(pNum)
+  end
 
-      while Python.PyDict_Next(pDict, pos, key, val) != 0
-        pKey = key.read_pointer
-        pVal = val.read_pointer
-        rKey = ptorObject(pKey)
-        rVal = ptorObject(pVal)
-        rb_hash[rKey] = rVal
-      end
+  # Convert an FFI::Pointer to a \Python Tuple (PyTupleObject) to a Ruby
+  # Array.
+  def self.ptorTuple(pTuple)
+    pList = RubyPython::Python.PySequence_List pTuple
+    rArray = ptorList pList
+    RubyPython::Python.Py_DecRef pList
+    rArray
+  end
 
-      rb_hash
+  # Convert an FFI::Pointer to a \Python Dictionary (PyDictObject) to a Ruby
+  # Hash.
+  def self.ptorDict(pDict)
+    rb_hash = {}
+
+    pos = FFI::MemoryPointer.new :ssize_t
+    pos.write_int 0
+    key = FFI::MemoryPointer.new :pointer
+    val = FFI::MemoryPointer.new :pointer
+
+    while RubyPython::Python.PyDict_Next(pDict, pos, key, val) != 0
+      pKey = key.read_pointer
+      pVal = val.read_pointer
+      rKey = ptorObject(pKey)
+      rVal = ptorObject(pVal)
+      rb_hash[rKey] = rVal
     end
 
+    rb_hash
+  end
 
-    #Converts a pointer to a Python object into a native ruby type, if
-    #possible. Otherwise raises an error.
-    #@param [FFI::Pointer] pObj a pointer to a Python object
-    #@return a native ruby object.
-    #@raise {UnsupportedConversion}
-    def self.ptorObject(pObj)
-      if Macros.PyObject_TypeCheck(pObj, Python.PyString_Type.to_ptr) != 0
-        ptorString pObj
-      elsif Macros.PyObject_TypeCheck(pObj, Python.PyList_Type.to_ptr) != 0
-        ptorList pObj
-      elsif Macros.PyObject_TypeCheck(pObj, Python.PyInt_Type.to_ptr) != 0
-        ptorInt pObj
-      elsif Macros.PyObject_TypeCheck(pObj, Python.PyLong_Type.to_ptr) != 0
-        ptorLong pObj
-      elsif Macros.PyObject_TypeCheck(pObj, Python.PyFloat_Type.to_ptr) != 0
-        ptorFloat pObj
-      elsif Macros.PyObject_TypeCheck(pObj, Python.PyTuple_Type.to_ptr) != 0
-        ptorTuple pObj
-      elsif Macros.PyObject_TypeCheck(pObj, Python.PyDict_Type.to_ptr) != 0
-        ptorDict pObj
-      elsif pObj == Macros.Py_True
-        true
-      elsif pObj == Macros.Py_False
-        false
-      elsif pObj == Macros.Py_None
-        nil
-      else
-        pObj
-      end
+  # Converts a pointer to a \Python object into a native Ruby type, if
+  # possible. If the conversion cannot be done, the Python object will be
+  # returned unmodified.
+  #
+  # [pObj]  An FFI::Pointer to a \Python object.
+  def self.ptorObject(pObj)
+    if RubyPython::Macros.PyObject_TypeCheck(pObj, RubyPython::Python.PyString_Type.to_ptr) != 0
+      ptorString pObj
+    elsif RubyPython::Macros.PyObject_TypeCheck(pObj, RubyPython::Python.PyList_Type.to_ptr) != 0
+      ptorList pObj
+    elsif RubyPython::Macros.PyObject_TypeCheck(pObj, RubyPython::Python.PyInt_Type.to_ptr) != 0
+      ptorInt pObj
+    elsif RubyPython::Macros.PyObject_TypeCheck(pObj, RubyPython::Python.PyLong_Type.to_ptr) != 0
+      ptorLong pObj
+    elsif RubyPython::Macros.PyObject_TypeCheck(pObj, RubyPython::Python.PyFloat_Type.to_ptr) != 0
+      ptorFloat pObj
+    elsif RubyPython::Macros.PyObject_TypeCheck(pObj, RubyPython::Python.PyTuple_Type.to_ptr) != 0
+      ptorTuple pObj
+    elsif RubyPython::Macros.PyObject_TypeCheck(pObj, RubyPython::Python.PyDict_Type.to_ptr) != 0
+      ptorDict pObj
+    elsif pObj == RubyPython::Macros.Py_True
+      true
+    elsif pObj == RubyPython::Macros.Py_False
+      false
+    elsif pObj == RubyPython::Macros.Py_None
+      nil
+    else
+      pObj
     end
   end
 end