fastruby 0.0.7 → 0.0.8

data/lib/fastruby.rb

@@ -33,6 +33,6 @@ module FastRuby
   FastRuby.fastruby_script_path = File.expand_path(__FILE__)
   FastRuby.fastruby_load_path = File.expand_path(File.dirname(__FILE__))
 
-  VERSION = "0.0.7" unless defined? FastRuby::VERSION
+  VERSION = "0.0.8" unless defined? FastRuby::VERSION
 end
 

data/spec/block/break_spec.rb

@@ -187,4 +187,50 @@ describe FastRuby, "fastruby" do
   end
 
 
+
+  class ::V10
+
+    attr_accessor :a, :b, :c, :c_e, :b_e
+
+    fastruby "
+
+      def moo
+        yield(1)
+        @c = 32 # this should't be executed
+      ensure
+        @c_e = 4
+      end
+
+      def bar
+        yield(2)
+        @b = 16 # this should't be executed
+      ensure
+        @b_e = 4
+      end
+
+      def foo
+        ret = moo do |x|
+          bar do |y|
+            break 9
+          end
+          @a = 111
+          break 10
+        end
+        ret + 1
+      end
+
+    "
+  end
+
+  it "should break for nested blocks" do
+    v10 = ::V10.new
+    v10.foo.should be == 11
+    v10.a.should be == 111
+    v10.b.should be == nil
+    v10.c.should be == nil
+    v10.b_e.should be == 4
+    v10.c_e.should be == 4
+  end
+
+
 end

data/spec/block/callcc_spec.rb

@@ -0,0 +1,115 @@
+require "fastruby"
+
+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
+
+
+end

data/spec/block/lambda_spec.rb

@@ -0,0 +1,181 @@
+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)
+    fastruby "
+      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
+
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: fastruby
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 15
   prerelease: false
   segments: 
   - 0
   - 0
-  - 7
-  version: 0.0.7
+  - 8
+  version: 0.0.8
 platform: ruby
 authors: 
 - Dario Seminara
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-02 00:00:00 -03:00
+date: 2011-09-22 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -54,8 +54,8 @@ description:
 email: robertodarioseminara@gmail.com
 executables: []
 
-extensions: []
-
+extensions: 
+- ext/fastruby_base/extconf.rb
 extra_rdoc_files: 
 - README
 files: 
@@ -90,14 +90,18 @@ files:
 - spec/module_spec.rb
 - spec/exception_spec.rb
 - spec/base_spec.rb
+- spec/block/lambda_spec.rb
 - spec/block/next_spec.rb
 - spec/block/break_spec.rb
+- spec/block/callcc_spec.rb
 - spec/block_spec.rb
 - spec/flow_control/case_spec.rb
 - spec/sugar_spec.rb
 - spec/literal_spec.rb
 - spec/singleton_spec.rb
 - spec/integrity_spec.rb
+- ext/fastruby_base/fastruby_base.c
+- ext/fastruby_base/extconf.rb
 - LICENSE
 - AUTHORS
 - README