lokeshh_rubypython 0.7

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/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,202 @@
+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 "#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 "#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
+
+end

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,98 @@
+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
+  RubyPython::Macros.Py_REFCNT pobject
+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
+
+  describe RubyPython::Conversion do
+    describe ".rtopArrayToList" do
+      it "should incref any wrapped objects in the array" do
+        int = RubyPython::PyObject.new AnInt
+        refcnt = get_refcnt(int)
+        arr = [int]
+        pyArr = subject.rtopArrayToList(arr)
+        get_refcnt(int).should == refcnt + 1
+      end
+
+    end
+
+    describe ".rtopObject" do
+      [
+        ["string", AString],
+        ["float", AFloat],
+        ["array", AnArray],
+        #["symbol", ASym],
+        ["hash", AHash]
+      ].each do |arr|
+        type, input = arr
+
+        it "should return a refcnt of 1 for newly created #{type}" do
+          pyObj = subject.rtopObject(input)
+          get_refcnt(pyObj).should == 1
+        end
+
+        it "should increment the refcnt each time the same #{type} is passed in" do
+          pyObj = RubyPython::PyObject.new subject.rtopObject(input)
+          refcnt = get_refcnt(pyObj)
+          pyObj2 = subject.rtopObject(pyObj)
+          get_refcnt(pyObj2).should == refcnt + 1
+        end
+      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