rdg 0.0.2 → 0.1.0

data/lib/rdg/graph/rgl/allow_duplicates.rb

@@ -0,0 +1,45 @@
+require "rgl/dot"
+
+# This module provides a workaround for RGL issue #15:
+# https://github.com/monora/rgl/issues/15
+#
+# Once the fix appears in an RGL release, this module
+# and any includes of this module can be safely removed.
+
+# rubocop:disable all
+module RDG
+  module RGL
+    module AllowDuplicates
+      def to_dot_graph(params = {})
+        params['name'] ||= self.class.name.gsub(/:/, '_')
+        fontsize       = params['fontsize'] ? params['fontsize'] : '8'
+        graph          = (directed? ? ::RGL::DOT::Digraph : ::RGL::DOT::Graph).new(params)
+        edge_class     = directed? ? ::RGL::DOT::DirectedEdge : ::RGL::DOT::Edge
+
+        each_vertex do |v|
+          graph << ::RGL::DOT::Node.new(
+              'name'     => v.object_id,
+              'fontsize' => fontsize,
+              'label'    => vertex_label(v)
+          )
+        end
+
+        each_edge do |u, v|
+          graph << edge_class.new(
+              'from'     => u.object_id,
+              'to'       => v.object_id,
+              'fontsize' => fontsize
+          )
+        end
+
+        graph
+      end
+      
+      # Returns a label for vertex v. Default is v.to_s
+      def vertex_label(v)
+        v.to_s
+      end
+    end
+  end
+end
+# rubocop:enable all

data/lib/rdg/tree/ast.rb

@@ -1,6 +1,5 @@
-require "rgl/adjacency"
-require "rgl/dot"
 require "parser/current"
+require_relative "../graph/bidirected_adjacency_graph"
 require_relative "rgl/pre_order_iterator"
 require_relative "rgl/post_order_iterator"
 
@@ -16,7 +15,7 @@ module RDG
       end
 
       def initialize(ast)
-        @graph = ::RGL::DirectedAdjacencyGraph.new
+        @graph = Graph::BidirectedAdjacencyGraph.new
         import(ast)
       end
 
@@ -75,7 +74,19 @@ module RDG
         end
 
         def children
-          @graph.each_adjacent(self).to_a
+          @graph.each_successor(self).to_a
+        end
+
+        def parent
+          @graph.each_predecessor(self).first
+        end
+
+        def ancestors
+          parent.nil? ? [] : parent.ancestors.unshift(parent)
+        end
+
+        def siblings
+          parent.nil? ? [] : parent.children
         end
 
         def ==(other)

data/lib/rdg/version.rb

@@ -1,3 +1,3 @@
 module RDG
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/rdg.gemspec

@@ -18,10 +18,11 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "parser", "~> 2.2.0.2"
+  spec.add_runtime_dependency "parser", "~> 2.2.2.0"
   spec.add_runtime_dependency "rgl", "~> 0.5.0"
+  spec.add_runtime_dependency "require_all", "~> 1.3.2"
   
-  spec.add_development_dependency "bundler", "~> 1.8.0"
+  spec.add_development_dependency "bundler", "~> 1.9.0"
   spec.add_development_dependency "rake", "~> 10.4.2"
   spec.add_development_dependency "rspec", "~> 3.2.0"
   spec.add_development_dependency "codeclimate-test-reporter", "~> 0.4.6"

data/spec/integration/cfg/conditionals/case_spec.rb

