fastruby 0.0.19 → 0.0.20

data/spec/fastruby_only/base_spec.rb

@@ -0,0 +1,74 @@
+require "fastruby"
+
+describe FastRuby, "FastRuby" do
+  it "should accept fastruby_only option" do
+    fastruby "
+    class FRONLY1
+      def foo
+        100
+      end
+    end
+    ", :fastruby_only => true
+  end
+
+  it "should accept fastruby_only option, methods defined with that option should not be callable from normal ruby" do
+    fastruby "
+    class FRONLY2
+      def fronly2_foo
+        100
+      end
+    end
+    ", :fastruby_only => true
+
+    lambda {
+      FRONLY2.new.fronly2_foo
+    }.should raise_error(NoMethodError)
+  end
+
+  it "should accept fastruby_only option, methods defined with that option should be callable from fastruby" do
+    fastruby "
+    class FRONLY3
+      def foo
+        100
+      end
+    end
+    ", :fastruby_only => true
+
+    fastruby "
+    class FRONLY3
+      def bar
+        foo
+      end
+    end
+    "
+    
+    FRONLY3.new.bar.should be == 100
+  end
+  
+  it "should accept fastruby_only option, and two versions of the same method" do
+    class FRONLY4
+      def foo
+        200
+      end
+    end
+
+    fastruby "
+    class FRONLY4
+      def foo
+        100
+      end
+    end
+    ", :fastruby_only => true
+
+    fastruby "
+    class FRONLY4
+      def bar
+        foo
+      end
+    end
+    "
+    
+    FRONLY4.new.bar.should be == 100
+    FRONLY4.new.foo.should be == 200
+  end
+end

data/spec/graph/base_spec.rb

@@ -1,8 +1,9 @@
 require "fastruby"
 require "fastruby/sexp_extension"
 
+include FastRuby  
+
 describe FastRuby::Graph, "fastruby sexp graph" do
-  include FastRuby  
   it "should allow create empty graph" do
     graph = Graph.new 
   end

data/spec/graph/base_spec.rb~

@@ -0,0 +1,35 @@
+require "fastruby"
+require "fastruby/sexp_extension"
+
+describe FastRuby::Graph, "fastruby sexp graph" do
+  include FastRuby  
+  it "should allow create empty graph" do
+    graph = Graph.new 
+  end
+
+  it "should allow add edges with add_edge" do
+    graph = Graph.new
+    graph.add_edge(1,2)
+    graph.edges.count.should be == 1
+    graph.edges.first.should be == [1,2]
+  end
+
+  it "should return 0 edges for an empty graph" do
+    graph = Graph.new 
+    graph.edges.count.should be == 0
+  end
+
+  it "should allow creation of graphs using hashes" do
+    graph = Graph.new 3 => [4]
+    graph.edges.count.should be == 1    
+    graph.edges.should include([3,4])
+  end
+
+  it "should allow creation of graphs using hashes with multiple nodes" do
+    graph = Graph.new 3 => [4,5,6]
+    graph.edges.count.should be == 3
+    graph.edges.should include([3,4])
+    graph.edges.should include([3,5])
+    graph.edges.should include([3,6])
+  end
+end

data/spec/graph/path_spec.rb

@@ -1,9 +1,9 @@
 require "fastruby"
 require "fastruby/sexp_extension"
 
-describe FastRuby::Graph, "fastruby sexp graph" do
-  include FastRuby  
+include FastRuby  
 
+describe FastRuby::Graph, "fastruby sexp graph" do
   def self.assert_graph_paths(origin, paths, graph_hash) 
     it "should read paths #{paths.inspect} for graph #{graph_hash} from #{origin}" do
       graph = Graph.new graph_hash

data/spec/graph/path_spec.rb~

@@ -0,0 +1,48 @@
+require "fastruby"
+require "fastruby/sexp_extension"
+
+describe FastRuby::Graph, "fastruby sexp graph" do
+  include FastRuby  
+
+  def self.assert_graph_paths(origin, paths, graph_hash) 
+    it "should read paths #{paths.inspect} for graph #{graph_hash} from #{origin}" do
+      graph = Graph.new graph_hash
+            
+      array = []
+      graph.each_path_from(origin) do |path|
+        path_array = []
+        path.each(&path_array.method(:<<))
+        array << path_array
+      end
+
+      paths.each do |path|
+        array.should include(path)
+      end
+      array.count.should be == paths.count
+ 
+      array
+    end
+  end
+
+  assert_graph_paths(1, [[1,2]], 1 => [2] )
+  assert_graph_paths(1, [[1,3]], 1 => [3] )
+  assert_graph_paths(1, [[1,4]], 1 => [4] )
+  assert_graph_paths(3, [[3,2]], 3 => [2] )
+  assert_graph_paths(4, [[4,2]], 4 => [2] )
+
+  assert_graph_paths(1, [[1,2],[1,3]], 1 => [2,3] )
+
+  assert_graph_paths(1, [[1,2,3]], 1 => [2], 2 => [3] )
+  assert_graph_paths(1, [[1,2,3],[1,2,4]], 1 => [2], 2 => [3,4] )
+  assert_graph_paths(1, [[1,2,4],[1,3,4]], 1 => [2,3], 2 => [4],3 => [4] )
+  assert_graph_paths(1, [[1,2,3,4,5],[1,2,3,5],[1,3,5],[1,3,4,5]], 1 => [2,3], 2 => [3],3 => [4,5],4 => [5] )
+
+  # cyclic paths
+  assert_graph_paths(1, [[1]], 1 => [1] )
+  assert_graph_paths(1, [[1,2,1]], 1 => [2], 2 => [1] )
+  assert_graph_paths(2, [[2,1,2]], 1 => [2], 2 => [1] )
+
+  # cyclyc paths with repeated vertexes
+  assert_graph_paths(1, [[1,2,4],[1,2,3,2,4]], 1 => [2], 2 => [3,4], 3 => [2])
+end
+

