rubypython-raspi 0.1.0

data/spec/python_helpers/basics.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+
+def iterate_list():
+  for item in [ 1, 2, 3 ]:
+    yield item
+
+def identity(object):
+  return object
+
+def simple_callback(callback, value):
+  return callback(value)
+
+def simple_generator(callback):
+  output = []
+  for i in callback():
+    output.append(i)
+  return output
+
+def named_args(arg1, arg2):
+  return [arg1, arg2]
+
+def expects_tuple(tvalue):
+  return isinstance(tvalue, tuple)

data/spec/python_helpers/errors.py

@@ -0,0 +1,2 @@
+def nested_error():
+  return 1 / 0

data/spec/python_helpers/objects.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+def identity(object):
+  return object
+
+def apply_callback(callback, args):
+    return callback(*args)
+
+def named_args(arg1, arg2):
+  return [arg2*2, arg1*2]
+
+class RubyPythonMockObject:
+  STRING = "STRING"
+  STRING_LIST = ["STRING1", "STRING2"]
+  INT = 1
+  INT_LIST = [1,1]
+  FLOAT = 1.0
+  FLOAT_LIST = [1.0,1.0]
+
+  def square_elements(self, aList):
+    return [x**2 for x in aList]
+
+  def sum_elements(self, aList):
+    return sum(aList)
+
+  def __eq__(self, other):
+    if type(self) == type(other):
+      return True
+    else:
+      return False
+
+class NewStyleClass(object):
+  def a_method(self):
+    pass
+
+an_int = 1
+a_char = 'a'
+a_float = 1.0
+a_symbol = 'sym'
+a_string = "STRING"
+a_string_with_nulls = "STRING\0WITH\0NULLS"
+an_array = a_list = [an_int, a_char, a_float, a_string]
+a_hash = a_dict = { an_int: an_int, a_char: a_char, a_symbol: a_float,
+    a_string: a_string }
+true = python_True = True
+false = python_False = False
+nil = python_None = None
+a_tuple = tuple(a_list)

data/spec/pythonerror_spec.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe RubyPython::PythonError do
+  def cause_error
+    RubyPython::Python.PyImport_ImportModule("wat")
+  end
+
+  describe "#error?" do
+    it "should return false when no error has occured" do
+      described_class.error?.should be_false
+    end
+
+    it "should return true when an error has occured" do
+      cause_error
+      described_class.error?.should be_true
+    end
+  end
+
+  describe "#clear" do
+    it "should reset the Python error flag" do
+      cause_error
+      described_class.clear
+      described_class.error?.should be_false
+    end
+
+    it "should not barf when there is no error" do
+      lambda {described_class.clear}.should_not raise_exception
+    end
+  end
+
+  describe "#fetch" do
+    it "should make availible Python error type" do
+      cause_error
+      rbType, rbValue, rbTraceback = described_class.fetch
+      rbType.getAttr("__name__").rubify.should == "ImportError"
+    end
+  end
+
+  describe ".last_traceback" do
+    it "should make availble the Python traceback of the last error" do
+      traceback = RubyPython.import 'traceback'
+      errors = RubyPython.import 'errors'
+      begin
+        errors.nested_error
+      rescue RubyPython::PythonError => exc
+        tb = exc.traceback
+        list = traceback.format_tb(tb)
+        list.rubify[0].should =~ /1 \/ 0/
+      end
+    end
+  end
+end

data/spec/refcnt_spec.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+def get_refcnt(pobject)
+  raise 'Cannot work with a nil object' if pobject.nil?
+
+  if pobject.kind_of? RubyPython::RubyPyProxy
+    pobject = pobject.pObject.pointer
+  elsif pobject.kind_of? RubyPython::PyObject
+    pobject = pobject.pointer
+  end
+  struct = RubyPython::Python::PyObjectStruct.new pobject
+  struct[:ob_refcnt]
+end
+
+include TestConstants
+
+describe 'Reference Counting' do
+  before :all do
+    RubyPython.start
+    @sys = RubyPython.import 'sys'
+    @sys.path.append './spec/python_helpers'
+    @objects = RubyPython.import 'objects'
+  end
+
+  after :all do
+    RubyPython.stop
+  end
+
+  it "should be one given a new object" do
+    pyObj = @objects.RubyPythonMockObject.new
+    get_refcnt(pyObj).should == 1
+  end
+
+  it "should increase when a new reference is passed into Ruby" do
+    pyObj = @objects.RubyPythonMockObject
+    refcnt = get_refcnt(pyObj)
+    pyObj2 = @objects.RubyPythonMockObject
+    get_refcnt(pyObj).should == (refcnt + 1)
+  end
+
+  describe RubyPython::PyObject do
+    describe "#xIncref" do
+      it "should increase the reference count" do
+        pyObj = @objects.RubyPythonMockObject.new
+        refcnt = get_refcnt(pyObj)
+        pyObj.pObject.xIncref
+        get_refcnt(pyObj).should == refcnt + 1
+      end
+    end
+
+    describe "#xDecref" do
+      it "should decrease the reference count" do
+        pyObj = @objects.RubyPythonMockObject.new
+        pyObj.pObject.xIncref
+        refcnt = get_refcnt(pyObj)
+        pointer = pyObj.pObject.pointer
+        pyObj.pObject.xDecref
+        get_refcnt(pointer).should == refcnt - 1
+      end
+    end
+  end
+end

