fastruby 0.0.1

data/spec/block_spec.rb

@@ -0,0 +1,418 @@
+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 ::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
+end

data/spec/control_spec.rb

@@ -0,0 +1,71 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+
+  class ::C1
+    fastruby '
+      def foo
+        ret = 0
+        if true
+          ret = 32
+        end
+        ret
+      end
+    '
+  end
+
+  it "should execute if when the condition is true" do
+    ::C1.new.foo.should be == 32
+  end
+
+  class ::C2
+    fastruby '
+      def foo
+        ret = 0
+        if false
+          ret = 32
+        end
+        ret
+      end
+    '
+  end
+
+  it "should execute if when the condition is false" do
+    ::C2.new.foo.should be == 0
+  end
+
+  class ::C3
+    fastruby '
+      def foo
+        ret = 0
+        if false
+          ret = 32
+        else
+          ret = 16
+        end
+        ret
+      end
+    '
+  end
+
+  it "should execute if with else when the condition is false" do
+    ::C3.new.foo.should be == 16
+  end
+
+  class ::C4
+    fastruby '
+      def foo
+        ret = 0
+        unless false
+          ret = 32
+        end
+        ret
+      end
+    '
+  end
+
+  it "should execute unless when the condition is false" do
+    # tip: unless is only a reverse if
+    ::C4.new.foo.should be == 32
+  end
+end

data/spec/expression_spec.rb

@@ -0,0 +1,59 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  class ::D5
+    fastruby '
+      def foo(a,b)
+        a == b
+      end
+    '
+  end
+
+  it "should execute unless when the condition is false" do
+    ::D5.new.foo(1,1).should be == true
+    ::D5.new.foo(1,2).should be == false
+  end
+
+  class ::D6
+    fastruby '
+      def foo(a,b)
+        a and b
+      end
+    '
+  end
+
+  it "should execute unless when the condition is false" do
+    ::D6.new.foo(false,false).should be == false
+    ::D6.new.foo(true,false).should be == false
+    ::D6.new.foo(false,true).should be == false
+    ::D6.new.foo(true,true).should be == true
+  end
+
+  class ::D7
+    fastruby '
+      def foo(a,b)
+        a or b
+      end
+    '
+  end
+
+  it "should execute unless when the condition is false" do
+    ::D7.new.foo(false,false).should be == false
+    ::D7.new.foo(true,false).should be == true
+    ::D7.new.foo(false,true).should be == true
+    ::D7.new.foo(true,true).should be == true
+  end
+
+  class ::D8
+    fastruby '
+      def foo(a)
+       not a
+      end
+    '
+  end
+
+  it "should execute unless when the condition is false" do
+    ::D8.new.foo(false).should be == true
+    ::D8.new.foo(true).should be == false
+  end
+end

data/spec/integrity_spec.rb

@@ -0,0 +1,74 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+
+  class ::Y1
+    fastruby "
+      def foo(x)
+        i = 0
+        lvar_type(i,Fixnum)
+        i = x
+        0
+      end
+    "
+  end
+
+  it "should deny wrong type assignments at runtime by default" do
+    lambda {
+    ::Y1.new.foo("test string")
+    }.should raise_error(FastRuby::TypeMismatchAssignmentException)
+  end
+
+  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
+
+
+  class ::Y4
+    fastruby "
+      def foo(x)
+		x+1
+      end
+    "
+  end
+
+  it "should builds be re-entrants, multiple calls should not produce any error if the first call works" do
+    lambda {
+	::Y4.build([Y4,Fixnum],:foo)
+	::Y4.build([Y4,Fixnum],:foo)
+	::Y4.build([Y4,Fixnum],:foo)
+	
+	::Y4.new.foo(1).should be ==2
+    }.should_not raise_error
+  end
+end

data/spec/literal_spec.rb

@@ -0,0 +1,95 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  class ::Z1
+    fastruby "
+      def foo
+        0
+      end
+    "
+  end
+
+  it "should compile Fixnum literals" do
+    ::Z1.new.foo.should be == 0
+  end
+
+  class ::Z2
+    fastruby "
+      def foo
+        'test string'
+      end
+    "
+  end
+
+  it "should compile string literals" do
+    ::Z2.new.foo.should be == 'test string'
+  end
+
+  class ::Z3
+    fastruby "
+      def foo
+        [1,2,3]
+      end
+    "
+  end
+
+  it "should compile array literals" do
+    ::Z3.new.foo.should be == [1,2,3]
+  end
+
+  class ::Z4
+    fastruby "
+      def foo
+        /aaa/
+      end
+    "
+  end
+
+  it "should compile regexp literals" do
+    ::Z4.new.foo.should be == /aaa/
+  end
+
+  class ::Z5
+    fastruby "
+      def foo
+        { 1 => 2, 3 => 4}
+      end
+    "
+  end
+
+  it "should compile hash literals" do
+    ::Z5.new.foo.should be == { 1 => 2, 3 => 4}
+  end
+
+  class ::Z6
+    fastruby "
+      def foo
+        nil
+      end
+    "
+  end
+
+  it "should compile nil" do
+    ::Z6.new.foo.should be == nil
+  end
+
+  class ::Z7
+    fastruby "
+      def foo(a,b)
+        (a..b)
+      end
+    "
+  end
+
+  def self.test_range(a,b)
+    it "should compile range (#{a}..#{b})" do
+      ::Z7.new.foo(a,b).should be == (a..b)
+    end
+  end
+
+  test_range 0,0
+  test_range 3,54
+  test_range 'a', 'f'
+  test_range 0.54,066
+
+end