fastruby 0.0.17 → 0.0.18

data/spec/ruby/base_spec.rb~

@@ -0,0 +1,394 @@
+require "fastruby"
+
+class X
+  fastruby "
+    def foo(a,b)
+      return a+b
+    end
+  "
+  def foo2(a,b)
+    return a+b
+  end
+
+  fastruby "
+    def foo3(a)
+      9
+    end
+    "
+
+end
+
+describe FastRuby, "fastruby" do
+
+  def self.test_foo(a,b)
+    it "should execute a method with + of #{a.class}" do
+      x = X.new
+      x.foo(a,b).should be == x.foo2(a,b)
+    end
+  end
+
+  test_foo(5353531,6000000)
+  test_foo("5353531","6000000")
+  test_foo([1,2,3], [5,6])
+
+  it "methods without return should return last expression result" do
+    X.new.foo3(0).should be == 9
+  end
+
+  class ::X2
+   fastruby "
+    def foo
+      0
+    end
+   "
+  end
+
+  it "methods without arguments should be called" do
+    ::X2.new.foo.should be == 0
+  end
+
+  class ::X3
+    fastruby "
+      def foo
+       while false
+       end
+       0
+      end
+    "
+  end
+
+  it "should execute methods with while" do
+    ::X3.new.foo.should be == 0
+  end
+
+  class ::X4
+    fastruby "
+      def foo
+       i = 10
+       i
+      end
+    "
+  end
+
+  it "should assign and read locals" do
+    ::X4.new.foo.should be == 10
+  end
+
+  class ::X5
+    fastruby "
+      def foo
+       i = 10
+       while i > 0
+        i = i - 1
+       end
+       0
+      end
+    "
+  end
+
+  it "should run 10 iterations" do
+    ::X5.new.foo.should be == 0
+  end
+
+  class ::A1
+    fastruby "
+      def foo
+        i = 9
+      end
+    "
+  end
+
+  it "should compile a methd with lvar assignment as the last instruction" do
+    ::A1.new.foo.should be == 9
+  end
+
+  class ::B2
+    fastruby "
+      def foo
+        self
+      end
+    "
+  end
+  class ::A2
+    fastruby "
+      def foo(b2)
+        b2.foo
+      end
+    "
+  end
+
+  it "should read self of nested frame" do
+    b2 = ::B2.new
+    ::A2.new.foo(b2).should be == b2
+  end
+
+  class ::A3
+    fastruby "
+      def foo(x)
+        x.to_i(16)
+      end
+    "
+  end
+
+  it "should execute native methods with variable arguments" do
+    ::A3.new.foo("40").should be == 64
+  end
+
+  class ::A4
+    fastruby "
+      def foo(x)
+        x.to_i
+      end
+    "
+  end
+
+  it "should execute native methods with variable arguments (and no arguments is passed)" do
+    ::A4.new.foo("40").should be == 40
+  end
+
+  class ::A5
+    fastruby "
+      def bar(x)
+        x
+      end
+     "
+
+    fastruby "
+      def foo(x,a,b)
+        bar(
+          if (x)
+            a
+          else
+            b
+          end
+        )
+      end
+    "
+  end
+
+  it "should compile inline if when passed as argument in a method call" do
+    ::A5.new.foo(true,11,12).should be == 11
+  end
+
+  class ::A6
+    fastruby "
+      def bar(x)
+        x
+      end
+     "
+
+    fastruby "
+      def foo(x,a,b)
+        bar(
+          if (x)
+            x.to_s
+            a
+          else
+            x.to_s
+            b
+          end
+        )
+      end
+    "
+  end
+
+  it "should compile inline if when passed as argument in a method call. if as many lines" do
+    ::A6.new.foo(true,11,12).should be == 11
+  end
+
+  class ::A7
+    fastruby "
+      def bar(x)
+        x
+      end
+     "
+
+    fastruby "
+      def foo(xz,a,b)
+        bar(
+          if (xz)
+            xz.to_s
+            a
+          else
+            xz.to_s
+            b
+          end
+        ) {
+        }
+      end
+    "
+  end
+
+  it "should compile inline if when passed as argument in a method call with block. if has many lines" do
+    ::A7.new.foo(true,11,12).should be == 11
+  end
+
+  class ::A8
+    fastruby "
+      def foo(x)
+          a = if (x)
+                x.to_s
+                1
+              else
+                x.to_s
+                2
+              end
+
+          a
+      end
+    "
+  end
+
+  it "should compile inline if at lvar assignment" do
+    ::A8.new.foo(true).should be == 1
+    ::A8.new.foo(false).should be == 2
+  end
+
+  class ::A9
+    fastruby "
+      def foo(x)
+            if (x)
+              x.to_s
+              1
+            else
+              x.to_s
+              2
+            end
+      end
+    "
+  end
+
+  it "should compile inline if at end of method" do
+    ::A9.new.foo(true).should be == 1
+    ::A9.new.foo(false).should be == 2
+  end
+
+  class ::A10
+    fastruby '
+      def foo
+        a = nil
+        inline_c "plocals->a = INT2FIX(143)"
+        a
+      end
+    '
+  end
+
+  it "should compile inline C when using inline_c directive" do
+    ::A10.new.foo().should be == 143;
+  end
+
+  class ::A11
+    fastruby '
+      def foo(b)
+        a = b
+        inline_c " if (plocals->a == Qnil) {
+            plocals->a = INT2FIX(43);
+          } else {
+            plocals->a = INT2FIX(44);
+          }
+          "
+        a
+      end
+    '
+  end
+
+  it "should compile inline C if when using inline_c directive" do
+    ::A11.new.foo(nil).should be == 43;
+    ::A11.new.foo(true).should be == 44;
+  end
+
+  class ::A12
+    fastruby '
+      def foo(b)
+        a = b
+        x = inline_c(" if (plocals->a == Qnil) {
+            plocals->a = INT2FIX(43);
+          } else {
+            plocals->a = INT2FIX(44);
+          }
+          ")
+        a
+      end
+    '
+  end
+
+  it "should compile inline C when it is used as rvalue and return nil when no return is specified" do
+    ::A12.new.foo(55).should be == 44;
+  end
+
+  class ::A13
+    fastruby '
+      def foo(b)
+        a = b
+        x = inline_c(" if (plocals->a == Qnil) {
+            plocals->a = INT2FIX(43);
+          } else {
+            plocals->a = INT2FIX(44);
+          }
+          ")
+        x
+      end
+    '
+  end
+
+  it "should compile inline C when it is used as rvalue and assign nil if not return is specified" do
+    ::A13.new.foo(55).should be == nil;
+  end
+
+  class ::A14
+    fastruby '
+      def foo(b)
+        a = b
+        x = inline_c(" if (plocals->a == Qnil) {
+            return INT2FIX(43);
+          } else {
+            return INT2FIX(44);
+          }
+          ")
+        x
+      end
+    '
+  end
+
+  it "should compile inline C when it is used as rvalue and assign the returned expression" do
+    ::A14.new.foo(55).should be == 44;
+  end
+
+  it "should do nothing when execute fastruby with nothing" do
+    lambda {
+    fastruby ""
+    }.should_not raise_error
+  end
+
+  it "should allow basic inheritance" do
+    fastruby "
+      class J56
+        def foo
+          43
+        end
+      end
+
+      class ::K56 < J56
+      end
+    "
+
+    ::K56.new.foo.should be == 43
+  end
+
+  it "should allow call to self method" do
+    fastruby "
+      class J57
+        def foo
+          43
+        end
+        def bar
+          foo
+        end
+      end
+    "
+
+    ::J57.new.foo.should be == 43
+    ::J57.new.bar.should be == 43
+  end
+
+end