data/spec/rubypyclass_spec.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe RubyPython::RubyPyClass do
+  describe "#new" do
+    it "should return a RubyPyInstance" do
+      urllib2 = RubyPython.import 'urllib2'
+      urllib2.Request.new('google.com').should be_a(RubyPython::RubyPyInstance)
+    end
+  end
+end

data/spec/rubypyproxy_spec.rb

@@ -0,0 +1,261 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include TestConstants
+describe RubyPython::RubyPyProxy do
+  before do
+    @a = RubyPython::PyObject.new "a"
+    @b = RubyPython::PyObject.new "b"
+    @builtin = RubyPython.import("__builtin__").pObject
+    @string = RubyPython.import("string").pObject
+
+    @two = described_class.new 2
+    @six = described_class.new 6
+
+    @sys = RubyPython.import 'sys'
+    @sys.path.append './spec/python_helpers'
+    @objects = RubyPython.import 'objects'
+  end
+
+  describe "#new" do
+    it "should accept a PyObject instance" do
+      rbPyObject = RubyPython::PyObject.new AString
+      lambda {described_class.new rbPyObject}.should_not raise_exception
+    end
+
+    [
+      ["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 convert #{type} to wrapped pObject" do
+        described_class.new(input).pObject.rubify.should == output
+      end
+    end
+  end
+
+  describe "#rubify" 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 faithfully unwrap #{title}" do
+        pyObject = RubyPython::PyObject.new obj
+        proxy = described_class.new pyObject
+        proxy.rubify.should == pyObject.rubify
+      end
+    end
+  end
+
+  describe "#inspect" do
+    it "should return 'repr' of wrapped object" do
+      @six.inspect.should == '6'
+    end
+
+    it "should gracefully handle lack of defined __repr__" do
+      lambda { @objects.RubyPythonMockObject.inspect }.should_not raise_exception
+    end
+
+    it "always tries the 'repr' function if __repr__ produces an error" do
+      RubyPython::PyMain.list.inspect.should == run_python_command('print repr(list)').chomp
+    end
+  end
+
+  describe "#to_s" do
+    it "should return 'str' of wrapped object" do
+      @six.to_s.should == '6'
+    end
+
+    it "should gracefully handle lack of defined __str__" do
+      lambda { @objects.RubyPythonMockObject.to_s }.should_not raise_exception
+    end
+
+    it "always tries the 'str' function if __repr__ produces an error" do
+      RubyPython::PyMain.list.to_s.should == run_python_command('print str(list)').chomp
+    end
+  end
+
+  describe "#to_a" do
+    it "should convert a list to an array of its entries" do
+      list = @objects.a_list
+      list.to_a.should == AnArray.map { |x| described_class.new(x) }
+    end
+
+    it "should convert a tuple to an array of its entries" do
+      tuple = @objects.a_tuple
+      tuple.to_a.should == AnArray.map { |x| described_class.new(x) }
+    end
+
+    it "should convert a dict to an array of keys" do
+      dict = @objects.a_dict
+      dict.to_a.sort.should == AConvertedHash.keys.map {|x| described_class.new(x)}.sort
+    end
+  end
+
+  describe "#respond_to?" do
+    it "should return true given getters" do
+      @objects.should respond_to(:RubyPythonMockObject)
+    end
+
+    it "should return false given undefined methods" do
+      @objects.should_not respond_to(:undefined_attr)
+    end
+
+    it "should return true given any setter" do
+      @objects.should respond_to(:any_variable=)
+    end
+
+    it "should return true given methods on RubyPyProxy instance" do
+      @objects.should respond_to(:inspect)
+    end
+  end
+
+  describe "method delegation" do
+    it "should refer method calls to wrapped object" do
+      aProxy = described_class.new(@a)
+      bProxy = described_class.new(@b)
+      aProxy.__add__(bProxy).rubify.should == (@a.rubify + @b.rubify)
+    end
+
+    it "should raise NoMethodError when method is undefined" do
+      aProxy = described_class.new @a
+      lambda {aProxy.wat}.should raise_exception(NoMethodError)
+    end
+
+    it "raises NoMethodError when boolean method is undefined" do
+      aProxy = described_class.new @a
+      lambda { aProxy.wat? }.should raise_exception(NoMethodError)
+    end
+
+    it "should allow methods to be called with no arguments" do
+      builtinProxy = described_class.new @builtin
+      rbStrClass = builtinProxy.str
+      rbStrClass.new.rubify.should == String.new
+    end
+
+    it "should fetch attributes when method name is an attribute" do
+      pyLetters = @string.getAttr "ascii_letters"
+      stringProxy = described_class.new @string
+      stringProxy.ascii_letters.rubify.should == pyLetters.rubify
+    end
+
+    it "should set attribute if method call is a setter" do
+      stringProxy = described_class.new @string
+      stringProxy.letters = AString
+      stringProxy.letters.rubify.should == AString
+    end
+
+    it "should create nonexistent attirubte if method call is a setter" do
+      stringProxy = described_class.new @string
+      stringProxy.nonExistent = 1
+      stringProxy.nonExistent.rubify.should == 1
+    end
+
+    it "should return a class as a RubyPyClass" do
+      urllib2 = RubyPython.import('urllib2')
+      urllib2.Request.should be_a(RubyPython::RubyPyClass)
+    end
+
+    it "should pass named args via bang method" do
+      @objects.named_args!(:arg2 => 2, :arg1 => 1).rubify.should == [4,2]
+    end
+
+    it "should pass through keyword arguments via bang method" do
+      builtinProxy = described_class.new @builtin
+      builtinProxy.dict!({'dict'=>'val'}, :keyword=>true).rubify.should == {
+        'dict' => 'val',
+        'keyword' => true
+      }
+    end
+  end
+
+  describe "when used with an operator" do
+    [
+      '+', '-', '/', '*', '&', '^', '%', '**',
+      '>>', '<<', '<=>', '|'
+    ].each do |op|
+      it "should delegate #{op}" do
+        @six.__send__(op, @two).rubify.should == 6.__send__(op, 2)
+      end
+    end
+
+    [
+      '~', '-@', '+@'
+    ].each do |op|
+      it "should delegate #{op}" do
+        @six.__send__(op).rubify.should == 6.__send__(op)
+      end
+    end
+
+    ['==', '<', '>', '<=', '>='].each do |op|
+      it "should delegate #{op}" do
+        @six.__send__(op, @two).should == 6.__send__(op, 2)
+      end
+    end
+
+    describe "#equal?" do
+      it "be true given proxies representing the same object" do
+        obj1 = @objects.RubyPythonMockObject
+        obj2 = @objects.RubyPythonMockObject
+        obj1.should equal(obj2)
+      end
+
+      it "should be false given objects which are different" do
+        @two.should_not equal(@six)
+      end
+    end
+
+    it "should allow list indexing" do
+      array = described_class.new(AnArray)
+      array[1].rubify.should == AnArray[1]
+    end
+
+    it "should allow dict access" do
+      dict = described_class.new(AHash)
+      key = AConvertedHash.keys[0]
+      dict[key].rubify.should == AConvertedHash[key]
+    end
+
+    it "should allow list index assignment" do
+      array = described_class.new(AnArray)
+      val = AString*2
+      array[1] = val
+      array[1].rubify.should == val
+    end
+
+    it "should allow dict value modification" do
+      dict = described_class.new(AHash)
+      key = AConvertedHash.keys[0]
+      val = AString*2
+      dict[key] = val
+      dict[key].rubify.should == val
+    end
+
+    it "should allow creation of new dict key-val pair" do
+      dict = described_class.new(AHash)
+      key = AString*2
+      dict[key] = AString
+      dict[key].rubify.should == AString
+    end
+
+    it "should allow membership tests with include?" do
+      list = described_class.new(AnArray)
+      list.include?(AnArray[0]).should be_true
+    end
+  end
+
+  it "should delegate object equality" do
+    urllib_a = RubyPython.import('urllib')
+    urllib_b = RubyPython.import('urllib')
+    urllib_a.should == urllib_b
+  end
+end