@@ -0,0 +1,66 @@
+require "rdg/cfg"
+
+module RDG
+  describe CFG do
+    context "for simple case expressions" do
+      it "should show control flowing to expression, to test and then through and around action" do
+        cfg = CFG.from_source("a = 1; case b; when 2; c = 1; end; z = 1")
+
+        expect(cfg).to contain("a = 1", "b", "2", "c = 1", "z = 1")
+
+        expect(cfg).to flow_between("a = 1", "b")
+        expect(cfg).to flow_between("b", "2")
+        expect(cfg).to flow_between("2", "z = 1")
+        expect(cfg).to flow_between("2", "c = 1")
+        expect(cfg).to flow_between("c = 1", "z = 1")
+      end
+
+      it "should show control flowing through longer action" do
+        cfg = CFG.from_source("a = 1; case b; when 2; c = 1; d = 1; e = 1; end; z = 1")
+
+        expect(cfg).to contain("a = 1", "b", "2", "c = 1", "d = 1", "e = 1", "z = 1")
+
+        expect(cfg).to flow_between("a = 1", "b")
+        expect(cfg).to flow_between("b", "2")
+        expect(cfg).to flow_between("2", "z = 1")
+        expect(cfg).to flow_between("2", "c = 1")
+        expect(cfg).to flow_between("c = 1", "d = 1")
+        expect(cfg).to flow_between("d = 1", "e = 1")
+        expect(cfg).to flow_between("e = 1", "z = 1")
+      end
+    end
+
+    context "for case expressions with several actions" do
+      it "should show control flowing from test to action and to alternative" do
+        cfg = CFG.from_source("a = 1; case b; when 2; c = 1; else; d = 1; end; z = 1")
+
+        expect(cfg).to contain("a = 1", "b", "2", "c = 1", "d = 1", "z = 1")
+
+        expect(cfg).to flow_between("a = 1", "b")
+        expect(cfg).to flow_between("b", "2")
+        expect(cfg).to flow_between("2", "c = 1")
+        expect(cfg).to flow_between("2", "d = 1")
+        expect(cfg).to flow_between("c = 1", "z = 1")
+        expect(cfg).to flow_between("d = 1", "z = 1")
+      end
+
+      it "should show control flowing from test to action and to next test" do
+        cfg = CFG.from_source("a = 1;" \
+                              "case b; when 2; c = 1; when 3; d = 1; else; e = 1; end;" \
+                              "z = 1")
+
+        expect(cfg).to contain("a = 1", "b", "2", "c = 1", "3", "d = 1", "e = 1", "z = 1")
+
+        expect(cfg).to flow_between("a = 1", "b")
+        expect(cfg).to flow_between("b", "2")
+        expect(cfg).to flow_between("2", "c = 1")
+        expect(cfg).to flow_between("2", "3")
+        expect(cfg).to flow_between("3", "d = 1")
+        expect(cfg).to flow_between("3", "e = 1")
+        expect(cfg).to flow_between("c = 1", "z = 1")
+        expect(cfg).to flow_between("d = 1", "z = 1")
+        expect(cfg).to flow_between("e = 1", "z = 1")
+      end
+    end
+  end
+end

data/spec/integration/cfg/{if_spec.rb → conditionals/if_spec.rb}

@@ -3,21 +3,13 @@ require "rdg/cfg"
 module RDG
   describe CFG do
     context "for simple if expressions" do
-      it "should show control flowing from predicate to successor (skipping consequence)" do
+      it "should show control flowing from predicate through and around consequence" do
         cfg = CFG.from_source("a = 1; if b == 1 then; c = 1; end; z = 1")
 
         expect(cfg).to contain("a = 1", "b == 1", "c = 1", "z = 1")
 
         expect(cfg).to flow_between("a = 1", "b == 1")
         expect(cfg).to flow_between("b == 1", "z = 1")
-      end
-
-      it "should show control flowing into predicate and through consequence" do
-        cfg = CFG.from_source("a = 1; if b == 1 then; c = 1; end; z = 1")
-
-        expect(cfg).to contain("a = 1", "b == 1", "c = 1", "z = 1")
-
-        expect(cfg).to flow_between("a = 1", "b == 1")
         expect(cfg).to flow_between("b == 1", "c = 1")
         expect(cfg).to flow_between("c = 1", "z = 1")
       end
@@ -33,6 +25,17 @@ module RDG
         expect(cfg).to flow_between("d = 1", "e = 1")
         expect(cfg).to flow_between("e = 1", "z = 1")
       end
+
+      it "should show control flowing through and around predicate of modifier if" do
+        cfg = CFG.from_source("a = 1; c = 1 if b == 1; z = 1")
+
+        expect(cfg).to contain("a = 1", "b == 1", "c = 1", "z = 1")
+
+        expect(cfg).to flow_between("a = 1", "b == 1")
+        expect(cfg).to flow_between("b == 1", "z = 1")
+        expect(cfg).to flow_between("b == 1", "c = 1")
+        expect(cfg).to flow_between("c = 1", "z = 1")
+      end
     end
 
     context "for if expressions with several consequences" do
@@ -64,6 +67,18 @@ module RDG
         expect(cfg).to flow_between("d = 1", "z = 1")
         expect(cfg).to flow_between("e = 1", "z = 1")
       end
