fastruby 0.0.3 → 0.0.4

data/spec/exception_spec.rb

@@ -0,0 +1,440 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  it "should allow basic exception control" do
+   fastruby "
+      class ::L1
+        def foo
+          begin
+          rescue
+          end
+
+          0
+        end
+      end
+    "
+    ::L1.new.foo.should be == 0
+  end
+
+  it "should allow basic exception control and catch exception" do
+   fastruby "
+      class ::L2
+        def foo
+          begin
+            raise RuntimeError
+          rescue RuntimeError
+            return 1
+          end
+
+          0
+        end
+      end
+    "
+
+    lambda {
+      ::L2.new.foo.should be == 1
+    }.should_not raise_exception
+  end
+
+  it "should allow basic exception control and ensure" do
+   fastruby "
+      class ::L3
+        def foo
+
+          a = 0
+
+          begin
+            raise RuntimeError
+          rescue RuntimeError
+          ensure
+            a = 2
+          end
+
+          a
+        end
+      end
+    "
+
+    lambda {
+      ::L3.new.foo.should be == 2
+    }.should_not raise_exception
+  end
+
+  it "should allow basic exception control and ensure without rescue" do
+      class ::L4
+        attr_reader :a
+
+        fastruby "
+          def foo
+            begin
+              raise RuntimeError
+            ensure
+              @a = 2
+            end
+          end
+       "
+      end
+
+    l4 = ::L4.new
+
+    lambda {
+      l4.foo
+    }.should raise_exception(Exception)
+
+    l4.a.should be == 2
+  end
+
+  class BahException < Exception
+  end
+
+  def self.basic_unhandled_exception(*exception_names)
+
+    exception_names.each do |exception_name|
+      it "should raise basic exception #{exception_name}" do
+
+        random_name = "::L5_" + rand(10000).to_s
+
+        fastruby "
+          class #{random_name}
+              def foo
+                raise #{exception_name}
+              end
+          end
+           "
+
+        l = eval(random_name).new
+
+        lambda {
+          l.foo
+        }.should raise_exception(eval(exception_name))
+      end
+
+      it "should not raise basic exception #{exception_name} if rescued" do
+
+        random_name = "::L6_" + rand(10000).to_s
+
+        fastruby "
+          class #{random_name}
+              def foo
+                begin
+                raise #{exception_name}
+                rescue #{exception_name}
+                end
+              end
+          end
+           "
+
+        l = eval(random_name).new
+
+        lambda {
+          l.foo
+        }.should_not raise_exception
+      end
+
+      it "should raise basic exception #{exception_name} even if rescued when the rescue is for another exception" do
+
+        random_name = "::L7_" + rand(10000).to_s
+
+        fastruby "
+          class #{random_name}
+              def foo
+                begin
+                  raise #{exception_name}
+                rescue BahException
+                end
+              end
+          end
+           "
+
+        l = eval(random_name).new
+
+        lambda {
+          l.foo
+        }.should raise_exception(eval(exception_name))
+      end
+
+      it "should rescue basic exception #{exception_name} when raised from rubycode called from fastruby code" do
+
+        random_name = "::L8_" + rand(10000).to_s
+        random_name_2 = "::L8_" + rand(10000).to_s
+
+        eval "
+          class #{random_name_2}
+            def bar
+              raise #{exception_name}
+            end
+          end
+        "
+
+        fastruby "
+          class #{random_name}
+              def foo(x)
+                x.bar
+              end
+          end
+           "
+
+        l1 = eval(random_name_2).new
+        l2 = eval(random_name).new
+        lambda {
+          l2.foo(l1)
+        }.should raise_exception(eval(exception_name))
+      end
+
+      it "should rescue basic exception #{exception_name} from fastruby code when raised from rubycode" do
+
+        random_name = "::L9_" + rand(10000).to_s
+        random_name_2 = "::L9_" + rand(10000).to_s
+
+        eval "
+          class #{random_name_2}
+            def bar
+              raise #{exception_name}
+            end
+          end
+        "
+
+        fastruby "
+          class #{random_name}
+              def foo(x)
+                begin
+                  x.bar
+                rescue #{exception_name}
+                end
+              end
+          end
+           "
+
+        l1 = eval(random_name_2).new
+        l2 = eval(random_name).new
+        lambda {
+          l2.foo(l1)
+        }.should_not raise_exception
+      end
+
+
+
+
+      it "should raise basic exception #{exception_name} from singleton method" do
+
+        random_name = "::L5_" + rand(10000).to_s
+
+        fastruby "
+          class #{random_name}
+              def foo(x)
+                def x.foo
+                  raise #{exception_name}
+                end
+
+                x
+              end
+          end
+           "
+
+        l = eval(random_name).new
+
+        lambda {
+          l.foo("").foo
+        }.should raise_exception(eval(exception_name))
+      end
+
+      it "should not raise basic exception #{exception_name} if rescued from singleton method" do
+
+        random_name = "::L6_" + rand(10000).to_s
+
+        fastruby "
+          class #{random_name}
+              def foo(x)
+                def x.foo
+                  begin
+                    raise #{exception_name}
+                  rescue #{exception_name}
+                  end
+                end
+
+                x
+              end
+          end
+           "
+
+        l = eval(random_name).new
+
+        lambda {
+          l.foo("").foo
+        }.should_not raise_exception
+      end
+
+      it "should raise basic exception #{exception_name} even if rescued when the rescue is for another exception from singleton method" do
+
+        random_name = "::L7_" + rand(10000).to_s
+
+        fastruby "
+          class #{random_name}
+              def foo(x)
+                def x.foo
+                  begin
+                    raise #{exception_name}
+                  rescue BahException
+                  end
+                end
+
+                x
+              end
+          end
+           "
+
+        l = eval(random_name).new
+
+        lambda {
+          l.foo("").foo
+        }.should raise_exception(eval(exception_name))
+      end
+
+      it "should rescue basic exception #{exception_name} when raised from rubycode called from fastruby code from singleton method" do
+
+        random_name = "::L8_" + rand(10000).to_s
+        random_name_2 = "::L8_" + rand(10000).to_s
+
+        eval "
+          class #{random_name_2}
+            def bar
+              raise #{exception_name}
+            end
+          end
+        "
+
+        fastruby "
+          class #{random_name}
+              def foo(x)
+                def x.foo(y)
+                  y.bar
+                end
+
+                x
+              end
+          end
+           "
+
+        l1 = eval(random_name_2).new
+        l2 = eval(random_name).new
+        lambda {
+          l2.foo("").foo(l1)
+        }.should raise_exception(eval(exception_name))
+      end
+
+      it "should rescue basic exception #{exception_name} from fastruby code when raised from rubycode from singleton methods" do
+
+        random_name = "::L9_" + rand(10000).to_s
+        random_name_2 = "::L9_" + rand(10000).to_s
+
+        eval "
+          class #{random_name_2}
+            def bar
+              raise #{exception_name}
+            end
+          end
+        "
+
+        fastruby "
+          class #{random_name}
+              def foo(x)
+                def x.foo(y)
+                  begin
+                    y.bar
+                  rescue #{exception_name}
+                  end
+                end
+
+                x
+              end
+          end
+           "
+
+        l1 = eval(random_name_2).new
+        l2 = eval(random_name).new
+        lambda {
+          l2.foo("").foo(l1)
+        }.should_not raise_exception
+      end
+
+
+
+
+
+
+
+
+
+
+
+    end
+  end
+
+  basic_unhandled_exception("Exception")
+  basic_unhandled_exception("RuntimeError")
+  basic_unhandled_exception("StandardError")
+  basic_unhandled_exception("Errno::ENOENT")
+
+  it "should accept else with rescue" do
+
+    random_name = "::L11_" + rand(10000).to_s
+    fastruby "
+          class #{random_name}
+              def foo
+                begin
+                  raise Exception
+                rescue Exception
+                  return 111
+                else
+                  return 222
+                end
+              end
+          end
+           "
+
+    l = eval(random_name).new
+    l.foo.should be == 111
+   end
+
+  it "should accept else with rescue, when no exception is raised" do
+
+    random_name = "::L12_" + rand(10000).to_s
+    fastruby "
+          class #{random_name}
+              def foo
+                begin
+                rescue Exception
+                  return 111
+                else
+                  return 222
+                end
+              end
+          end
+           "
+
+    l = eval(random_name).new
+    l.foo.should be == 222
+   end
+
+  it "should accept else with rescue, when no exception is raised and begin has body" do
+
+    random_name = "::L13_" + rand(10000).to_s
+    fastruby "
+          class #{random_name}
+              def foo
+                begin
+                  a = 77
+                rescue Exception
+                  return 111
+                else
+                  return 222
+                end
+              end
+          end
+           "
+
+    l = eval(random_name).new
+    l.foo.should be == 222
+   end
+
+end

