fastruby 0.0.16 → 0.0.17

data/spec/scope_mode/base_spec.rb

@@ -0,0 +1,55 @@
+require "fastruby"
+require "sexp"
+require "ruby_parser"
+require "fastruby/translator/scope_mode_helper"
+
+$parser = RubyParser.new
+
+describe FastRuby::ScopeModeHelper, "scope mode helper" do
+  it "method with only ONE call and read after call should return :dag scope mode" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c) 
+        a+b
+        c
+      end"
+    ).should be == :dag
+  end
+
+  it "method with only ONE call and self read after call should return :dag scope mode" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c) 
+        a+b
+        self
+      end"
+    ).should be == :dag
+  end
+
+  it "method with only ONE call and yield after call should return :dag scope mode" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c) 
+        a+b
+        yield
+      end"
+    ).should be == :dag
+  end
+
+  it "method with only ONE call and local call after call should return :dag scope mode" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c) 
+        a+b
+        foo
+      end"
+    ).should be == :dag
+  end
+
+  it "method call AFTER read inside while should return :dag scope" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b)
+        while (true) 
+          a=b
+          a+b
+        end
+      end"
+    ).should be == :dag
+  end
+end

data/spec/scope_mode/block_spec.rb

@@ -0,0 +1,105 @@
+require "fastruby"
+require "sexp"
+require "ruby_parser"
+require "fastruby/translator/scope_mode_helper"
+
+$parser = RubyParser.new
+
+describe FastRuby::ScopeModeHelper, "scope mode helper" do
+  it "iter call with block accessing locals should return dag" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a)
+        bar do
+          a
+        end
+      end"
+    ).should be == :dag
+  end
+  
+  it "iter call with block doing yield should return dag" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a)
+        bar do
+          yield
+        end
+      end"
+    ).should be == :dag
+  end  
+  
+  it "iter call with block with arguments should return dag" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a)
+        bar do |x|
+        end
+      end"
+    ).should be == :dag
+  end  
+
+  it "iter call with block writing local variable should return dag" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a)
+        bar do
+          a = 87
+        end
+      end"
+    ).should be == :dag
+  end
+
+  it "two iter call, one empty and the second with yield should return dag" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a)
+        bar do
+        end
+        
+        bar do
+          yield
+        end
+      end"
+    ).should be == :dag
+  end
+  
+  it "lambda with yield must return :dag" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "          def foo
+            lambda {
+              yield
+            }
+          end
+        "
+    ).should be == :dag
+  end  
+
+  it "method with return from inside block return :dag" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "    def bar
+            foo do
+              return 9
+            end
+          end
+        "
+    ).should be == :dag
+  end
+  
+  it "method with self from inside block return :dag" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "    def bar
+            foo do
+              self
+            end
+          end
+        "
+    ).should be == :dag
+  end
+  
+  it "local call from inside block should return :dag" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "    def bar
+            foo do
+              print
+            end
+          end
+        "
+    ).should be == :dag
+  end
+  
+end

data/spec/scope_mode/call_spec.rb

@@ -0,0 +1,24 @@
+require "fastruby"
+require "sexp"
+require "ruby_parser"
+require "fastruby/translator/scope_mode_helper"
+
+$parser = RubyParser.new
+
+describe FastRuby::ScopeModeHelper, "scope mode helper" do
+  it "method with two nested calls refering local vars should return :dag scope mode" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c) 
+        a+b+c
+      end"
+    ).should be == :dag
+  end
+
+  it "method with two nested calls refering local vars should return :dag scope mode" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c) 
+        a.foo(b){}.foo(c){}
+      end"
+    ).should be == :dag
+  end
+end

data/spec/scope_mode/exception_spec.rb

@@ -0,0 +1,34 @@
+require "fastruby"
+require "sexp"
+require "ruby_parser"
+require "fastruby/translator/scope_mode_helper"
+
+$parser = RubyParser.new
+
+describe FastRuby::ScopeModeHelper, "scope mode helper" do
+  it "method with read on begin body, call on rescue body and retry should return :dag scope mode" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c) 
+        begin
+          b
+        rescue
+          a.foo
+          retry
+        end
+      end"
+    ).should be == :dag
+  end
+  
+  it "method with read on begin body and retry should return :dag scope mode" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c) 
+        begin
+          nil.bar(b)
+        rescue
+          retry
+        end
+      end"
+    ).should be == :dag
+  end
+  
+end

data/spec/scope_mode/flow_spec.rb