+
+      it "should show control flowing from predicate to both consequences of ternary" do
+        cfg = CFG.from_source("a = 1; b == 1 ? c = 1 : d = 1; z = 1")
+
+        expect(cfg).to contain("a = 1", "b == 1", "c = 1", "d = 1", "z = 1")
+
+        expect(cfg).to flow_between("a = 1", "b == 1")
+        expect(cfg).to flow_between("b == 1", "c = 1")
+        expect(cfg).to flow_between("b == 1", "d = 1")
+        expect(cfg).to flow_between("c = 1", "z = 1")
+        expect(cfg).to flow_between("d = 1", "z = 1")
+      end
     end
   end
 end

data/spec/integration/cfg/conditionals/unless_spec.rb

@@ -0,0 +1,53 @@
+require "rdg/cfg"
+
+module RDG
+  describe CFG do
+    context "for unless expressions" do
+      it "should show control flowing from predicate through and around consequence" do
+        cfg = CFG.from_source("a = 1; unless b == 1 then; c = 1; end; z = 1")
+
+        expect(cfg).to contain("a = 1", "b == 1", "c = 1", "z = 1")
+
+        expect(cfg).to flow_between("a = 1", "b == 1")
+        expect(cfg).to flow_between("b == 1", "z = 1")
+        expect(cfg).to flow_between("b == 1", "c = 1")
+        expect(cfg).to flow_between("c = 1", "z = 1")
+      end
+
+      it "should show control flowing into predicate and through longer consequence" do
+        cfg = CFG.from_source("a = 1; unless b == 1 then; c = 1; d = 1; e = 1; end; z = 1")
+
+        expect(cfg).to contain("a = 1", "b == 1", "c = 1", "d = 1", "e = 1", "z = 1")
+
+        expect(cfg).to flow_between("a = 1", "b == 1")
+        expect(cfg).to flow_between("b == 1", "c = 1")
+        expect(cfg).to flow_between("c = 1", "d = 1")
+        expect(cfg).to flow_between("d = 1", "e = 1")
+        expect(cfg).to flow_between("e = 1", "z = 1")
+      end
+
+      it "should show control flowing through and around predicate of modifier unless" do
+        cfg = CFG.from_source("a = 1; c = 1 unless b == 1; z = 1")
+
+        expect(cfg).to contain("a = 1", "b == 1", "c = 1", "z = 1")
+
+        expect(cfg).to flow_between("a = 1", "b == 1")
+        expect(cfg).to flow_between("b == 1", "z = 1")
+        expect(cfg).to flow_between("b == 1", "c = 1")
+        expect(cfg).to flow_between("c = 1", "z = 1")
+      end
+
+      it "should show control flowing from predicate to (and out of) all consequences" do
+        cfg = CFG.from_source("a = 1; unless b == 1 then; c = 1; else; d = 1; end; z = 1")
+
+        expect(cfg).to contain("a = 1", "b == 1", "c = 1", "d = 1", "z = 1")
+
+        expect(cfg).to flow_between("a = 1", "b == 1")
+        expect(cfg).to flow_between("b == 1", "c = 1")
+        expect(cfg).to flow_between("b == 1", "d = 1")
+        expect(cfg).to flow_between("c = 1", "z = 1")
+        expect(cfg).to flow_between("d = 1", "z = 1")
+      end
+    end
+  end
+end

data/spec/integration/cfg/exceptions_spec.rb