data/spec/module_spec.rb

@@ -0,0 +1,36 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  it "should alow definition of modules" do
+    fastruby "
+      module H1
+      end
+    "
+  end
+
+  it "should alow definition of modules with other code" do
+    fastruby '
+      print "defining module\n"
+
+      module H2
+      end
+    '
+  end
+
+  it "should alow definition of method in modules" do
+    fastruby '
+      module H2
+        def foo
+          77
+        end
+      end
+    '
+
+    class H2C
+     include H2
+    end
+
+    H2C.new.foo.should be == 77
+  end
+
+end

data/spec/return_spec.rb

@@ -0,0 +1,99 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  it "should allow basic return" do
+   fastruby "
+      class ::P1
+        def foo
+          return 1
+        end
+      end
+    "
+    ::P1.new.foo.should be == 1
+  end
+
+  it "should allow return from inside a block" do
+   fastruby "
+      class ::P2
+        def bar
+          yield
+        end
+
+        def foo
+          bar do
+            return 8
+          end
+
+          return 0
+        end
+      end
+    "
+    ::P2.new.foo.should be == 8
+  end
+
+  it "should allow basic return on singleton method" do
+   fastruby "
+      class ::P3
+      end
+
+      class ::P31
+        def bar(x)
+          def x.foo
+            return 1
+          end
+        end
+      end
+    "
+
+    p3 = ::P3.new
+    ::P31.new.bar(p3)
+    p3.foo.should be == 1
+  end
+
+  it "should allow return from inside a block on a singleton method" do
+   fastruby "
+      class ::P4
+        def bar
+          yield
+        end
+      end
+
+      class ::P41
+        def bar(x)
+          def x.foo
+            bar do
+              return 8
+            end
+            return 0
+          end
+        end
+      end
+    "
+    p4 = ::P4.new
+    ::P41.new.bar(p4)
+    p4.foo.should be == 8
+  end
+
+  it "should execute ensure when ensure impl has a return" do
+   fastruby "
+      class ::P5
+        def a
+          @a
+        end
+
+        def foo
+          begin
+            return 16
+          ensure
+            @a = 9
+          end
+
+          return 32
+        end
+      end
+    "
+    p5 = ::P5.new
+    p5.foo.should be == 16
+    p5.a.should be ==9
+  end
+end

