fastruby 0.0.17 → 0.0.18

data/spec/ruby/block_spec.rb~

@@ -0,0 +1,520 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  class ::X6
+    fastruby "
+      def foo(ary)
+        ary.each do |a|
+        end
+        0
+      end
+    "
+  end
+
+  it "should compile blocks" do
+    ::X6.new.foo([1,2,3]).should be == 0
+  end
+
+  class ::X7
+    fastruby "
+      def foo(ary)
+        ary.map do |a|
+          0
+        end
+      end
+    "
+  end
+
+  it "should compile blocks with code inside" do
+    ::X7.new.foo([1,2,3]).should be == [0,0,0]
+  end
+
+  class ::X8
+    fastruby "
+      def foo(ary)
+        ary.map do |a|
+          a
+        end
+      end
+    "
+  end
+
+  it "should compile blocks with code inside refering block arguments" do
+    ::X8.new.foo([1,2,3]).should be == [1,2,3]
+  end
+
+  class ::X9
+    fastruby "
+      def foo(hash)
+        hash.map do |k,v|
+          k+v
+        end
+      end
+    "
+  end
+
+  it "should compile blocks with code inside refering multiple block arguments" do
+    ::X9.new.foo({1 => 2, 3 => 4}).sort.should be == [3,7]
+  end
+  
+  class ::X9_11
+    fastruby "
+      def foo
+        proc do |k,v|
+          k+v
+        end
+      end
+    "
+  end
+
+  it "should compile blocks with code inside refering multiple block arguments (proc)" do
+    pr = ::X9_11.new.foo
+    {1 => 2, 3 => 4}.map(&pr).sort.should be == [3,7]
+  end
+  
+
+  class ::Y10
+    def bar(arg1)
+      yield
+      arg1
+    end
+  end
+
+  class ::X10
+    fastruby "
+      def foo(obj, arg1)
+        obj.bar(arg1) do |a|
+        end
+      end
+    "
+  end
+
+  it "should compile iter calls with arguments" do
+    ::X10.new.foo(::Y10.new, 10).should be == 10
+  end
+
+  class ::Y11
+    def bar(arg1, arg2)
+      yield
+      arg1+arg2
+    end
+  end
+
+  class ::X11
+    fastruby "
+      def foo(obj, arg1, arg2)
+        obj.bar(arg1, arg2) do |a|
+        end
+      end
+    "
+  end
+
+  it "should compile iter calls with multiple arguments" do
+    ::X11.new.foo(::Y11.new, 10, 9).should be == 19
+  end
+
+  class ::X12
+    fastruby "
+      def foo(ary)
+        a = 1
+        ary.map do |x|
+          a
+        end
+      end
+    "
+  end
+
+  it "should allow accessing local variables from block" do
+    ::X12.new.foo([1,2,3,4]).should be == [1,1,1,1]
+  end
+
+  class ::X13
+    fastruby "
+      def foo(ary)
+        a = 1
+        ary.map do |x|
+          a+x
+        end
+      end
+    "
+  end
+
+  it "should allow accessing local variables and block parameters from block" do
+    ::X13.new.foo([1,2,3,4]).should be == [2,3,4,5]
+  end
+
+  class ::Y14
+    fastruby "
+      def bar
+        block_given?
+      end
+    "
+  end
+
+  class ::X14
+    fastruby "
+      def foo(y)
+        y.bar
+      end
+    "
+  end
+
+  it "method calls should not repass blocks" do
+    ::X14.new.foo(::Y14.new){ }.should be == false
+  end
+
+  class ::X15
+    fastruby "
+      def foo
+        bar
+      end
+    "
+
+    private
+      def bar
+        true
+      end
+  end
+
+  it "should allow calls to private methods" do
+    ::X15.new.foo.should be == true
+  end
+
+  class ::X16
+    fastruby "
+      def foo
+        bar do
+          12
+        end
+      end
+    "
+
+    def bar
+      yield
+    end
+  end
+
+  it "should allow calls with block to self methods" do
+    ::X16.new.foo.should be == 12
+  end
+
+  class ::X17
+    fastruby "
+      def foo(z)
+        i = 9
+        z.each do |x|
+          i = x
+          0
+        end
+        i
+      end
+    "
+  end
+
+  it "should allow assignment of locals from blocks" do
+    ::X17.new.foo([1,2,3]).should be == 3
+  end
+
+  class ::X18
+    fastruby "
+      def foo
+        yield
+      end
+    "
+  end
+
+  it "should allow block calls" do
+    ::X18.new.foo{ 9 }.should be == 9
+  end
+
+  class ::Y19
+    fastruby "
+      def bar
+        yield
+      end
+    "
+  end
+
+  class ::X19
+    fastruby "
+      def foo(y)
+        y.bar {
+          9
+        }
+      end
+    "
+  end
+
+  it "should execute block class between fastruby methods when no block is passed" do
+    ::X19.new.foo(::Y19.new).should be == 9
+  end
+
+  it "should execute block class between fastruby methods when block is passed" do
+    ::X19.new.foo(::Y19.new){}.should be == 9
+  end
+
+  class ::X20
+    fastruby "
+      def foo
+        yield(1)
+      end
+    "
+  end
+
+  it "should execute block from fastruby methods with one argument" do
+    ::X20.new.foo do |n1|
+      n1.should be == 1
+    end
+  end
+
+  class ::X21
+    fastruby "
+      def foo
+        yield(1,2)
+      end
+    "
+  end
+
+  it "should execute block from fastruby methods with two arguments" do
+    ::X21.new.foo do |n1,n2|
+      n1.should be == 1
+      n2.should be == 2
+    end
+  end
+
+  class ::Y22
+    fastruby "
+      def foo
+        yield
+      end
+    "
+
+    fastruby "
+      def bar(x)
+        i = 10
+        lvar_type(i,Fixnum)
+        x.foo do
+          i = i - 1
+        end
+        i
+      end
+    "
+  end
+
+  it "should execute block calls after lvar_type directive" do
+    y22 = ::Y22.new
+    y22.bar(y22).should be == 9
+  end
+
+  class ::Y23
+    def foo
+      yield
+    end
+
+    def foo2
+      77
+    end
+
+    fastruby "
+      def bar(x)
+        i = 0
+        x.foo do
+          i = foo2
+        end
+        i
+      end
+    "
+  end
+
+  it "should call self methods from inside a block" do
+    y23 = ::Y23.new
+    y23.bar(y23).should be == 77
+  end
+
+  class ::Y24
+    def foo
+      yield
+    end
+
+    fastruby "
+      def bar(x)
+        i = 0
+        x.foo do
+          i = block_given?
+        end
+        i
+      end
+    "
+  end
+
+  it "should call block_given? from inside a block when a block is not passed should return false" do
+    y24 = ::Y24.new
+    y24.bar(y24).should be == false
+  end
+
+  it "should call block_given? from inside a block when a block is not passed should return true" do
+    y24 = ::Y24.new
+    y24.bar(y24){}.should be == true
+  end
+
+  class ::Y25
+    def foo
+      yield
+    end
+
+    fastruby "
+      def bar(x)
+        i = 0
+        x.foo do
+          i = block_given? do
+          end
+        end
+        i
+      end
+    "
+  end
+
+  it "should call block_given? with block from inside a block when a block is not passed should return false " do
+    y25 = ::Y25.new
+    y25.bar(y25).should be == false
+  end
+
+  it "should call block_given? with block from inside a block when a block is not passed should return true" do
+    y25 = ::Y25.new
+    y25.bar(y25){}.should be == true
+  end
+
+  class ::Y26
+    def bar
+      yield
+    end
+
+    fastruby "
+      def foo
+        bar do
+          yield
+        end
+      end
+    "
+  end
+
+  it "should call yield from inside a block" do
+    y26 = ::Y26.new
+
+    block_num_calls = 0
+
+    y26.foo do
+      block_num_calls = block_num_calls + 1
+    end
+
+    block_num_calls.should be == 1
+  end
+
+  class ::Y27
+    fastruby "
+      def foo(x)
+        x
+      end
+    "
+  end
+
+  class ::Y28
+    fastruby "
+      def foo(y27, a)
+        y27.foo(a) do
+        end
+      end
+    "
+  end
+
+  it "should pass arguments when call with block" do
+    y28 = ::Y28.new
+    y28.foo(::Y27.new, 713).should be == 713
+  end
+
+  class ::Y29
+    fastruby "
+      def foo(ary)
+        cc = nil
+        ary.each do |x|
+          cc = x
+        end
+        cc
+      end
+    "
+  end
+
+  it "should assign variables from inside a block" do
+    ::Y29.new.foo([1,2,3]).should be == 3
+  end
+
+
+  class ::Y30
+    attr_accessor :a, :b, :c
+
+      def bar
+        begin
+          doo do
+            yield
+          end
+        ensure
+          @a = 15
+        end
+      end
+
+    fastruby "
+
+      def doo
+        begin
+          yield
+        ensure
+          @b = 16
+        end
+      end
+
+      def foo
+        cc = nil
+        bar do
+          return
+        end
+      ensure
+        @c = 17
+      end
+    "
+  end
+
+  it "should assign variables from inside a block" do
+    y = ::Y30.new
+    y.foo
+
+    y.a.should be == 15
+    y.b.should be == 16
+    y.c.should be == 17
+  end
+
+  class ::Y31
+    fastruby "
+
+      def bar
+        begin
+          yield
+        rescue
+        end
+      end
+
+      def foo
+        bar do
+          return 8
+        end
+        return 0
+      end
+    "
+  end
+
+  it "should return values from block through rescue" do
+    y = ::Y31.new
+    y.foo.should be == 8
+  end
+
+
+end