@@ -0,0 +1,131 @@
+require "rdg/cfg"
+
+module RDG
+  describe CFG do
+    ["begin"].each do |block_type|
+      context "for a #{block_type} block with exception handlers" do
+        it "should show control flow from every child to the start of every handler" do
+          cfg = CFG.from_source(
+            "#{block_type}; a = 1; b = 1; rescue Err; y = 1; rescue; z = 1; end"
+          )
+
+          expect(cfg).to contain("a = 1", "b = 1", "y = 1", "z = 1")
+
+          expect(cfg).to flow_between("a = 1", "y = 1")
+          expect(cfg).to flow_between("b = 1", "y = 1")
+          expect(cfg).to flow_between("a = 1", "z = 1")
+          expect(cfg).to flow_between("b = 1", "z = 1")
+        end
+
+        it "should show control flowing into the first child" do
+          cfg = CFG.from_source(
+            "a = 1; #{block_type}; b = 1; rescue; z = 1; end"
+          )
+
+          expect(cfg).to contain("a = 1", "b = 1", "z = 1")
+
+          expect(cfg).to flow_between("a = 1", "b = 1")
+        end
+
+        it "should show control flowing out of the last child and the handlers to successor" do
+          cfg = CFG.from_source(
+            "#{block_type}; a = 1; b = 1; rescue Err; w = 1; x = 1; rescue; y = 1; end; z = 1"
+          )
+
+          expect(cfg).to contain("a = 1", "b = 1", "w = 1", "x = 1", "y = 1", "z = 1")
+
+          expect(cfg).to flow_between("b = 1", "z = 1")
+          expect(cfg).to flow_between("x = 1", "z = 1")
+          expect(cfg).to flow_between("y = 1", "z = 1")
+        end
+
+        it "should show control flowing out from out of last child through an else" do
+          cfg = CFG.from_source(
+            "#{block_type}; a = 1; b = 1; rescue Err; w = 1; x = 1; else; y = 1; end; z = 1"
+          )
+
+          expect(cfg).to contain("a = 1", "b = 1", "x = 1", "w  = 1", "y = 1", "z = 1")
+
+          expect(cfg).to flow_between("b = 1", "y = 1")
+          expect(cfg).to flow_between("y = 1", "z = 1")
+
+          expect(cfg).not_to flow_between("b = 1", "z = 1")
+        end
+      end
+
+      context "for a #{block_type} with an ensure" do
+        it "should show control flow from every child to the start of an ensure" do
+          cfg = CFG.from_source(
+            "#{block_type}; a = 1; b = 1; ensure; z = 1; end; final = 1"
+          )
+
+          expect(cfg).to contain("a = 1", "b = 1", "z = 1", "final = 1")
+
+          expect(cfg).to flow_between("a = 1", "z = 1")
+          expect(cfg).to flow_between("b = 1", "z = 1")
+
+          expect(cfg).to flow_between("z = 1", "final = 1")
+          expect(cfg).not_to flow_between("b = 1", "final = 1")
+        end
+
+        it "should show control flow from every child incl. rescues to the start of an ensure" do
+          cfg = CFG.from_source(
+            "#{block_type}; a = 1; b = 1;" \
+            "rescue Err; v = 1;" \
+            "rescue; w = 1; y = 1;" \
+            "ensure; z = 1; end;" \
+            "final = 1"
+          )
+
+          expect(cfg).to contain("a = 1", "b = 1", "v = 1", "w = 1", "y = 1", "z = 1", "final = 1")
+
+          expect(cfg).to flow_between("a = 1", "z = 1")
+          expect(cfg).to flow_between("b = 1", "z = 1")
+          expect(cfg).to flow_between("w = 1", "z = 1")
+          expect(cfg).to flow_between("y = 1", "z = 1")
+
+          expect(cfg).to flow_between("z = 1", "final = 1")
+          expect(cfg).not_to flow_between("b = 1", "final = 1")
+          expect(cfg).not_to flow_between("v = 1", "final = 1")
+          expect(cfg).not_to flow_between("y = 1", "final = 1")
+        end
+
+        it "should show control flow from last child to ensure via else" do
+          cfg = CFG.from_source(
+            "#{block_type}; a = 1; b = 1;" \
+            "rescue; v = 1;" \
+            "else; w = 1; y = 1;" \
+            "ensure; z = 1; end;" \
+            "final = 1"
+          )
+
+          expect(cfg).to contain("a = 1", "b = 1", "v = 1", "w = 1", "y = 1", "z = 1", "final = 1")
+
+          expect(cfg).to flow_between("b = 1", "w = 1")
+          expect(cfg).to flow_between("y = 1", "z = 1")
+          expect(cfg).to flow_between("z = 1", "final = 1")
+
+          # b = 1 could raise, not be rescued and flow directly to ensure
+          expect(cfg).to flow_between("b = 1", "z = 1")
+          expect(cfg).not_to flow_between("b = 1", "final = 1")
+        end
+      end
+
+      context "retrying" do
+        it "should return control to the start of the #{block_type}" do
+          cfg = CFG.from_source(
+            "#{block_type}; a = 1; rescue; retry; end; z = 1"
+          )
+
+          expect(cfg).to contain("a = 1", "retry", "z = 1")
+
+          expect(cfg).to flow_between("a = 1", "z = 1")
+          expect(cfg).to flow_between("a = 1", "retry")
+          expect(cfg).to flow_between("retry", "a = 1")
+
+          expect(cfg).not_to flow_between("retry", "z = 1")
+        end
+      end
+    end
+  end
+end