data/spec/singleton_spec.rb

@@ -0,0 +1,76 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+
+  it "should allow defining class methods" do
+    fastruby '
+      class X
+        def self.foo
+          9
+        end
+      end
+    '
+    X.foo.should be == 9
+  end
+
+  it "should allow defining class methods with blocks" do
+    fastruby '
+      class R2
+        def self.bar
+          yield
+        end
+      end
+    '
+    R2.bar{67}.should be == 67
+  end
+
+  it "should call singleton methods from outside" do
+    class R3
+      def bar
+        12
+      end
+    end
+
+    fastruby '
+      class R4
+        def foo(x)
+          def x.bar
+            24
+          end
+        end
+      end
+    '
+
+    r3 = R3.new
+    R4.new.foo(r3)
+    r3.bar.should be == 24
+  end
+
+  it "should call singleton methods from inside" do
+    fastruby '
+      class R5
+        def bar
+          12
+        end
+      end
+      class R6
+        def foo(x)
+          def x.bar
+            24
+          end
+        end
+      end
+      class R7
+        def foo(x)
+          x.bar+1
+        end
+      end
+    '
+
+    r5 = R5.new
+    R7.new.foo(r5).should be == 13
+    R6.new.foo(r5)
+    R7.new.foo(r5).should be == 25
+  end
+
+end

data/spec/sugar_spec.rb

@@ -57,7 +57,7 @@ describe FastRuby, "fastruby" do
   it "should compile standalone code and execute it inmediatly" do
     $e4 = ::E4
     fastruby "
-      require 'fastruby'
+      print 'fastruby'
       $e4.new.foo
     "
   end
@@ -65,7 +65,7 @@ describe FastRuby, "fastruby" do
   it "should compile standalone code togheter with classes and execute it inmediatly" do
     $e4 = ::E4
     fastruby "
-      require 'fastruby'
+      print 'fastruby'
       $e4.new.foo
 
       class ::E5