rubypython-raspi 0.1.0

data/lib/rubypython/legacy.rb

@@ -0,0 +1,18 @@
+require 'rubypython'
+
+# A quick way to activate <em>Legacy Mode</em> for a project. Requiring
+# +'rubypython/legacy' automatically activates +RubyPython.legacy_mode+ on
+# the project. This mode is deprecated and will be removed.
+module RubyPython::LegacyMode
+  # Enables +RubyPython.legacy_mode+.
+  def self.setup_legacy
+    RubyPython.legacy_mode = true
+  end
+
+  # Disables +RubyPython.legacy_mode+.
+  def self.teardown_legacy
+    RubyPython.legacy_mode = false
+  end
+end
+
+RubyPython::LegacyMode.setup_legacy

data/lib/rubypython/macros.rb

@@ -0,0 +1,56 @@
+require 'ffi'
+require 'rubypython/python'
+
+# Contains Python C API macros reimplemented in Ruby. For internal use only.
+module RubyPython::Macros #:nodoc:
+  # Returns the reference count for the provided pointer.
+  def self.Py_REFCNT(pObjPointer)
+    pStruct = RubyPython::Python::PyObjectStruct.new pObjPointer
+    pStruct[:ob_refcnt]
+  end
+
+  # Returns the object type for the provided pointer.
+  def self.Py_TYPE(pObjPointer)
+    pStruct = RubyPython::Python::PyObjectStruct.new pObjPointer
+    pStruct[:ob_type]
+  end
+
+  # This has been modified from the C API macro to allow for multiple
+  # pointer objects to be passed. It simplifies a number of checks.
+  def self.PyObject_TypeCheck(pObject, pTypePointer)
+    type = self.Py_TYPE(pObject)
+
+    [ pTypePointer ].flatten.each do |pointer|
+      return 1 if type == pointer
+    end
+
+    return 0
+  end
+
+  def self.Py_True
+    RubyPython::Python.Py_TrueStruct.to_ptr
+  end
+
+  def self.Py_False
+    RubyPython::Python.Py_ZeroStruct.to_ptr
+  end
+
+  def self.Py_None
+    RubyPython::Python.Py_NoneStruct.to_ptr
+  end
+
+  def self.Py_RETURN_FALSE
+    RubyPython::Python.Py_IncRef(self.Py_False)
+    self.Py_False
+  end
+
+  def self.Py_RETURN_TRUE
+    RubyPython::Python.Py_IncRef(self.Py_True)
+    self.Py_True
+  end
+
+  def self.Py_RETURN_NONE
+    RubyPython::Python.Py_IncRef(self.Py_None)
+    self.Py_None
+  end
+end

data/lib/rubypython/operators.rb

@@ -0,0 +1,124 @@
+# 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 RubyPython::Operators
+  # Provides access to the \Python _operator_ module.
+  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}.
+  # [rname] The name of the Ruby method for this operation. Can be either a
+  # Symbol or a 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.
+  #
+  # [rname] The name of the Ruby method for this operation. Can be a Symbol
+  # or a 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|
+      RubyPython::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.
+  # [rname] The name of the Ruby method for this operation. Can be a Symbol
+  # or a 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
+      RubyPython::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
+
+  # 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)
+    RubyPython::PyMain.cmp(self, other)
+  end
+
+  class << self
+    # Called by RubyPython when the interpreter is started or stopped so
+    # that the necessary preparation or cleanup can be done. For internal
+    # use only.
+    def python_interpreter_update(status)
+      case status
+      when :stop
+        @@operator = nil
+      end
+    end
+    private :python_interpreter_update
+  end
+
+  # Aliases eql? to == for Python objects.
+  alias_method :eql?, :==
+end

data/lib/rubypython/pygenerator.rb