data/spec/integration/cfg/loops/loop_control_spec.rb

@@ -0,0 +1,90 @@
+require "rdg/cfg"
+
+module RDG
+  describe CFG do
+    context "for simple loop control expressions" do
+      it "should show control flowing from break directly to successor" do
+        cfg = CFG.from_source("a = 1; while true do; a += 1; break; b += 1; end; z = 1")
+
+        expect(cfg).to contain("a = 1", "true", "a += 1", "break", "b += 1", "z = 1")
+
+        expect(cfg).to flow_between("a = 1", "true")
+        expect(cfg).to flow_between("true", "a += 1")
+        expect(cfg).to flow_between("true", "z = 1")
+        expect(cfg).to flow_between("a += 1", "break")
+        expect(cfg).to flow_between("break", "z = 1")
+        expect(cfg).to flow_between("b += 1", "true")
+
+        expect(cfg).not_to flow_between("break", "a += 1")
+      end
+
+      it "should show control flowing from nested break only to successor" do
+        cfg = CFG.from_source("a = 1; while true do; a += 1; break if false; b += 1; end; z = 1")
+
+        expect(cfg).to contain("a = 1", "true", "a += 1", "break", "false", "b += 1", "z = 1")
+
+        expect(cfg).to flow_between("a = 1", "true")
+        expect(cfg).to flow_between("true", "a += 1")
+        expect(cfg).to flow_between("true", "z = 1")
+        expect(cfg).to flow_between("a += 1", "false")
+        expect(cfg).to flow_between("false", "break")
+        expect(cfg).to flow_between("false", "b += 1")
+        expect(cfg).to flow_between("break", "z = 1")
+        expect(cfg).to flow_between("b += 1", "true")
+
+        expect(cfg).not_to flow_between("break", "a += 1")
+      end
+
+      %w(next redo).each do |kind|
+        it "should show control flowing from #{kind} directly to test" do
+          cfg = CFG.from_source("a = 1; while true do; a += 1; #{kind}; b += 1; end; z = 1")
+
+          expect(cfg).to contain("a = 1", "true", "a += 1", "#{kind}", "b += 1", "z = 1")
+
+          expect(cfg).to flow_between("a = 1", "true")
+          expect(cfg).to flow_between("true", "a += 1")
+          expect(cfg).to flow_between("true", "z = 1")
+          expect(cfg).to flow_between("a += 1", "#{kind}")
+          expect(cfg).to flow_between("#{kind}", "true")
+          expect(cfg).to flow_between("b += 1", "true")
+        end
+      end
+    end
+
+    context "for nested loop control expressions" do
+      it "should show control flowing from break to inner loop's successor" do
+        cfg = CFG.from_source("while false do;" \
+                              "a = 1; while true do; a += 1; break; b += 1; end; z = 1;" \
+                              "end;" \
+                              "final = 1")
+
+        expect(cfg).to flow_between("break", "z = 1")
+        expect(cfg).not_to flow_between("break", "final = 1")
+      end
+
+      %w(next redo).each do |kind|
+        it "should show control flowing from #{kind} to inner loop's test" do
+          cfg = CFG.from_source("while false do;" \
+                                "a = 1; while true do; a += 1; #{kind}; b += 1; end; z = 1;" \
+                                "end;" \
+                                "final = 1")
+
+          expect(cfg).to flow_between("#{kind}", "true")
+          expect(cfg).not_to flow_between("#{kind}", "false")
+        end
+      end
+    end
+
+    context "for complex loop test" do
+      %w(next redo).each do |kind|
+        it "should show control flow from #{kind} to children of inner loop's test" do
+          cfg = CFG.from_source("a = 1;" \
+                                "while 42 ? :foo : 'bar' do; a += 1; #{kind}; b += 1; end;" \
+                                "z = 1;")
+
+          expect(cfg).to flow_between("#{kind}", "42")
+        end
+      end
+    end
+  end
+end