rubypython 0.2.11 → 0.3.0

data/lib/rubypython/version.rb

@@ -1,8 +1,9 @@
 module RubyPython
-  module VERSION #:nodoc:
+  #Just a simple way to keep track of the gem version.
+  module VERSION
     MAJOR = 0
-    MINOR = 2
-    TINY  = 11
+    MINOR = 3
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/spec/conversion_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include TestConstants
+describe RubyPython::Conversion do
+  include RubyPythonStartStop
+
+  subject { RubyPython::Conversion }
+
+  before do
+    sys = RubyPython.import 'sys'
+    sys.path.append './spec/python_helpers'
+    @objects = RubyPython.import 'objects'
+  end
+
+  context "when converting from Python to Ruby" do
+    [
+      ["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 "should convert #{py_type} to #{rb_type}" do
+        py_object_ptr = @objects.__send__(py_type.sub(' ', '_')).pObject.pointer
+        subject.ptorObject(py_object_ptr).should == output
+      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", "a symbol", ASym],
+      ["a list", "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, input|
+
+      it "should convert #{rb_type} to #{py_type}" do
+        py_object_ptr = subject.rtopObject(input)
+        output = @objects.__send__(rb_type.sub(' ', '_')).pObject.pointer
+        RubyPython::Python.PyObject_Compare(py_object_ptr, output).should == 0
+      end
+    end
+
+    it "should raise an exception when it cannot convert" do
+      lambda { subject.rtopObject(Class) }.should raise_exception(subject::UnsupportedConversion)
+    end
+
+  end
+
+end

data/spec/legacy_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include TestConstants
+
+describe 'RubyPython Legacy Mode Module' do
+  include RubyPythonStartStop
+
+  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
+  end
+
+end

data/spec/pymainclass_spec.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe RubyPython::PyMainClass do
+  include TestConstants
+  include RubyPythonStartStop
+
+  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,264 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe RubyPython::PyObject do
+  include RubyPythonStartStop
+  include TestConstants
+
+  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 for a method" do
+      mockObjClass = @objects.RubyPythonMockObject.pObject
+      mockObjClass.getAttr('square_elements').should be_a_function_or_method
+    end
+
+    it "should be true for a function" do
+      @objects.pObject.getAttr('identity').should be_a_function_or_method
+    end
+
+    xit "should return true for a builtin function" do
+      any = @builtin.pObject.getAttr('any')
+      any.should be_a_function_or_method
+    end
+
+    it "should return false for 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 for an object instance" do
+      @objects.RubyPythonMockObject.new.pObject.should_not be_a_class
+    end
+
+  end
+
+  describe "#callable?" do
+
+    it "should be true for a method" do
+      mockObjClass = @objects.RubyPythonMockObject.pObject
+      mockObjClass.getAttr('square_elements').should be_callable
+    end
+
+    it "should be true for a function" do
+      @objects.pObject.getAttr('identity').should be_callable
+    end
+
+    it "should return true for a builtin function" do
+      any = @builtin.pObject.getAttr('any')
+      any.should be_callable
+    end
+
+    it "should return true for a class" do
+      @objects.RubyPythonMockObject.pObject.should be_callable
+    end
+
+    it "should return false for 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
+

data/spec/python_helpers/objects.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+
+def identity(object):
+    return object
+
+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"
+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,43 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe RubyPython::PythonError do
+  include RubyPythonStartStop
+
+  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
+
+end
+