rubypython 0.2.11 → 0.3.0

data/lib/rubypython/blankobject.rb

@@ -0,0 +1,21 @@
+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)/
+          @hidden_methods ||= {}
+          @hidden_methods[name.to_sym] = instance_method(name)
+          undef_method name
+        end
+      end
+    end
+
+    instance_methods.each { |m| hide(m) }
+  end
+end

data/lib/rubypython/conversion.rb

@@ -0,0 +1,198 @@
+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
+
+    def self.rtopString(rString)
+      Python.PyString_FromString(rString)
+    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
+    end
+
+    def self.rtopArrayToTuple(rArray)
+      pList = rtopArrayToList(rArray)
+      pTuple = Python.PySequence_Tuple(pList)
+      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
+    end
+
+    def self.rtopFixnum(rNum)
+      Python.PyInt_FromLong(rNum)
+    end
+
+    def self.rtopBigNum(rNum)
+      Python.PyLong_FromLong(rNum)
+    end
+
+    def self.rtopFloat(rNum)
+      Python.PyFloat_FromDouble(rNum)
+    end
+
+    def self.rtopFalse
+      Macros.Py_RETURN_FALSE
+    end
+
+    def self.rtopTrue
+      Macros.Py_RETURN_TRUE
+    end
+
+    def self.rtopNone
+      Macros.Py_RETURN_NONE
+    end
+
+    def self.rtopSymbol(rSymbol)
+      Python.PyString_FromString rSymbol.to_s
+    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 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
+      else
+        raise UnsupportedConversion.new("Unsupported type for RTOP conversion." )
+      end
+    end
+
+    def self.ptorString(pString)
+      Python.PyString_AsString(pString)
+    end
+
+    def self.ptorList(pList)
+      rb_array = []
+      list_size = Python.PyList_Size(pList)
+
+      list_size.times do |i|
+        element = Python.PyList_GetItem(pList, i)
+        Python.Py_IncRef element
+        rObject = ptorObject(element)
+        rb_array.push rObject
+      end
+
+      rb_array
+    end
+
+    def self.ptorInt(pNum)
+      Python.PyInt_AsLong pNum
+    end
+
+    def self.ptorLong(pNum)
+      Python.PyLong_AsLong(pNum)
+      #TODO Overflow Checking
+    end
+
+    def self.ptorFloat(pNum)
+      Python.PyFloat_AsDouble(pNum)
+    end
+
+    def self.ptorTuple(pTuple)
+      pList = Python.PySequence_List pTuple
+      rArray = ptorList pList
+      Python.Py_DecRef pList
+      rArray
+    end
+
+    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 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
+    end
+  end
+end

data/lib/rubypython/core_ext/string.rb

@@ -0,0 +1,7 @@
+class String
+  #This is necessary for Ruby versions 1.8.6 and below as 
+  #String#end_with? is not defined in this case.
+  def end_with?(c)
+    self[-1].chr == c
+  end
+end unless String.respond_to? :end_with?

data/lib/rubypython/legacy.rb

@@ -0,0 +1,15 @@
+require 'rubypython'
+
+module RubyPython::LegacyMode
+  class << self
+    def setup_legacy
+      RubyPython.legacy_mode = true
+    end
+
+    def teardown_legacy
+      RubyPython.legacy_mode = false
+    end
+  end
+end
+
+RubyPython::LegacyMode.setup_legacy

data/lib/rubypython/macros.rb

@@ -0,0 +1,47 @@
+require 'ffi'
+require 'rubypython/python'
+
+module RubyPython
+  #Contains Python C API macros reimplmented in Ruby. For internal use only.
+  module Macros
+    def self.Py_TYPE(pObjPointer)
+      pStruct = Python::PyObjectStruct.new pObjPointer
+      pStruct[:ob_type]
+    end
+
+    def self.PyObject_TypeCheck(pObject, pTypePointer)
+      if Py_TYPE(pObject) == pTypePointer
+        1
+      else
+        0
+      end
+    end
+
+    def self.Py_True
+      Python.Py_TrueStruct.to_ptr
+    end
+
+    def self.Py_False
+      Python.Py_ZeroStruct.to_ptr
+    end
+
+    def self.Py_None
+      Python.Py_NoneStruct.to_ptr
+    end
+
+    def self.Py_RETURN_FALSE
+      Python.Py_IncRef(self.Py_False)
+      self.Py_False
+    end
+
+    def self.Py_RETURN_TRUE
+      Python.Py_IncRef(self.Py_True)
+      self.Py_True
+    end
+
+    def self.Py_RETURN_NONE
+      Python.Py_IncRef(self.Py_None)
+      self.Py_None
+    end
+  end
+end

data/lib/rubypython/operators.rb

