fastruby 0.0.21 → 0.0.22

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

@@ -1,190 +1,13 @@
 require "fastruby"
 
 describe FastRuby, "fastruby" do
-  class ::LL1
-    fastruby "
-      def foo
-        a = 16
-        lambda {|x|
-          a+x
-        }
-      end
-    "
-  end
-
-  it "lambda must be able to access local variables" do
-    ::LL1.new.foo.call(16).should be == 32
-  end
-
-    fastruby "
-  class ::LL2
-      def foo
-        a = 16
-        lambda {|x|
-          a+x
-        }
-      end
-
-      def bar
-      end
-  end
-    "
-
-  it "lambda must be able to access local variables, after another unrelated method is called" do
-    ll2 = ::LL2.new
-    lambda_object = ll2.foo
-    ::LL2.new.bar
-    lambda_object.call(16).should be == 32
-  end
-
-    fastruby "
-  class ::LL3
-      def foo(a)
-        lambda {|x|
-          a+x
-        }
-      end
-
-      def bar(y)
-        lambda_object = foo(16)
-        foo(160)
-        lambda_object.call(y)
-      end
-  end
-    "
-
-  it "lambda must be able to access local variables, after another unrelated method is called (from fastruby)" do
-    ll3 = ::LL3.new
-    ll3.bar(1).should be == 17
-  end
-
-    fastruby "
-  class ::LL4
-      def foo
-        lambda {|x|
-          yield(x)
-        }
-      end
-
-      def bar
-        z = 99
-        foo do |x|
-          x+z
-        end
-      end
-
-      def xt
-        lambda_object = bar()
-        lambda_object.call(1)
-      end
-  end
-    "
-
-  it "lambda must be able to access local variables of parent scopes through yield (from fastruby)" do
-    ll4 = ::LL4.new
-    ll4.xt.should be == 100
-  end
-
-  it "lambda must be able to access local variables of parent scopes through yield" do
-    ll4 = ::LL4.new
-    lambda_object = ll4.bar
-    lambda_object.call(1).should be == 100
-  end
-
-  it "lambda must be able to access local variables of parent scopes through yield on ruby" do
-    ll4 = ::LL4.new
-
-    a = 99
-
-    lambda_object = ll4.foo do |x|
-      x+a
-    end
-    lambda_object.call(1).should be == 100
-  end
-
-  def self.next_sentence(sname)
-    fastruby "
-      class ::LL5#{sname}
-          def foo
-            lambda {
-              #{sname} 100
-            }
-          end
-      end
-    "
-
-    it "lambda #{sname}'s must act as block next" do
-      eval("LL5"+sname).new.foo.call.should be == 100
-    end
-  end
-
-  next_sentence("next")
-  next_sentence("break")
-  next_sentence("return")
-
-  def self.illegal_jump(sname)
-    eval "
-      class ::LL6#{sname}
-          def foo
-            lambda {
-              yield
-            }
-          end
-
-          def bar
-            foo do
-              #{sname} 9
-            end
-          end
-      end
-    "
-
-    it "#{sname} inside block should raise LocalJumpError" do
-       ll6 = eval("::LL6"+sname).new
-       lambda {
-         ll6.bar.call
-         }.should raise_error(LocalJumpError)
-    end
-  end
-
-#  illegal_jump("return")
-  illegal_jump("break")
-
-
-    fastruby "
-    class ::LL7
-
-      def bar(l)
-        l.call
-        yield
-      end
-
-      def foo
-        lambda_obj = lambda {
-        }
-
-        bar(lambda_obj) do
-          break 0
-        end
-      end
-    end
-    "
-
-    it "should break from block after calling lambda" do
-       ll7 = ::LL7.new
-       lambda {
-         ll7.foo.should be == 0
-         }.should_not raise_error
-    end
-
-
     class ::LL8
 
       alias alt_lambda lambda
 
       fastruby "
       def foo