data/spec/ruby/defn/replacement_spec.rb~

@@ -0,0 +1,102 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  it "should allow replace methods after they are called and compiled at runtime" do
+    fastruby "
+      class JU1
+        def foo
+          6
+        end
+      end
+    "
+    
+    ::JU1.new.foo
+    
+    fastruby "
+      class JU1
+        def foo
+          9
+        end
+      end
+    "
+    
+    ::JU1.new.foo.should be == 9
+  end
+
+  it "should allow replace methods after they are called and compiled at runtime (through other method)" do
+    fastruby "
+      class JU2
+        def foo
+          6
+        end
+        
+        def bar
+          foo
+        end
+      end
+    "
+    
+    ::JU2.new.bar
+    
+    fastruby "
+      class JU2
+        def foo
+          9
+        end
+      end
+    "
+    
+    ::JU2.new.bar.should be == 9
+  end
+  
+  it "should allow replace methods using ruby after they are called and compiled at runtime (through other method)" do
+    fastruby "
+      class ::JU3
+        def foo
+          6
+        end
+        
+        def bar
+          foo
+        end
+      end
+    "
+    
+    ::JU3.new.bar
+    
+      class ::JU3
+        def foo
+          9
+        end
+      end
+    
+    ::JU3.new.bar.should be == 9
+  end  
+  
+  it "should allow replace methods using indentical code string" do
+    code = "
+      class ::JU4
+        def foo
+          6
+        end
+      end
+    "
+    
+    fastruby code
+    
+    ::JU4.new.foo.should be == 6
+    
+    fastruby "class ::JU4
+        def foo
+          9
+        end
+      end
+    "
+
+    ::JU4.new.foo.should be == 9
+
+    fastruby code
+
+    ::JU4.new.foo.should be == 6
+  end  
+end

data/spec/ruby/integrity_spec.rb~

@@ -0,0 +1,40 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+
+
+  class ::Y2
+    fastruby "
+      def foo(x)
+        i = 0
+        lvar_type(i,Fixnum)
+        i = x
+        0
+      end
+    ", :validate_lvar_types => true
+  end
+
+  it "should deny wrong type assignments at runtime when validate_lvar_types is true" do
+    lambda {
+    ::Y2.new.foo("test string")
+    }.should raise_error(FastRuby::TypeMismatchAssignmentException)
+  end
+
+  class ::Y3
+    fastruby "
+      def foo(x)
+        i = 0
+        lvar_type(i,Fixnum)
+        i = x
+        0
+      end
+    ", :validate_lvar_types => false
+  end
+
+  it "should NOT deny wrong type assignments at runtime when validate_lvar_types is false" do
+    lambda {
+    ::Y3.new.foo("test string")
+    }.should_not raise_error
+  end
+
+end

data/spec/ruby/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
+            240
+          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 == 241
+  end
+
+end