@@ -0,0 +1,61 @@
+require "rubypython/python"
+require "rubypython/conversion"
+require 'rubypython/macros'
+require 'rubypython/conversion'
+require 'rubypython/pyobject'
+require "rubypython/pymainclass"
+require "rubypython/rubypyproxy"
+
+if defined? Fiber
+  module RubyPython
+    class << self
+      # Creates a \Python generator object called +rubypython_generator+
+      # that accepts a callback and yields to it.
+      #
+      # *Note*: This method only exists in the RubyPython if the Fiber
+      # exists.
+      def generator_type
+        @generator_type ||= lambda do
+          code = <<-EOM
+def rubypython_generator(callback):
+  while True:
+    yield callback()
+          EOM
+
+          globals = PyObject.new({ "__builtins__" => PyMain.builtin.pObject, })
+          empty_hash = PyObject.new({})
+          ptr = Python.PyRun_String(code, Python::PY_FILE_INPUT, globals.pointer, empty_hash.pointer)
+          ptr = Python.PyRun_String("rubypython_generator", Python::PY_EVAL_INPUT, globals.pointer, empty_hash.pointer)
+          raise PythonError.handle_error if PythonError.error?
+          RubyPyProxy.new(PyObject.new(ptr))
+        end.call
+      end
+
+      # Creates a Ruby lambda that acts like a \Python generator. Uses
+      # +RubyPython.generator_type+ and Fiber to work the generator as a
+      # coroutine.
+      #
+      # *Note*: This method only exists in the RubyPython if the Fiber
+      # exists.
+      def generator
+        return lambda do |*args|
+          fib = Fiber.new do
+            yield *args
+            Python.PyErr_SetNone(Python.PyExc_StopIteration)
+            FFI::Pointer::NULL
+          end
+          generator_type.__call__(lambda { fib.resume })
+        end
+      end
+
+      # Performs a +Fiber.yield+ with the provided arguments, continuing the
+      # coroutine execution of the generator.
+      #
+      # *Note*: This method only exists in the RubyPython if the Fiber
+      # exists.
+      def yield(*args)
+        Fiber.yield(*args)
+      end
+    end
+  end
+end

data/lib/rubypython/pymainclass.rb

@@ -0,0 +1,80 @@
+require 'rubypython/blankobject'
+require 'singleton'
+
+module RubyPython
+  # A singleton object providing access to the \Python <tt>__main__</tt> and
+  # <tt>__builtin__</tt> modules. This can be conveniently accessed through
+  # +PyMain+. The <tt>__main__</tt> namespace is searched before the
+  # <tt>__builtin__</tt> namespace. As such, naming clashes will be resolved
+  # in that order.
+  #
+  #   RubyPython::PyMain.dir("dir") # => ['__add__', '__class__', … ]
+  #
+  # === Block Syntax
+  # PyMainClass provides experimental block support for called methods. 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.
+  #
+  #   RubyPython::PyMain.dir("dir") { |a| a.rubify.map { |e| e.to_sym } }
+  #     # => [:__add__, :__class__, :__contains__, … ]
+  class PyMainClass < RubyPython::BlankObject
+    include Singleton
+
+    # Returns a proxy object wrapping the \Python <tt>__main__</tt> namespace.
+    def main
+      @main ||= RubyPython.import "__main__"
+    end
+
+    # Returns a proxy object wrapping the \Python <tt>__builtin__</tt>
+    # namespace.
+    def builtin
+      @builtin ||= RubyPython.import "__builtin__"
+    end
+
+    # Delegates any method calls on this object to the \Python
+    # <tt>__main__</tt> or <tt>__builtin__</tt> namespaces, in that order. If
+    # a block is provided, the result of calling the \Python method will be
+    # yielded as an argument to the block.
+    #
+    # [name] The name of the \Python method or function to call.
+    # [args] The arguments to pass to the \Python method.
+    # [block] A block to execute with the result of calling the \Python
+    # method. If a block is provided, the result of the block is returned,
+    # not the result of the \Python method.
+    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
+
+      if block
+        block.call(result)
+      else
+        result
+      end
+    end
+
+    # Called by RubyPython when the interpreter is started or stopped so
+    # that the neccesary preparation or cleanup can be done. For internal
+    # use only.
+    def python_interpreter_update(status)
+      case status
+      when :stop
+        @main = nil
+        @builtin = nil
+      end
+    end
+    private :python_interpreter_update
+  end
+
+  # The accessible instance of PyMainClass.
+  PyMain = RubyPython::PyMainClass.instance
+end

data/lib/rubypython/pyobject.rb

