fastruby 0.0.16 → 0.0.17

data/lib/fastruby.rb

@@ -32,5 +32,5 @@ class Object
 end
 
 module FastRuby
-  VERSION = "0.0.16" unless defined? FastRuby::VERSION
+  VERSION = "0.0.17" unless defined? FastRuby::VERSION
 end

data/lib/fastruby.rb~

@@ -0,0 +1,36 @@
+=begin
+
+This file is part of the fastruby project, http://github.com/tario/fastruby
+
+Copyright (c) 2011 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+fastruby is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+fastruby is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
+
+=end
+require "fastruby/exceptions"
+require "fastruby/object"
+require "fastruby/exceptions"
+require "fastruby/custom_require"
+require "fastruby/set_tree"
+require "base64"
+
+class Object
+  def self.decode64(value)
+    Base64.decode64(value)
+  end
+end
+
+module FastRuby
+  VERSION = "0.0.16" unless defined? FastRuby::VERSION
+end

data/spec/edges_helper.rb

@@ -0,0 +1,91 @@
+module EdgesHelper
+
+  class GraphEdges < Array
+    def initialize(sexp); @sexp = sexp; end
+
+    def to_sexp(obj, &blk)
+      if obj.instance_of? Symbol
+        blk.call @sexp.find_tree{|st| st.node_type == :call and st[2] == obj}
+      elsif obj.instance_of? Array
+        obj.each do |element|
+          to_sexp(element,&blk)
+        end
+      else
+        blk.call obj
+      end
+    end
+
+    def tr_edges(hash)
+      hash.each do |k,v|
+        to_sexp(k) do |a|
+          to_sexp(v) do |b|
+            yield(a,b)
+          end
+        end
+      end
+    end
+  end
+
+  def get_defn_edges(code)
+    sexp = FastRuby::FastRubySexp.parse(code)
+
+    edges = GraphEdges.new(sexp)
+    sexp[3].edges.each do |tree_orig, tree_dest|
+      edges << [tree_orig, tree_dest]
+    end
+
+    yield(sexp, edges)
+  end  
+
+  def get_edges(code)
+    sexp = FastRuby::FastRubySexp.parse(code)
+
+    edges = GraphEdges.new(sexp)
+    sexp.edges.each do |tree_orig, tree_dest|
+      edges << [tree_orig, tree_dest]
+    end
+
+    yield(sexp, edges)
+  end
+
+  module KlassLevelHelper
+    def assert_graph(assert_name, code, node_count = nil)
+      it assert_name do
+        get_edges(code) do |sexp, edges|
+          condition_tree = sexp[1]
+          execution_tree = sexp[2]
+
+          if node_count
+            edges.count.should be == node_count
+          end
+
+          edges.tr_edges yield(sexp,edges) do |a,b|
+            edges.should include([a,b])
+          end
+        end
+      end
+    end
+
+    def assert_graph_defn(assert_name, code, node_count = nil)
+      it assert_name do
+        get_defn_edges(code) do |sexp, edges|
+          condition_tree = sexp[1]
+          execution_tree = sexp[2]
+
+          if node_count
+            edges.count.should be == node_count
+          end
+
+          edges.tr_edges yield(sexp,edges) do |a,b|
+            edges.should include([a,b])
+          end
+        end
+      end
+    end
+  end
+
+  def self.included(klass)
+    klass.extend KlassLevelHelper
+  end
+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

@@ -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

@@ -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/ruby/block/proc_as_block_spec.rb