@@ -0,0 +1,99 @@
+require "fastruby"
+require "sexp"
+require "ruby_parser"
+require "fastruby/translator/scope_mode_helper"
+
+$parser = RubyParser.new
+
+describe FastRuby::ScopeModeHelper, "scope mode helper" do
+  it "possible read on if after call should return :dag scope mode" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c)
+        if (a > 0)
+          c
+        end
+      end"
+    ).should be == :dag
+  end
+
+  it "possible read on case after call should return :dag scope mode" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c)
+        case (a > 0)
+          when 0
+            c
+        end
+      end"
+    ).should be == :dag
+  end
+
+  it "possible read on case (on enum) after call should return :dag scope mode" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c)
+        case (a > 0)
+          when c
+            0
+        end
+      end"
+    ).should be == :dag
+  end
+
+  it "for with local read and call should return :dag scope mode" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c)
+        for a in b
+          foo
+          c
+        end
+      end"
+    ).should be == :dag
+  end
+
+  it "empty for with local read should return :dag scope mode (because for is a iter call to each with one argument)" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c)
+        for a in b
+        end
+    end"
+    ).should be == :dag
+  end
+
+  it "case with a when should act as call and local read after case when should return :dag" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c)
+        case b
+          when c
+        end
+        a
+    end"
+    ).should be == :dag
+  end
+  
+  it "case with a when should act as call and local read after case when should return :dag" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c)
+        case b
+          when c
+            a
+          else
+            c
+        end
+    end"
+    ).should be == :dag
+  end  
+
+  it "case with two call (when) after read should return :dag scope" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c)
+        case a
+          when b # call to a.===(b)
+            43
+          when c # read of variable c
+            439
+        end
+      end"
+    ).should be == :dag
+  end
+
+
+end

data/spec/scope_mode/optimization_spec.rb

@@ -0,0 +1,130 @@
+require "fastruby"
+require "sexp"
+require "ruby_parser"
+require "fastruby/translator/scope_mode_helper"
+
+$parser = RubyParser.new
+
+describe FastRuby::ScopeModeHelper, "scope mode helper" do
+  it "empty method should return :linear scope mode" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(); end"
+    ).should be == :linear
+  end
+
+  it "method without calls should return :linear scope mode" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c) 
+        a
+      end"
+    ).should be == :linear
+  end
+
+  it "method with only ONE call should return :linear scope mode" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b) 
+        a+b
+      end"
+    ).should be == :linear
+  end
+
+  it "method call AFTER read should return :linear scope" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b) 
+        a=b
+        a+b
+      end"
+    ).should be == :linear
+  end
+  
+  it "empty if should return :linear scope mode" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c)
+        if (a)
+        end
+      end"
+    ).should be == :linear
+  end
+  it "iter call with empty block should return linear" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo
+        bar do
+        end
+      end"
+    ).should be == :linear
+  end
+  
+  it "return of simple call should return :linear" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b)
+      return a+b
+      end"
+    ).should be == :linear
+  end
+
+  it "call on if body and read on condition should return :linear (no read after call risk)" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b)
+        if a
+          b.foo
+        end
+      end"
+    ).should be == :linear
+  end  
+
+  it "call on if body and read on else body should return :linear (no read after call risk)" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b)
+        if true
+          b
+        else
+          b.foo
+        end
+      end"
+    ).should be == :linear
+  end  
+
+  it "method with read on begin body should return :linear scope mode" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c)
+        begin
+          nil.bar(b)
+        rescue
+        end
+      end"
+    ).should be == :linear
+  end
+
+  it "method with read on begin body and call on rescue body   should return :linear scope mode" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c)
+        begin
+          b
+        rescue
+          a.foo
+        end
+      end"
+    ).should be == :linear
+  end
+
+  it "case with call (when) after read should return :linear scope" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b,c)
+        case a
+          when b
+            43
+        end
+      end"
+    ).should be == :linear
+  end
+
+  it "read of variable AFTER write without call between them should return :linear scope" do
+    FastRuby::ScopeModeHelper.get_scope_mode(
+      $parser.parse "def foo(a,b) 
+        a+b
+        c=55
+        c
+      end"
+    ).should be == :linear
+  end
+end

data/spec/sexp2graph/base_spec.rb

@@ -0,0 +1,36 @@
+require "fastruby"
+require "fastruby/sexp_extension"
+require "sexp"
+require "ruby_parser"
+require "edges_helper"
+
+describe FastRuby::FastRubySexp, "FastRubySexp" do
+  include EdgesHelper
+
+  it "should have edges" do
+    FastRuby::FastRubySexp.parse("def foo; end").should respond_to(:edges)
+  end
+
+  assert_graph_defn("should have two edges for empty method","def foo; end",2) do |sexp, edges|
+    {sexp.find_tree(:block) => sexp.find_tree(:scope), sexp.find_tree(:nil) => sexp.find_tree(:block)}
+  end
+
+  assert_graph_defn("should have two edges for method returning literal 1","def foo; 0; end",2) do |sexp, edges|
+   {sexp.find_tree(:block) => sexp.find_tree(:scope), sexp.find_tree(:lit) => sexp.find_tree(:block)}
+  end
+
+  assert_graph_defn("should have three edges for method invoking method a and then literal 1","def foo; a; 1; end",3) do |sexp, edges|
+    {:a => sexp.find_tree(:lit), 
+        sexp.find_tree(:lit) => sexp.find_tree(:block), 
+        sexp.find_tree(:block) => sexp.find_tree(:scope) }
+  end
+
+  assert_graph("should have three edges for method invoking method with two arguments","x.foo(y,z)",3) do |sexp,edges|
+    {:y => :z, :x => :y, :z => sexp}  
+  end
+
+  assert_graph_defn("should connect edges on block","def foo(x); x.bar; x1.foo(y,z); end") do |sexp,edges|
+    block_tree = sexp.find_tree(:block)
+    { block_tree[1] => :x1}
+  end
+end