-        lambda_obj = alt_lambda {
+        lambda_obj = lambda {
           return 9
         }
 

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

@@ -0,0 +1,85 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  class ::W1
+    fastruby "
+      def foo(ary)
+        sum = 0
+        ary.each do |a|
+          next if a == 2
+          sum = sum + a
+        end
+
+        sum
+      end
+    "
+  end
+
+  it "should execute basic test iterating an array" do
+    ::W1.new.foo([1,2,3]).should be == 4
+  end
+
+  class ::W2
+    fastruby "
+      def foo
+        next
+      end
+    "
+  end
+
+  it "should raise LocalJumpError with illegal next" do
+    lambda {
+    ::W2.new.foo
+    }.should raise_error(LocalJumpError)
+  end
+
+  class ::W3
+    attr_reader :x, :y
+
+    fastruby "
+      def bar
+        @x = yield(1)
+        @y = yield(2)
+      end
+
+      def foo
+        bar do |a|
+          next 16 if a == 1
+          next 32 if a == 2
+        end
+      end
+    "
+  end
+
+  it "should return values on block using next" do
+     x = ::W3.new
+     x.foo
+     x.x.should be == 16
+     x.y.should be == 32
+  end
+
+  class ::W4
+    attr_reader :x, :y
+
+    fastruby "
+      def foo(ary)
+        sum = 0
+        ary.each do |a|
+          begin
+            next if a == 2
+          ensure
+            sum = sum + a
+          end
+        end
+
+        sum
+      end
+    "
+  end
+
+  it "should execute ensure when using next" do
+     x = ::W4.new
+     x.foo([1,2,3]).should be == 6
+  end
+
+end

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

@@ -0,0 +1,22 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+
+  eval "
+  class LN9
+    def foo
+      f = Proc.new { return 'return from foo from inside proc' }
+      f.call
+      return 'return from foo'
+    end
+   end
+  "
+
+    it "should return from proc using Proc.new" do
+       ll9 = ::LN9.new
+       lambda {
+         ll9.foo.should be == 'return from foo from inside proc'
+         }.should_not raise_error
+    end
+
+end

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

@@ -0,0 +1,133 @@
+require "fastruby"
+
+describe FastRuby, "fastruby redo statement" do
+  class ::WB1
+    fastruby "
+      def bar
+        yield
+      end
+
+      def foo
+        sum = 0
+        bar do
+          sum = sum + 1
+          redo if sum<10
+        end
+
+        sum
+      end
+    "
+  end
+
+  it "should execute basic redo" do
+    wb1 = ::WB1.new
+    wb1.foo.should be == 10
+  end
+
+  class ::WB2
+      def bar
+        yield
+      end
+
+    fastruby "
+
+      def foo
+        sum = 0
+        bar do
+          sum = sum + 1
+          redo if sum<10
+        end
+
+        sum
+      end
+    "
+  end
+
+  it "should execute basic redo (called method is in ruby)" do
+    wb2 = ::WB2.new
+    wb2.foo.should be == 10
+  end
+
+  class ::WB3
+    fastruby "
+      def foo
+        redo
+      end
+    "
+  end
+
+  it "should raise LocalJumpError when invoked illegal redo" do
+    wb3 = ::WB3.new
+
+    lambda {
+      wb3.foo
+    }.should raise_error(LocalJumpError)
+  end
+  
+  class ::WB4
+    fastruby <<EOS
+    def foo
+      yield(5)
+    end
+  
+    def bar
+      a = true
+      foo do |n|
+        if a
+          a = false
+          n = 555
+          redo
+        end
+        n
+      end
+    end
+EOS
+  end
+
+  it "should NOT restore variable arguments on block when calling redo" do
+    wb4 = ::WB4.new
+    wb4.bar.should be == 555
+  end
+
+  class ::WB5
+    fastruby <<EOS
+    def bar
+      a = true
+      proc do |n|
+        if a
+          a = false
+          n = 555
+          
+        end
+        n
+      end
+    end
+EOS
+  end
+
+  it "should NOT restore variable arguments on block when calling redo (lambda block)" do
+    wb5 = ::WB5.new
+    wb5.bar.call(5).should be == 555
+  end
+  
+  class ::WB6
+    fastruby <<EOS
+    def bar
+      a = true
+      Proc.new do |n|
+        if a
+          a = false
+          n = 555
+          redo
+        end
+        n
+      end
+    end
+EOS
+  end
+
+  it "should NOT restore variable arguments on block when calling redo (Proc.new block)" do
+    wb6 = ::WB6.new
+    wb6.bar.call(5).should be == 555
+  end  
+end

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

@@ -0,0 +1,135 @@
+require "fastruby"
+
+describe FastRuby, "fastruby retry statement" do
+  class ::WG1
+    attr_reader :a, :b
+
+    def initialize
+      @a = 0
+      @b = 0
+    end
+
+    fastruby "
+      def bar
+        @a = @a + 1
+
+        yield(1)
+        yield(2)
+        yield(3)
+      ensure
+        @b = @b + 1
+      end
+
+      def foo
+        sum = 0
+        bar do |x|
+          sum = sum + 1
+          retry if x == 3 and sum < 30
+        end
+
+        sum
+      end
+    "
+  end
+
+  it "should execute basic retry" do
+    wg1 = ::WG1.new
+    wg1.foo.should be == 30
+    wg1.a.should be == 10
+    wg1.b.should be == 10
+  end
+
+
+  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
+
+  class ::WG3
+    fastruby "
+      def foo
+        sum = 0
+        begin
+          sum = sum + 1
+          raise RuntimeError
+        rescue RuntimeError
+          retry if sum < 10
+        end
+
+        sum
+      end
+    "
+  end
+
+  it "should work with rescue" do
+    ::WG3.new.foo.should be == 10
+  end
+
+  class ::WG4
+    fastruby "
+      def foo
+        retry
+      end
+    "
+  end
+
+  it "should raise LocalJumpError when there is no block" do
+    lambda {
+    ::WG4.new.foo
+    }.should raise_error(LocalJumpError)
+  end
+
+  class ::WG5
+    attr_accessor :a
+
+    fastruby "
+      def foo
+          retry
+      ensure
+        @a = 1
+      end
+    "
+  end
+
+  it "should trap exceptions generated by illegal retry's" do
+    wg5 = ::WG5.new
+    lambda {
+    wg5.foo
+    }.should raise_error(LocalJumpError)
+
+    wg5.a.should be == 1
+  end
+end