@@ -0,0 +1,214 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  class ::VY1
+    fastruby "
+      def foo
+        yield
+      end
+    "
+  end
+
+  it "should allow block as proc when calling from normal ruby" do
+    executed = 0
+    
+    block = proc do 
+      executed = 1
+    end
+    
+    ::VY1.new.foo(&block)
+    
+    executed.should be == 1
+  end
+
+  class ::VY2
+    fastruby "
+      def foo
+        yield
+      end
+      
+      def bar(block)
+        foo(&block)
+      end
+    "
+  end
+
+  it "should allow block as proc when calling from fastruby" do
+    executed = 0
+    
+    block = proc do 
+      executed = 1
+    end
+    
+    ::VY2.new.bar(block)
+    
+    executed.should be == 1
+  end
+
+  class ::VY3
+    fastruby "
+      def foo
+        yield(1)
+      end
+      
+      def bar(block)
+        foo(&block)
+      end
+    "
+  end
+
+  it "should allow block as proc when calling from fastruby with arguments" do
+    executed = 0
+    recv_x = nil
+    
+    block = proc do |x|
+      recv_x = x       
+      executed = 1
+    end
+    
+    ::VY3.new.bar(block)
+    
+    recv_x.should be == 1
+    executed.should be == 1
+  end
+
+
+  class ::VY4
+      def foo(a,b,c)
+        yield(a,b,c)
+      end
+      
+    
+    fastruby "
+      def bar(x,block)
+        foo(*x,&block)
+      end
+    "
+  end
+
+  it "should allow block as proc when calling from fastruby with splat arguments" do
+    executed = 0
+    recv_a = nil
+    recv_b = nil
+    recv_c = nil
+    
+    block = proc do |a,b,c|
+      recv_a = a
+      recv_b = b
+      recv_c = c
+      executed = 1
+    end
+    
+    ::VY4.new.bar([1,2,3],block)
+    
+    recv_a.should be == 1
+    recv_b.should be == 2
+    recv_c.should be == 3
+    executed.should be == 1
+  end
+
+  class ::VY5
+      def foo(a)
+        yield(a)
+      end
+      
+    
+    fastruby "
+      def bar(x,block)
+        foo(*x,&block)
+      end
+    "
+  end
+
+  it "should allow pass symbols as blocks" do
+    vy5 = ::VY5.new
+    vy5.bar([44],:to_s).should be == "44"
+  end
+
+
+  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)
+      end
+      
+    
+    fastruby "
+      def bar(x,block)
+        foo(x,&block)
+      end
+    "
+  end
+
+  it "should allow single arguments with block calling ruby methods" do
+    vy7 = ::VY7.new
+
+    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

data/spec/ruby/block/redo_spec.rb

@@ -0,0 +1,133 @@
+require "fastruby"
+
+describe FastRuby, "fastruby redo statement" do
+  class ::WB1
+    fastruby "
+      def bar
+        yield
+      end
+
+      def foo
+        sum = 0
+        bar do
+          sum = sum + 1
+          redo if sum<10
+        end
+
+        sum
+      end
+    "
+  end
+
+  it "should execute basic redo" do
+    wb1 = ::WB1.new
+    wb1.foo.should be == 10
+  end
+
+  class ::WB2
+      def bar
+        yield
+      end
+
+    fastruby "
+
+      def foo
+        sum = 0
+        bar do
+          sum = sum + 1
+          redo if sum<10
+        end
+
+        sum
+      end
+    "
+  end
+
+  it "should execute basic redo (called method is in ruby)" do
+    wb2 = ::WB2.new
+    wb2.foo.should be == 10
+  end
+
+  class ::WB3
+    fastruby "
+      def foo
+        redo
+      end
+    "
+  end
+
+  it "should raise LocalJumpError when invoked illegal redo" do
+    wb3 = ::WB3.new
+
+    lambda {
+      wb3.foo
+    }.should raise_error(LocalJumpError)
+  end
+  
+  class ::WB4
+    fastruby <<EOS
+    def foo
+      yield(5)
+    end
+  
+    def bar
+      a = true
+      foo do |n|
+        if a
+          a = false
+          n = 555
+          redo
+        end
+        n
+      end
+    end
+EOS
+  end
+
+  it "should NOT restore variable arguments on block when calling redo" do
+    wb4 = ::WB4.new
+    wb4.bar.should be == 555
+  end
+
+  class ::WB5
+    fastruby <<EOS
+    def bar
+      a = true
+      proc do |n|
+        if a
+          a = false
+          n = 555
+          redo
+        end
+        n
+      end
+    end
+EOS
+  end
+
+  it "should NOT restore variable arguments on block when calling redo (lambda block)" do
+    wb5 = ::WB5.new
+    wb5.bar.call(5).should be == 555
+  end
+  
+  class ::WB6
+    fastruby <<EOS
+    def bar
+      a = true
+      Proc.new do |n|
+        if a
+          a = false
+          n = 555
+          redo
+        end
+        n
+      end
+    end
+EOS
+  end
+
+  it "should NOT restore variable arguments on block when calling redo (Proc.new block)" do
+    wb6 = ::WB6.new
+    wb6.bar.call(5).should be == 555
+  end  
+end

data/spec/ruby/defn/single_function_spec.rb

@@ -0,0 +1,50 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  it "should allow define single method (without class)" do
+    fastruby "
+      def foo
+      end
+    "
+  end
+
+  it "should allow define and call single method (without class)" do
+    fastruby "
+      def foo
+        
+      end
+    "
+    foo
+  end
+  
+  it "should allow define method from inside another method" do
+    class ::YZU1
+    fastruby "
+      def foo
+        def bar
+          77
+        end
+      end
+    "
+    end
+    
+    ::YZU1.new.foo
+  end
+  
+  it "should allow define and call method from inside another method" do
+    class ::YZU2
+    fastruby "
+      def foo
+        def bar
+          99
+        end
+      end
+    "
+    end
+
+    yzu2 = ::YZU2.new
+    yzu2.foo
+    yzu2.bar.should be == 99
+  end  
+
+end