data/spec/sexp2graph/exception_spec.rb

@@ -0,0 +1,172 @@
+require "fastruby"
+require "fastruby/sexp_extension"
+require "sexp"
+require "ruby_parser"
+require "edges_helper"
+
+describe FastRuby::FastRubySexp, "FastRubySexp" do
+  include EdgesHelper
+
+  assert_graph_defn("should have edges for rescue","
+    def foo
+      begin
+          b
+        rescue
+          a
+          retry
+        end
+      end") do |sexp, edges|
+
+    {sexp.find_tree(:rescue)[1] => [:a,sexp.find_tree(:rescue)], 
+    :a => sexp.find_tree(:retry), 
+    sexp.find_tree(:retry) => :b
+    }
+  end
+
+  assert_graph_defn("should have edges for rescue","
+    def foo
+      begin
+          b
+        rescue
+        end
+      end") do |sexp, edges|
+
+    {sexp.find_tree(:rescue)[1] => [sexp.find_tree(:rescue)]}
+  end
+
+  assert_graph_defn("should enter the rescue in the body","
+    def foo
+      a
+      begin
+          b
+        rescue
+          c
+        end
+      end") do |sexp, edges|
+
+    {:a => :b,
+      sexp.find_tree(:rescue)[1] => sexp.find_tree(:rescue),
+      sexp.find_tree(:rescue) => sexp.find_tree(:block),
+      :b => :c,
+      :b => sexp.find_tree(:rescue)
+    }
+  end
+
+  assert_graph_defn("multiple calls on rescue may raise and go to rescue","
+    def foo
+      begin
+          a
+          b
+          c
+        rescue
+          d
+        end
+      end") do |sexp, edges|
+
+    {:a => :d, :b => :d, :c => [:d, sexp.find_tree(:rescue)[1] ], 
+      sexp.find_tree(:rescue)[1] => sexp.find_tree(:rescue) }
+  end
+
+  assert_graph_defn("multiple calls on ensure may raise and go to rescue","
+    def foo
+      begin
+          a
+          b
+          c
+       ensure
+          d
+       end
+      end") do |sexp, edges|
+
+    {:a => :d, :b => :d, :c => :d, sexp.find_tree(:ensure)[2] => sexp.find_tree(:ensure) }
+  end
+
+  assert_graph_defn("should enter the ensure in the body","
+    def foo
+      a
+      begin
+          b
+        ensure
+          c
+        end
+      end") do |sexp, edges|
+
+    {:a => :b,
+      :b => :c}
+  end
+
+
+  assert_graph_defn("should link declaration of exceptions on rescue","
+    def foo
+      begin
+          a
+        rescue b => c
+          d
+        end
+      end") do |sexp, edges|
+
+    {:a => :b,
+      :b => sexp.find_tree(:gvar), 
+      sexp.find_tree(:gvar) => sexp.find_tree(:lasgn),
+      sexp.find_tree(:lasgn) => :d     
+       }
+  end
+
+  assert_graph_defn("should link multiple declaration of exceptions on rescue","
+    def foo
+      begin
+          a
+        rescue b, d => e
+          f
+        end
+      end") do |sexp, edges|
+
+    array_tree = sexp.find_tree(:array)
+
+    {:a => :b,
+      :b => [sexp.find_tree(:gvar), :d], 
+      sexp.find_tree(:gvar) => sexp.find_tree(:lasgn),
+      sexp.find_tree(:lasgn) => :f,
+      :d => sexp.find_tree(:gvar)
+       }
+  end
+  
+  assert_graph_defn("should link trees on rescue without execution body","
+               def foo
+                  begin
+                  rescue Exception
+                    return a
+                  end
+                end") do |sexp,edges|  
+     {}
+    
+  end
+
+  assert_graph_defn("should link trees on rescue without execution body and else","
+               def foo
+                  begin
+                  rescue Exception
+                    return a
+                  else
+                    return b
+                  end
+                end") do |sexp,edges|  
+    {}
+    
+  end
+
+  assert_graph_defn("should link call previous to rescue when execution body of rescue is empty","
+               def foo
+                  z
+                  begin
+                  rescue Exception
+                    return a
+                  else
+                    return b
+                  end
+                end") do |sexp,edges|  
+    {:z => sexp.find_tree(:rescue) }
+    
+  end
+
+end