data/spec/ruby/block/arguments_spec.rb~

@@ -0,0 +1,214 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  class ::VO1
+    fastruby "
+      def foo(x)
+        yield(*x)
+      end
+    "
+  end
+
+  it "should allow pass splat arguments to yield" do
+    ::VO1.new.foo([1,2,3]) do |x,y,z|
+      x.should be == 1
+      y.should be == 2
+      z.should be == 3
+    end
+  end
+  
+  class ::VO2
+    fastruby "
+      def foo(x)
+        yield(1,*x)
+      end
+    "
+  end
+
+  it "should allow pass normal and splat arguments to yield" do
+    ::VO2.new.foo([2,3,4]) do |a,x,y,z|
+      a.should be == 1
+      x.should be == 2
+      y.should be == 3
+      z.should be == 4
+    end
+  end
+  
+  class ::VO3
+    fastruby "
+      def foo(x)
+        yield(1,2,*x)
+      end
+    "
+  end
+
+  it "should allow pass two normal args and one splat argument to yield" do
+    ::VO3.new.foo([3,4,5]) do |a,b,x,y,z|
+      a.should be == 1
+      b.should be == 2
+      x.should be == 3
+      y.should be == 4
+      z.should be == 5
+    end
+  end
+  
+  it "should take only the object argument when trying to splat a non-array" do
+    ::VO1.new.foo("non-array") do |x|
+      x.should be == "non-array"
+    end
+  end
+  
+  class ::VO4
+    
+    def bar
+      yield(1,2,3,4)
+    end
+    
+    fastruby "
+      def foo
+        bar do |*y|
+          y
+        end
+      end
+    "
+  end
+  
+  it "should allow masgn arguments on block passes" do
+    ::VO4.new.foo.should be == [1,2,3,4]
+  end
+  
+
+  class ::VO5
+    
+    fastruby "
+      def bar
+        yield(1,2,3,4)
+      end
+    
+      def foo
+        bar do |*y|
+          y
+        end
+      end
+    "
+  end
+  
+  it "should allow masgn arguments on block passes (fastruby call)" do
+    ::VO5.new.foo.should be == [1,2,3,4]
+  end
+  
+  
+  class ::VO6
+    
+    def bar
+      yield(1,2,3,4)
+    end
+    
+    fastruby "
+      def foo
+        bar do |a,b,*y|
+          y
+        end
+      end
+    "
+  end
+  
+  it "should allow normal arguments with masgn arguments on block passes" do
+    ::VO6.new.foo.should be == [3,4]
+  end
+  
+  class ::VO7
+    fastruby "
+      def foo
+        pr = proc do |*x|
+          x
+        end
+        pr.call(32)
+      end
+    "
+  end
+
+  it "should allow splat arguments on proc block" do
+    ::VO7.new.foo.should be == [32]
+  end
+
+  class ::VO8
+    fastruby "
+      def foo
+        pr = proc do |*x|
+          x
+        end
+        pr.call(32,33,34)
+      end
+    "
+  end
+
+  it "should allow multiple splat arguments on proc block" do
+    ::VO8.new.foo.should be == [32,33,34]
+  end
+  
+  class ::VO9
+      def bar
+        yield(32)
+      end
+    fastruby "
+      def foo
+        bar do |x|
+          x
+        end
+      end
+    "
+  end
+
+  it "should read single argument on block" do
+    ::VO9.new.foo.should be == 32
+  end
+
+
+  class ::VO10
+    fastruby "
+      def foo
+        pr = proc do |*x|
+          x
+        end
+        pr.call([32])
+      end
+    "
+  end
+
+  it "should allow splat arguments on proc block when the argument is an array" do
+    ::VO10.new.foo.should be == [[32]]
+  end
+  
+
+  class ::VO11
+    fastruby "
+      def foo
+        pr = proc do |*x|
+          x
+        end
+        pr.call([])
+      end
+    "
+  end
+
+  it "should allow splat arguments on proc block when the argument is an array empty" do
+    ::VO11.new.foo.should be == [[]]
+  end
+
+  class ::VO12
+    fastruby "
+      def foo
+        pr = proc do |*x|
+          x
+        end
+        pr.call()
+      end
+    "
+  end
+
+  it "should allow splat arguments on proc block when no arguments are passed" do
+    ::VO12.new.foo.should be == []
+  end
+  
+end