@@ -0,0 +1,232 @@
+require 'rubypython/python'
+require 'rubypython/macros'
+require 'rubypython/conversion'
+require 'ffi'
+
+# This object is an opaque wrapper around the C Py…Object types used by the
+# \Python C API.
+#
+# This class is *only* for RubyPython internal use.
+class RubyPython::PyObject # :nodoc: all
+  # This class wraps C <tt>Py…Object</tt>s so that the RubyPython::Python
+  # reference count is automatically decreased when the Ruby object
+  # referencing them goes out of scope.
+  class AutoPyPointer < FFI::AutoPointer # :nodoc:
+    class << self
+      # Keeps track of which objects are associated with the currently
+      # running RubyPython::Python interpreter, so that RubyPython knows not
+      # to try to decrease the reference counts of the others when garbage
+      # collecting.
+      attr_accessor :current_pointers
+
+      # When used along with the FFI Library method is executed whenever a
+      # pointer is garbage collected so that cleanup can be done. In our
+      # case we decrease the reference count of the held pointer as long as
+      # the object is still good. There is really no reason the end-user
+      # would need to the use this method directly.
+      def release(pointer)
+        obj_id = pointer.object_id
+        deleted = @current_pointers.delete(obj_id)
+        if deleted and (RubyPython::Python.Py_IsInitialized != 0)
+          RubyPython::Python.Py_DecRef pointer
+        end
+      end
+
+      # Called by RubyPython when the interpreter is started or stopped so
+      # that the necessary preparation or cleanup can be done. For internal
+      # use only.
+      def python_interpreter_update(status)
+        case status
+        when :stop
+          current_pointers.clear
+        end
+      end
+      private :python_interpreter_update
+    end
+
+    self.current_pointers = {}
+  end
+
+  # The AutoPyPointer object which represents the RubyPython::Python
+  # Py…Object.
+  attr_reader :pointer
+
+  # [rObject] FFI Pointer objects passed into the constructor are wrapped in
+  # an AutoPyPointer and assigned to the +#pointer+ attribute. Other objects
+  # are converted, if possible, from their Ruby types to their \Python types
+  # and wrapped in an AutoPyPointer. The conversion is done with
+  # +RubyPython::Conversion.rtopObject+.
+  def initialize(rObject)
+    if rObject.kind_of? FFI::AutoPointer
+      new_pointer = FFI::Pointer.new rObject
+      @pointer = AutoPyPointer.new new_pointer
+      xIncref
+    elsif rObject.kind_of? FFI::Pointer
+      @pointer = AutoPyPointer.new rObject
+    else
+      @pointer = AutoPyPointer.new RubyPython::Conversion.rtopObject(rObject)
+    end
+    AutoPyPointer.current_pointers[@pointer.object_id] = true
+  end
+
+  # Attempts to convert the wrapped object to a native ruby type. Returns
+  # either the Ruby object or the unmodified \Python object.
+  def rubify
+    RubyPython::Conversion.ptorObject @pointer
+  end
+
+  # Tests whether the wrapped \Python object has a given attribute. Returns
+  # +true+ if the attribute exists.
+  # [attrName] The name of the attribute to look up.
+  def hasAttr(attrName)
+    RubyPython::Python.PyObject_HasAttrString(@pointer, attrName) == 1
+  end
+
+  # Retrieves an object from the wrapped \Python object.
+  # [attrName] The name of the attribute to fetch.
+  def getAttr(attrName)
+    pyAttr = RubyPython::Python.PyObject_GetAttrString(@pointer, attrName)
+    self.class.new pyAttr
+  end
+
+  # Sets an attribute of the wrapped \Python object. Returns +true+ if the
+  # attribute was successfully set.
+  # [attrName] The name of the attribute to set.
+  # [rbPyAttr] A PyObject wrapper around the value that we wish to set the
+  # attribute to.
+  def setAttr(attrName, rbPyAttr)
+    RubyPython::Python.PyObject_SetAttrString(@pointer, attrName, rbPyAttr.pointer) != -1
+  end
+
+  # Calls the wrapped \Python object with the supplied arguments and keyword
+  # arguments. Returns a PyObject wrapper around the returned object, which
+  # may be +NULL+.
+  # [rbPyArgs]      A PyObject wrapping a Tuple of the supplied arguments.
+  # [rbPyKeywords]  A PyObject wrapping a Dict of keyword arguments.
+  def callObjectKeywords(rbPyArgs, rbPyKeywords)
+    pyReturn = RubyPython::Python.PyObject_Call(@pointer, rbPyArgs.pointer, rbPyKeywords.pointer)
+    self.class.new pyReturn
+  end
+
+  # Calls the wrapped \Python object with the supplied arguments. Returns a
+  # PyObject wrapper around the returned object, which may be +NULL+.
+  # [rbPyArgs]  A PyObject wrapping a Tuple of the supplied arguments.
+  def callObject(rbPyArgs)
+    pyReturn = RubyPython::Python.PyObject_CallObject(@pointer, rbPyArgs.pointer)
+    self.class.new pyReturn
+  end
+
+  # Decrease the reference count of the wrapped object.
+  def xDecref
+    AutoPyPointer.release(@pointer)
+    @pointer.free
+    nil
+  end
+
+  # Increase the reference count of the wrapped object
+  def xIncref
+    RubyPython::Python.Py_IncRef @pointer
+    nil
+  end
+
+  # Tests whether the wrapped object is +NULL+.
+  def null?
+    @pointer.null?
+  end
+
+  # Performs a compare on two Python objects. Returns a value similar to
+  # that of the spaceship operator (<=>).
+  def cmp(other)
+    RubyPython::Python.PyObject_Compare @pointer, other.pointer
+  end
+
+  # Tests whether the wrapped object is a function or a method. This is not
+  # the same as #callable? as many other \Python objects are callable.
+  def function_or_method?
+    check = RubyPython::Macros.PyObject_TypeCheck(@pointer, [
+                                                  RubyPython::Python.PyFunction_Type.to_ptr,
+                                                  RubyPython::Python.PyCFunction_Type.to_ptr,
+                                                  RubyPython::Python.PyMethod_Type.to_ptr
+    ])
+    check != 0
+  end
+
+  # Is the wrapped object callable?
+  def callable?
+    RubyPython::Python.PyCallable_Check(@pointer) != 0
+  end
+
+  # Returns the 'directory' of the RubyPython::Python object; similar to #methods in
+  # Ruby.
+  def dir
+    return self.class.new(RubyPython::Python.PyObject_Dir(@pointer)).rubify.map do |x|
+      x.to_sym
+    end
+  end
+
+  # Tests whether the wrapped object is a RubyPython::Python class (both new
+  # and old style).
+  def class?
+    check = RubyPython::Macros.PyObject_TypeCheck(@pointer, [
+                                                  RubyPython::Python.PyClass_Type.to_ptr,
+                                                  RubyPython::Python.PyType_Type.to_ptr
+    ])
+    check != 0
+  end
+
+  # Manipulates the supplied PyObject instance such that it is suitable to
+  # passed to #callObject or #callObjectKeywords. If +rbObject+ is a tuple
+  # then the argument passed in is returned. If it is a list then the list
+  # is converted to a tuple. Otherwise returns a tuple with one element:
+  # +rbObject+.
+  # [rbObject]  The argument to be turned into a Tuple.
+  def self.makeTuple(rbObject)
+    pTuple = nil
+
+    if RubyPython::Macros.PyObject_TypeCheck(rbObject.pointer, RubyPython::Python.PyList_Type.to_ptr) != 0
+      pTuple = RubyPython::Python.PySequence_Tuple(rbObject.pointer)
+    elsif RubyPython::Macros.PyObject_TypeCheck(rbObject.pointer, RubyPython::Python.PyTuple_Type.to_ptr) != 0
+      pTuple = rbObject.pointer
+    else
+      pTuple = RubyPython::Python.PyTuple_Pack(1, :pointer, rbObject.pointer)
+    end
+
+    self.new pTuple
+  end
+
+  # Wraps up the supplied arguments in a \Python List.
+  def self.newList(*args)
+    rbList = self.new RubyPython::Python.PyList_New(args.length)
+
+    args.each_with_index do |el, i|
+      el.xIncref # PyList_SetItem steals references!
+      RubyPython::Python.PyList_SetItem rbList.pointer, i, el.pointer
+    end
+
+    rbList
+  end
+
+  # Converts the supplied arguments to PyObject instances.
+  def self.convert(*args)
+    args.map do |arg|
+      if arg.kind_of? RubyPython::PyObject
+        arg
+      elsif arg.kind_of? RubyPython::RubyPyProxy
+        arg.pObject
+      else
+        RubyPython::PyObject.new arg
+      end
+    end
+  end
+
+  # Takes an array of wrapped \Python objects and wraps them in a Tuple such
+  # that they may be passed to #callObject.
+  # [args] An array of PyObjects; the arguments to be inserted into the
+  # Tuple.
+  def self.buildArgTuple(*args)
+    pList = newList(*args)
+    pTuple = makeTuple(pList)
+    pList.xDecref
+    pTuple
+  end
+end