data/spec/graph/vertex_spec.rb

@@ -1,8 +1,9 @@
 require "fastruby"
 require "fastruby/sexp_extension"
 
+include FastRuby  
+
 describe FastRuby::Graph, "fastruby sexp graph" do
-  include FastRuby  
   it "should allow read vertex from empty graph" do
     graph = Graph.new 
     graph.vertexes

data/spec/graph/vertex_spec.rb~

@@ -0,0 +1,58 @@
+require "fastruby"
+require "fastruby/sexp_extension"
+
+describe FastRuby::Graph, "fastruby sexp graph" do
+  include FastRuby  
+  it "should allow read vertex from empty graph" do
+    graph = Graph.new 
+    graph.vertexes
+  end
+
+  it "should allow read vertex from empty graph and it must be empty" do
+    graph = Graph.new 
+    graph.vertexes.count.should be == 0
+  end
+
+  it "should allow read vertex from graph with one vertex" do
+    graph = Graph.new 1 => [1]
+    graph.vertexes.count.should be == 1
+    graph.vertexes.should include(1)
+  end
+
+  it "should allow read vertex from graph with two vertexes" do
+    graph = Graph.new 1 => [1,2]
+    graph.vertexes.count.should be == 2
+    graph.vertexes.should include(1)
+    graph.vertexes.should include(2)
+  end
+
+  it "should allow allow read vertex outputs" do
+    graph = Graph.new 1 => [1]
+
+    array = []
+    graph.each_vertex_output(1, &array.method(:<<))
+
+    array.should include(1)
+  end
+
+  it "should allow read vertex outputs" do
+    graph = Graph.new 1 => [2]
+
+    array = []
+    graph.each_vertex_output(1, &array.method(:<<))
+
+    array.should include(2)
+
+    array = []
+    graph.each_vertex_output(2, &array.method(:<<))
+
+    array.should be == []
+  end
+
+
+  it "should allow read vertex outputs with no blocks (returning sets)" do
+    graph = Graph.new 1 => [2]
+    graph.each_vertex_output(1).should include(2)
+    graph.each_vertex_output(2).count.should == 0
+  end
+end

data/spec/reductor/base_spec.rb

@@ -1,5 +1,5 @@
 require "fastruby"
-require "fastruby/reductor/reductor"
+require "fastruby/builder/reductor"
 require "fastruby/sexp_extension"
 require "ruby_parser"
 

data/spec/ruby/block/lambda_spec.rb~

@@ -1,6 +1,62 @@
 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
@@ -35,4 +91,111 @@ describe FastRuby, "fastruby" do
     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)
+    eval "
+      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
+
+
+    class ::LL8
+
+      alias alt_lambda lambda
+
+      fastruby "
+      def foo
+        lambda_obj = alt_lambda {
+          return 9
+        }
+
+        lambda_obj.call
+      end
+      "
+    end
+
+    it "should close lambda with return when renamed with alias" do
+       ll8 = ::LL8.new
+       ll8.foo.should be == 9
+    end
+
 end

data/spec/ruby/block/proc_as_block_spec.rb~

@@ -1,6 +1,27 @@
 require "fastruby"
 
 describe FastRuby, "fastruby" do
+
+
+  class ::VY6
+    fastruby "
+      def foo(a)
+        yield(a)
+      end
+    
+      def bar(x,block)
+        foo(x,&block)
+      end
+    "
+  end
+
+  it "should allow single arguments with block" do
+    vy6 = ::VY6.new
+
+    block = proc do |a| "44" end
+    vy6.bar(44,block).should be == "44"
+  end
+
   class ::VY7
       def foo(a)
         yield(a)
@@ -9,7 +30,7 @@ describe FastRuby, "fastruby" do
     
     fastruby "
       def bar(x,block)
-        foo(x){|a|'44'} #,&block)
+        foo(x,&block)
       end
     "
   end
@@ -20,4 +41,51 @@ describe FastRuby, "fastruby" do
     block = proc do |a| "44" end
     vy7.bar(44,block).should be == "44"
   end
+
+
+  class ::VY8
+      def foo(a)
+        yield(a)
+      end
+      
+    
+    fastruby "
+      def bar(x,block)
+        foo(x,&block)
+      end
+    "
+  end
+
+  it "should allow single arguments with block calling ruby methods and read block arguments" do
+    vy8 = ::VY8.new
+
+    block = proc do |a| a.to_s end
+    vy8.bar(555,block).should be == "555"
+  end
+
+  it "should allow single arguments with block calling ruby methods and read array block arguments" do
+    vy8 = ::VY8.new
+
+    block = proc do |a| a end
+    vy8.bar([555],block).should be == [555]
+  end
+
+  class ::VY9
+      def foo(a)
+        yield(a)
+      end
+    
+    fastruby "
+      def bar(vy9,x,block)
+        vy9.first.foo(x,&block)
+      end
+    "
+  end
+
+  it "should allow block as proc with no type inference of the receiver" do
+    vy9 = ::VY9.new
+
+    block = proc do |a| a end
+    vy9.bar([vy9],555,block).should be == 555
+  end
 end