data/spec/ruby/block/proc_as_block_spec.rb~

@@ -0,0 +1,23 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  class ::VY7
+      def foo(a)
+        yield(a)
+      end
+      
+    
+    fastruby "
+      def bar(x,block)
+        foo(x){|a|'44'} #,&block)
+      end
+    "
+  end
+
+  it "should allow single arguments with block calling ruby methods" do
+    vy7 = ::VY7.new
+
+    block = proc do |a| "44" end
+    vy7.bar(44,block).should be == "44"
+  end
+end

data/spec/ruby/block/retry_spec.rb~

@@ -0,0 +1,43 @@
+require "fastruby"
+
+describe FastRuby, "fastruby retry statement" do
+  class ::WG2
+    attr_reader :a, :b
+
+    def initialize
+      @a = 0
+      @b = 0
+    end
+
+    fastruby "
+      def bar(x)
+        @a = @a + 1
+
+        yield(1)
+        yield(2)
+        yield(3)
+      ensure
+        @b = @b + 1
+      end
+
+      def foo
+        sum = 0
+        bar(0) do |x|
+#          sum = sum + 1
+#          retry if x == 3 and sum < 30
+        end
+
+        sum
+      end
+    "
+  end
+
+  it "should work with a method more arguments than zero" do
+    wg2 = ::WG2.new
+    wg2.foo.should be == 30
+    wg2.a.should be == 10
+    wg2.b.should be == 10
+  end
+
+
+end