fastruby 0.0.21 → 0.0.22

data/spec/fastruby_only/base_spec.rb~

@@ -0,0 +1,74 @@
+require "fastruby"
+
+describe FastRuby, "FastRuby" do
+  it "should accept fastruby_only option" do
+    fastruby "
+    class FRONLY1
+      def foo
+        100
+      end
+    end
+    ", :fastruby_only => true
+  end
+
+  it "should accept fastruby_only option, methods defined with that option should not be callable from normal ruby" do
+    fastruby "
+    class FRONLY2
+      def fronly2_foo
+        100
+      end
+    end
+    ", :fastruby_only => true
+
+    lambda {
+      FRONLY2.new.fronly2_foo
+    }.should raise_error(NoMethodError)
+  end
+
+  it "should accept fastruby_only option, methods defined with that option should be callable from fastruby" do
+    fastruby "
+    class FRONLY3
+      def foo
+        100
+      end
+    end
+    ", :fastruby_only => true
+
+    fastruby "
+    class FRONLY3
+      def bar
+        foo
+      end
+    end
+    "
+    
+    FRONLY3.new.bar.should be == 100
+  end
+  
+  it "should accept fastruby_only option, and two versions of the same method" do
+    class FRONLY4
+      def foo
+        200
+      end
+    end
+
+    fastruby "
+    class FRONLY4
+      def foo
+        100
+      end
+    end
+    ", :fastruby_only => true
+
+    fastruby "
+    class FRONLY4
+      def bar
+        foo
+      end
+    end
+    "
+    
+    FRONLY4.new.bar.should be == 100
+    FRONLY4.new.foo.should be == 200
+  end
+end

data/spec/ruby/base_spec.rb~

@@ -20,302 +20,6 @@ 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(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 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)
@@ -350,45 +54,4 @@ describe FastRuby, "fastruby" do
     '
   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
+end

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

@@ -0,0 +1,21 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  class ::V1
+    fastruby "
+      def foo(ary)
+        sum = 0
+        ary.each do |a|
+          sum = sum + 1
+        end
+
+        sum
+      end
+    "
+  end
+
+  it "should execute basic test iterating an array" do
+    ::V1.new.foo([1,2,3]).should be == 6
+  end
+
+end

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

@@ -0,0 +1,236 @@
+require "fastruby"
+if RUBY_VERSION =~ /^1\.9/
+require "continuation"
+end
+
+describe FastRuby, "fastruby" do
+  class ::N1
+    fastruby "
+      def bar(cc)
+        cc.call(75)
+      end
+
+      def foo
+        callcc do |cc|
+          bar(cc)
+        end
+      end
+    "
+  end
+
+  it "should execute callcc on fastruby" do
+    ::N1.new.foo.should be == 75
+  end
+
+  class ::N2
+   def bar(cc)
+     cc.call(76)
+   end
+
+    fastruby "
+      def foo
+        callcc do |cc|
+          bar(cc)
+        end
+      end
+    "
+  end
+
+  it "should execute callcc from ruby" do
+    ::N2.new.foo.should be == 76
+  end
+
+  class ::N3
+    fastruby "
+      def foo(n_)
+        n = n_
+
+        val = 0
+        cc = nil
+
+        x = callcc{|c| cc = c; nil}
+
+        val = val + x if x
+        n = n - 1
+
+        cc.call(n) if n > 0
+
+        val
+      end
+    "
+  end
+
+  it "should execute callcc from ruby using local variables" do
+    ::N3.new.foo(4).should be == 6
+  end
+
+  class ::N4
+    fastruby "
+      def foo(n_)
+        $n = n_
+
+        $val = 0
+        c = 0
+
+
+        x = callcc{|c| $cc_n4 = c; nil}
+
+        $val = $val + x if x
+        $n = $n - 1
+
+        $cc_n4.call($n) if $n > 0
+
+        $val
+      end
+    "
+  end
+
+  it "should execute callcc from ruby using global variables" do
+    ::N4.new.foo(4).should be == 6
+  end
+
+  class ::N5
+    fastruby "
+      def foo(n_)
+        $n = n_
+
+        $val = 0
+        c = 0
+        u = nil
+
+        x = callcc{|c| $cc_n4 = c; u = 44; nil}
+
+        $val = $val + x if x
+        $n = $n - 1
+
+        $cc_n4.call($n) if $n > 0
+
+        u
+      end
+    "
+  end
+
+  it "should execute callcc loops and preserve local variables" do
+    ::N5.new.foo(4).should be == 44
+  end
+
+  class ::N6
+    fastruby "
+    
+      def bar
+        a = 5555
+        
+        callcc do |cc|
+          $cc = cc
+        end
+        
+        a
+      end
+      
+      def another_method(n)
+        a = 9999
+	    another_method(n-1) if n>0
+      end
+    
+      def foo
+        
+        $called = nil
+        
+        ret = bar
+        another_method(200)
+        
+        unless $called
+          $called = 1
+          $cc.call
+        end
+        
+        ret
+      end
+    "
+  end
+
+  it "should execute callcc loops and preserve local variables when another method is called after callcc" do
+    ::N6.new.foo.should be == 5555
+  end
+  
+  
+  it "shouldn't raise LocalJumpError from proc being called on callcc de-initialized stack" do
+    
+fastruby <<ENDSTR
+
+class ::N7
+  def foo
+    val = nil
+    
+    pr = Proc.new do 
+      return val
+    end
+    
+    val = callcc do |cc|
+      $cc = cc
+    end
+    
+    pr.call
+  end
+
+  def bar
+    ret = foo
+
+    if ret.instance_of? Continuation
+      ret.call(4)
+    else
+      $cc.call(ret-1) if ret > 0
+    end
+  end
+end
+
+ENDSTR
+    
+    
+    n7 = ::N7.new
+    lambda {
+      n7.bar
+    }.should_not raise_error(LocalJumpError)
+  end
+  
+  it "should raise LocalJumpError from proc defined on abandoned stack after Continuation#call" do
+  
+fastruby <<ENDSTR
+class ::N8
+  def bar
+    ret = callcc do |cc|
+      $cc_n8 = cc
+    end
+    
+    if ret == 9
+      $pr_n8.call
+    end
+    
+    ret
+  end
+  
+  def foo3
+    $cc_n8.call(9)
+  end
+  
+  def foo2
+    $pr_n8 = Proc.new do
+      return
+    end
+    
+    foo3
+  end
+  
+  def foo
+    return if bar == 9
+    foo2
+  end
+end
+ENDSTR
+
+    n8 = ::N8.new
+    lambda {
+      n8.foo
+    }.should raise_error(LocalJumpError)
+  end  
+end