@@ -0,0 +1,111 @@
+module RubyPython
+  #A mixin module to provide method delegation to a proxy class. This is done
+  #either by delegating to methods defined on the wrapped object or by using the
+  #Python _operator_ module. A large number of the methods are dynamically
+  #generated and so their documentation is not provided here. In general all
+  #operators that can be overloaded are delegated.
+  module Operators
+    #Provides access to the Python _operator_ module.
+    #@return[RubyPython::RubyPyModule]
+    def self.operator_
+      @@operator ||= RubyPython.import('operator')
+    end
+
+    #Creates a method to delegate a binary operation. The result of the
+    #operation will follow the conversion rules appropriate to the current mode
+    #of operation as set by {RubyPython.legacy_mode}.
+    #@param[Symbol, String] rname The name of the Ruby method for this operation
+    #@param[String] pname The name of the Python magic method to which this
+    #method should be delegated.
+    def self.bin_op rname, pname
+      define_method rname.to_sym do |other|
+        self.__send__ pname, other
+      end
+    end
+
+    #Creates a method to delegate a relational operator. The result of the
+    #delegated method will always be converted to a Ruby type so that simple
+    #boolean testing may occur. These methods are implemented with calls the
+    #_operator_ module.
+    #@param[Symbol, String] rname The name of the Ruby method for this operation
+    #@param[String] pname The name of the Python magic method to which this
+    #method should be delegated.
+    def self.rel_op rname, pname
+      define_method rname.to_sym do |other|
+        Operators.operator_.__send__(pname, self, other).rubify
+      end
+    end
+
+    #Creates a method to delegate a relational operator. The result of the
+    #operation will follow the conversion rules appropriate to the current mode
+    #of operation as set by {RubyPython.legacy_mode}. These methods are
+    #implemented with calls the _operator_ module.
+    #@param[Symbol, String] rname The name of the Ruby method for this operation
+    #@param[String] pname The name of the Python magic method to which this
+    #method should be delegated.
+    def self.unary_op rname, pname
+      define_method rname.to_sym do 
+        Operators.operator_.__send__(pname, self)
+      end
+    end
+
+
+    [
+      [:+, '__add__'],
+      [:-, '__sub__'],
+      [:*, '__mul__'],
+      [:/, '__div__'],
+      [:&, '__and__'],
+      [:^, '__xor__'],
+      [:%, '__mod__'],
+      [:**, '__pow__'],
+      [:>>, '__rshift__'],
+      [:<<, '__lshift__'],
+      [:|, '__or__']
+    ].each do |args|
+      bin_op *args
+    end
+
+    [
+      [:~, :__invert__],
+      [:+@, :__pos__],
+      [:-@, :__neg__]
+    ].each do |args|
+      unary_op *args
+    end
+
+    [
+      [:==, 'eq'],
+      [:<, 'lt'],
+      [:<=, 'le'],
+      [:>, 'gt'],
+      [:>=, 'ge'],
+      [:equal?, 'is_']
+    ].each do |args|
+      rel_op *args
+    end
+
+    alias :eql? :==
+
+    #Delegates object indexed access to the wrapped Python object.
+    def [](index)
+      self.__getitem__ index
+    end
+
+    #Delegates setting of various indices to the wrapped Python object.
+    def []=(index, value)
+      self.__setitem__ index, value
+    end
+
+    #Delegates membership testing to Python.
+    def include?(item)
+      self.__contains__(item).rubify
+    end
+
+    #Delegates Comparison to Python.
+    def <=>(other)
+      PyMain.cmp(self, other)
+    end
+
+  end
+end

data/lib/rubypython/pymainclass.rb

@@ -0,0 +1,51 @@
+require 'rubypython/blankobject'
+require 'singleton'
+
+module RubyPython
+  # A singleton object providing access to the python \_\_main\_\_ and
+  # \_\_builtin\_\_ modules.  This can be conveniently accessed through the
+  # already instaniated PyMain constant.  The \_\_main\_\_ namespace is
+  # searched before the \_\_builtin\_\_ namespace. As such, naming clashes will
+  # be resolved in that order.
+  #
+  # ## Block Syntax
+  # The PyMainClass object provides somewhat experimental block support.  A
+  # block may be passed to a method call and the object returned by the
+  # function call will be passed as an argument to the block.
+  class PyMainClass < BlankObject
+    include Singleton
+    attr_writer :main, :builtin
+    
+    #@return [RubyPyModule] a proxy object wrapping the Python \__main\__
+    #namespace.
+    def main 
+      @main||=RubyPython.import "__main__"
+    end
+    
+    #@return [RubyPyModule] a proxy object wrapping the Python \__builtin\__
+    #namespace.
+    def builtin
+      @builtin||=RubyPython.import "__builtin__"
+    end
+
+    #Delegates any method calls on this object to the Python \__main\__ or
+    #\__builtin\__ namespaces. Method call resolution occurs in that order.
+    def method_missing(name,*args,&block)
+      proxy = if main.respond_to?(name)
+                main
+              elsif builtin.respond_to?(name)
+                builtin
+              else
+                super(name, *args)
+              end
+      result = if proxy.is_real_method?(name)
+                 proxy.__send__(name, *args)
+               else
+                 proxy.__send__(:method_missing, name,*args)
+               end
+      block ? block.call(result) : result
+    end
+  end
+
+  PyMain = PyMainClass.instance
+end