rubypython-raspi 0.1.0

data/lib/rubypython/type.rb

@@ -0,0 +1,20 @@
+module RubyPython
+  # Creates a Ruby class that inherits from a proxied Python object.
+  def self.Type(name)
+    mod, match, klass = name.rpartition(".")
+    pymod = RubyPython.import(mod)
+    pyclass = pymod.pObject.getAttr(klass)
+    rclass = Class.new(RubyPyProxy) do
+      define_method(:initialize) do |*args|
+        args = PyObject.convert(*args)
+        pTuple = PyObject.buildArgTuple(*args)
+        pReturn = pyclass.callObject(pTuple)
+        if PythonError.error?
+          raise PythonError.handle_error
+        end
+        @pObject = pReturn
+      end
+    end
+    return rclass
+  end
+end

data/spec/basic_spec.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include TestConstants
+
+describe "RubyPython" do
+  it "can import and use a native extension like cPickle" do
+    cPickle = RubyPython.import("cPickle")
+    string = cPickle.dumps("Testing RubyPython.")
+    string.should_not be_a_kind_of String
+    string.rubify.should be_a_kind_of String
+    string.rubify.should == "S'Testing RubyPython.'\np1\n."
+  end
+
+  it "can import and use a pure Python extension like pickle" do
+    pickle = RubyPython.import("pickle")
+    string = pickle.dumps("Testing RubyPython.")
+    string.should_not be_a_kind_of String
+    string.rubify.should be_a_kind_of String
+    string.rubify.should == "S'Testing RubyPython.'\np0\n."
+  end
+
+  it "can use iterators from Python" do
+    items = []
+    @basics.iterate_list.to_enum.each { |item| items << item }
+    items.should == [ 1, 2, 3 ]
+  end
+
+  it "can use Ruby procs as callbacks to Python code" do
+    @basics.simple_callback(lambda { |v| v * v }, 4).should == 16
+  end
+
+  it "can use Ruby methods as callbacks to Python code" do
+    def triple(v)
+      v * 3
+    end
+    @basics.simple_callback(method(:triple), 4).should == 12
+  end
+
+  it "can feed a Python generator in Ruby 1.9", :ruby_version => '1.9' do
+    output = @basics.simple_generator(RubyPython.generator do
+      (1..10).each { |i| RubyPython.yield i }
+    end)
+    output.should == [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
+  end
+
+  it "can use named parameters to functions" do
+    @basics.named_args(2, 1).should == [ 2, 1 ]
+    @basics.named_args!(:arg2 => 2, :arg1 => 1).should == [ 1, 2 ]
+  end
+end

data/spec/callback_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include TestConstants
+
+describe 'Callbacks' do
+  {
+    '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],
+    ["a string with nulls", AStringWithNULLs],
+    ["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

data/spec/conversion_spec.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include TestConstants
+
+describe RubyPython::Conversion do
+  subject { RubyPython::Conversion }
+
+  context "when converting from Python to Ruby" do
+    [
+      ["an int", "an int", AnInt],
+      ["a float", "a float", AFloat],
+      ["a string", "a string", AString],
+      ["a string_with_nulls", "a string_with_nulls", AStringWithNULLs],
+      ["a list", "an array", AnArray],
+      ["a tuple", "a tuple", ATuple],
+      ["a dict", "a hash", AConvertedHash],
+      ["python True", "true", true],
+      ["python False", "false", false],
+      ["python None", "nil", nil]
+    ].each do |py_type, rb_type, output|
+      it "should convert #{py_type} to #{rb_type}" do
+        py_object_ptr = @objects.__send__(py_type.sub(' ', '_')).pObject.pointer
+        obj = subject.ptorObject(py_object_ptr)
+        obj.should == output
+        obj.class.should == output.class
+      end
+    end
+
+    it "should return an FFI::Pointer when it cannot convert" do
+      unconvertable = @objects.RubyPythonMockObject.pObject.pointer
+      subject.ptorObject(unconvertable).should be_a_kind_of(FFI::Pointer)
+    end
+  end
+
+  context "when converting Ruby to Python" do
+    [
+      ["an int", "an int", AnInt],
+      ["a float", "a float", AFloat],
+      ["a string", "a string", AString],
+      ["a string_with_nulls", "a string_with_nulls", AStringWithNULLs],
+      ["a string", "a symbol", ASym],
+      ["a list", "an array", AnArray],
+      ["a tuple", "a tuple", ATuple ],
+      ["a dict", "a hash", AConvertedHash],
+      ["python True", "true", true],
+      ["python False", "false", false],
+      ["python None", "nil", nil],
+      ["a function", "a proc", AProc, true]
+    ].each do |py_type, rb_type, input, no_compare|
+      it "should convert #{rb_type} to #{py_type}" do
+        py_object_ptr = subject.rtopObject(input)
+        unless no_compare
+          output = @objects.__send__(rb_type.sub(' ', '_')).pObject.pointer
+          RubyPython::Python.PyObject_Compare(py_object_ptr, output).should == 0
+        end
+      end
+    end
+
+    it "should raise an exception when it cannot convert" do
+      lambda { subject.rtopObject(Class) }.should raise_exception(subject::UnsupportedConversion)
+    end
+
+    it "should convert a tuple correctly" do
+      @basics.expects_tuple(AnArray).should == false
+      @basics.expects_tuple(RubyPython::Tuple.tuple(AnArray)).should == true
+    end
+  end
+end

data/spec/legacy_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include TestConstants
+
+describe 'RubyPython Legacy Mode Module' do
+  before :all do
+    require 'rubypython/legacy'
+  end
+
+  after :all do
+    RubyPython::LegacyMode.teardown_legacy
+  end
+
+  describe "when required" do
+    it "should enable legacy mode" do
+      RubyPython.legacy_mode.should == true
+    end
+
+    [
+      ["an int", "an int", AnInt],
+      ["a float", "a float", AFloat],
+      ["a string", "a string", AString],
+      ["a list", "an array", AnArray],
+      ["a tuple", "an array", AnArray],
+      ["a dict", "a hash", AConvertedHash],
+      ["python True", "true", true],
+      ["python False", "false", false],
+      ["python None", "nil", nil]
+    ].each do |py_type, rb_type, output|
+      it "implicitly converts #{py_type} to #{rb_type}" do
+        @objects.__send__(py_type.sub(' ', '_')).should == output
+      end
+    end
+
+    [
+      ["proc", AProc],
+      ["method", AMethod]
+    ].each do |rb_type, rb_obj| 
+      it "raises an exception if a #{rb_type} callback is supplied" do
+        lambda do
+          @objects.apply_callback(rb_obj, [1, 1])
+        end.should raise_exception(RubyPython::Conversion::UnsupportedConversion)
+      end
+    end
+  end
+end

data/spec/pymainclass_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include TestConstants
+
+describe RubyPython::PyMainClass do
+  subject { RubyPython::PyMain }
+
+  it "should delegate to builtins" do
+    subject.float(AnInt).rubify.should == AnInt.to_f
+  end
+
+  it "should handle block syntax" do
+    subject.float(AnInt) {|f| f.rubify*2}.should == (AnInt.to_f * 2)
+  end
+
+  it "should allow attribute access" do
+    subject.main.__name__.rubify.should == '__main__'
+  end
+
+  it "should allow global variable setting" do
+    subject.x = 2
+    subject.x.rubify.should == 2
+  end
+end

data/spec/pyobject_spec.rb

@@ -0,0 +1,246 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include TestConstants
+
+describe RubyPython::PyObject do
+  before do
+    @string = RubyPython.import('string').pObject
+    @urllib2 = RubyPython.import('urllib2').pObject
+    @builtin = RubyPython.import("__builtin__")
+    sys = RubyPython.import 'sys'
+    sys.path.append './spec/python_helpers/'
+    @objects = RubyPython.import('objects')
+  end
+
+  describe ".new" do
+    [
+      ["a string", AString],
+      ["an int", AnInt],
+      ["a float", AFloat],
+      ["an array", AnArray],
+      ["a symbol", ASym],
+      ["a hash", AHash]
+    ].each do |title, obj|
+      it "should wrap #{title}" do
+        lambda { described_class.new(obj) }.should_not raise_exception
+      end
+    end
+
+    [
+      "a string",
+      "an int",
+      "a list",
+      "a dict",
+      "a tuple"
+    ].each do |title|
+      it "should take #{title} from a Python pointer" do
+        lambda do
+          py_obj = @objects.__send__(title.gsub(' ','_')).pObject.pointer
+          described_class.new(py_obj)
+        end.should_not raise_exception
+      end
+    end
+  end #new
+
+  describe "#rubify" do
+    [
+      ["a string", AString],
+      ["an int", AnInt],
+      ["a float", AFloat],
+      ["an array", AnArray],
+      ["a symbol", ASym, ASym.to_s],
+      ["a hash", AHash, AConvertedHash]
+    ].each do |arr|
+      type, input, output = arr
+      output ||= input
+
+      it "should faithfully unwrap #{type}" do
+        described_class.new(input).rubify.should == output
+      end
+    end
+  end #rubify
+
+  describe "#hasAttr" do
+    it "should return true when object has the requested attribute" do
+      @string.hasAttr("ascii_letters").should be_true
+    end
+
+    it "should return false when object does not have the requested attribute" do
+      @string.hasAttr("nonExistentThing").should be_false
+    end
+  end
+
+  describe "#getAttr" do
+    it "should fetch requested object attribute" do 
+      ascii_letters = @string.getAttr "ascii_letters"
+      ascii_letters.rubify.should == "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    end
+
+    it "should return a PyObject instance" do
+      ascii_letters = @string.getAttr "ascii_letters"
+      ascii_letters.should be_kind_of(described_class)
+    end
+  end
+
+  describe "#setAttr" do 
+    it "should modify the specified attribute of the object" do
+      pyNewLetters = described_class.new "RbPy"
+      @string.setAttr "ascii_letters", pyNewLetters
+      @string.getAttr("ascii_letters").rubify.should == pyNewLetters.rubify
+    end
+
+    it "should create the requested attribute if it doesn't exist" do 
+      pyNewString = described_class.new "python"
+      @string.setAttr "ruby", pyNewString
+      @string.getAttr("ruby").rubify.should == pyNewString.rubify
+    end
+  end
+
+  describe "#cmp" do
+    before do
+      @less = described_class.new 5
+      @greater = described_class.new 10
+      @less_dup = described_class.new 5
+    end
+
+    it "should return 0 when objects are equal" do
+      @less.cmp(@less_dup).should == 0
+    end
+
+    it "should change sign under interchange of arguments" do 
+      @less.cmp(@greater).should == -@greater.cmp(@less)
+    end
+
+    it "should return -1 when first object is less than the second" do
+      @less.cmp(@greater).should == -1
+    end
+
+    it "should return 1 when first object is greater than the second" do
+      @greater.cmp(@less).should == 1
+    end
+  end
+
+  describe "#makeTuple" do
+    it "should wrap single arguments in a tuple" do
+      arg = described_class.new AString
+      described_class.makeTuple(arg).rubify.should == [AString]
+    end
+
+    it "should turn a Python list into a tuple" do
+      arg = @objects.a_list.pObject
+      converted = described_class.makeTuple(arg)
+      converted.rubify.should == AnArray
+    end
+
+    it "should return the given argument if it is a tuple" do
+      arg = @objects.a_tuple.pObject
+      converted = described_class.makeTuple(arg)
+      converted.pointer.address.should == arg.pointer.address
+    end
+  end
+
+  describe "#callObject" do
+    #Expand coverage types
+    it "should execute wrapped object with supplied arguments" do
+      arg = described_class.new AnInt
+      argt = described_class.buildArgTuple arg
+
+      builtin = @builtin.pObject
+      stringClass = builtin.getAttr "str"
+      stringClass.callObject(argt).rubify.should == AnInt.to_s
+    end
+  end
+
+  describe "#newList" do
+    it "should wrap supplied args in a Python list" do
+      args = AnArray.map do |obj|
+        described_class.new obj
+      end
+      described_class.newList(*args).rubify.should == AnArray
+    end
+  end
+
+  describe "#function_or_method?" do
+    it "should be true given a method" do
+      mockObjClass = @objects.RubyPythonMockObject.pObject
+      mockObjClass.getAttr('square_elements').should be_a_function_or_method
+    end
+
+    it "should be true given a function" do
+      @objects.pObject.getAttr('identity').should be_a_function_or_method
+    end
+
+    it "should return true given a builtin function" do
+      any = @builtin.pObject.getAttr('any')
+      any.should be_a_function_or_method
+    end
+
+    it "should return false given a class" do
+      @objects.RubyPythonMockObject.pObject.should_not be_a_function_or_method
+    end
+  end
+
+  describe "#class?" do
+    it "should return true if wrapped object is an old style class" do
+      @objects.RubyPythonMockObject.pObject.should be_a_class
+    end
+
+    it "should return true if wrapped object is an new style class" do
+      @objects.NewStyleClass.pObject.should be_a_class
+    end
+
+    it "should return true if wrapped object is a builtin class" do
+      strClass = @builtin.pObject.getAttr('str')
+      strClass.should be_a_class
+    end
+
+    it "should return false given an object instance" do
+      @objects.RubyPythonMockObject.new.pObject.should_not be_a_class
+    end
+  end
+
+  describe "#callable?" do
+    it "should be true given a method" do
+      mockObjClass = @objects.RubyPythonMockObject.pObject
+      mockObjClass.getAttr('square_elements').should be_callable
+    end
+
+    it "should be true given a function" do
+      @objects.pObject.getAttr('identity').should be_callable
+    end
+
+    it "should return true given a builtin function" do
+      any = @builtin.pObject.getAttr('any')
+      any.should be_callable
+    end
+
+    it "should return true given a class" do
+      @objects.RubyPythonMockObject.pObject.should be_callable
+    end
+
+    it "should return false given a non-callable instance" do
+      @objects.RubyPythonMockObject.new.pObject.should_not be_callable
+    end
+
+    specify { described_class.new(6).should_not be_callable }
+
+  end
+
+  describe ".convert" do
+    it "should not modify PyObjects passed to it" do
+      args = AnArray.map { |x| described_class.new(x) }
+      described_class.convert(*args).should == args
+    end
+
+    it "should pull PyObjects out of RubyPyProxy instances" do
+      args = @objects.an_array.to_a
+      described_class.convert(*args).should == args.map {|x| x.pObject}
+    end
+
+    it "should create new PyObject instances of simple Ruby types" do
+      described_class.convert(*AnArray).each do |x|
+        x.should be_a_kind_of described_class
+      end
+    end
+  end
+end