rdg 0.0.2 → 0.1.0

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

@@ -0,0 +1,70 @@
+require "rdg/cfg"
+
+module RDG
+  describe CFG do
+    %w(while until).each do |kind|
+      context "for simple #{kind} expressions" do
+        it "should show control flowing between test and body, and out to successor" do
+          cfg = CFG.from_source("a = 1; #{kind} true do; a += 1; end; z = 1")
+
+          expect(cfg).to contain("a = 1", "true", "a += 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", "true")
+        end
+
+        it "should show control flowing through longer body" do
+          cfg = CFG.from_source("a = 1; #{kind} true do; a += 1; b += 1; c += 1; end; z = 1")
+
+          expect(cfg).to contain("a = 1", "true", "a += 1", "b += 1", "c += 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", "b += 1")
+          expect(cfg).to flow_between("b += 1", "c += 1")
+          expect(cfg).to flow_between("c += 1", "true")
+        end
+
+        it "should show control flowing between test and body for modifier #{kind}" do
+          cfg = CFG.from_source("a = 1; b += 1 #{kind} true; z = 1")
+
+          expect(cfg).to contain("a = 1", "b += 1", "true", "z = 1")
+
+          expect(cfg).to flow_between("a = 1", "true")
+          expect(cfg).to flow_between("true", "b +=1")
+          expect(cfg).to flow_between("true", "z = 1")
+          expect(cfg).to flow_between("b += 1", "true")
+        end
+      end
+    end
+
+    context "for simple for expressions" do
+      it "should show control flowing between test and body, and out to successor" do
+        cfg = CFG.from_source("a = 1; for i in [1,2,3] do; a += 1; end; z = 1")
+
+        expect(cfg).to contain("a = 1", "[1,2,3]", "a += 1", "z = 1")
+
+        expect(cfg).to flow_between("a = 1", "[1,2,3]")
+        expect(cfg).to flow_between("[1,2,3]", "a += 1")
+        expect(cfg).to flow_between("[1,2,3]", "z = 1")
+        expect(cfg).to flow_between("a += 1", "[1,2,3]")
+      end
+
+      it "should show control flowing through longer body" do
+        cfg = CFG.from_source("a = 1; for i in [1,2,3] do; a += 1; b += 1; c += 1; end; z = 1")
+
+        expect(cfg).to contain("a = 1", "[1,2,3]", "a += 1", "b += 1", "c += 1", "z = 1")
+
+        expect(cfg).to flow_between("a = 1", "[1,2,3]")
+        expect(cfg).to flow_between("[1,2,3]", "a += 1")
+        expect(cfg).to flow_between("[1,2,3]", "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", "[1,2,3]")
+      end
+    end
+  end
+end

data/spec/integration/cfg/sequence_spec.rb

@@ -3,7 +3,13 @@ require "rdg/cfg"
 module RDG
   describe CFG do
     context "for a sequence of statements" do
-      xit "should show no control flow for a lone element" do
+      it "should show no control flow for a lone integer" do
+        cfg = CFG.from_source("1")
+
+        expect(cfg).to contain("1")
+      end
+
+      it "should show no control flow for a lone assignment" do
         cfg = CFG.from_source("a = 1")
 
         expect(cfg).to contain("a = 1")

data/spec/support/doubles/fake_ast.rb

@@ -0,0 +1,15 @@
+class FakeAst
+  attr_accessor :type, :children, :ancestors, :siblings
+
+  def initialize(type, children: [], ancestors: [], siblings: [])
+    @type, @children, @ancestors, @siblings = type, children, ancestors, siblings
+  end
+
+  def empty?
+    false
+  end
+
+  def parent
+    ancestors.first
+  end
+end

data/spec/support/matchers/flow_between_matcher.rb

@@ -1,6 +1,6 @@
 RSpec::Matchers.define :flow_between do |source_of_start, source_of_end|
   match do |graph|
-    graph.has_edge?(
+    graph.edge?(
       find_vertex(graph, source_of_start),
       find_vertex(graph, source_of_end)
     )

data/spec/unit/analysis/composite_spec.rb

@@ -0,0 +1,47 @@
+require "rdg/analysis/composite"
+
+module RDG
+  module Analysis
+    describe Composite do
+      subject { Composite.compose(FirstAnalyser, SecondAnalyser).new(:node, :context) }
+
+      it "delegates analysis to each composed analyser in turn" do
+        subject.analyse
+
+        expect(FirstAnalyser.called).to be_truthy
+        expect(SecondAnalyser.called).to be_truthy
+      end
+
+      it "makes node available to each composed analyser" do
+        subject.analyse
+
+        expect(FirstAnalyser.node).to eq(:node)
+        expect(SecondAnalyser.node).to eq(:node)
+      end
+
+      it "makes context available to each composed analyser" do
+        subject.analyse
+
+        expect(FirstAnalyser.context).to eq(:context)
+        expect(SecondAnalyser.context).to eq(:context)
+      end
+    end
+
+    class FakeAnalyser
+      def initialize(node, context)
+        self.class.node, self.class.context = node, context
+      end
+
+      def analyse
+        self.class.called = true
+      end
+
+      class << self
+        attr_accessor :called, :node, :context
+      end
+    end
+
+    class FirstAnalyser < FakeAnalyser; end
+    class SecondAnalyser < FakeAnalyser; end
+  end
+end

data/spec/unit/analysis/equivalences_spec.rb

@@ -0,0 +1,29 @@
+require "rdg/analysis/equivalences"
+
+module RDG
+  module Analysis
+    describe Equivalences do
+      let(:ast) { FakeAst.new(:begin, children: [1, 2, 3]) }
+
+      context "all" do
+        it "returns direct equivalents" do
+          subject.add(:if, [:predicate, :consequence])
+
+          expect(subject.all(:if)).to eq([:predicate, :consequence])
+        end
+
+        it "returns indirect equivalents transitively" do
+          subject.add(:if, [:predicate, :consequence])
+          subject.add(:predicate, [:send, :float])
+          subject.add(:consequence, [:return])
+
+          expect(subject.all(:if)).to eq([:send, :float, :return])
+        end
+
+        it "returns the original when there is no equivalent" do
+          expect(subject.first(:if)).to eq(:if)
+        end
+      end
+    end
+  end
+end

data/spec/unit/{control/analyser_spec.rb → analysis/propagater_spec.rb}

@@ -1,27 +1,33 @@
-require "rdg/control/analyser"
+require "rdg/analysis/propagater"
 
 module RDG
-  module Control
-    describe Analyser do
-      let(:ast) { double("ast") }
+  module Analysis
+    describe Propagater do
+      let(:ast) { FakeAst.new(:some_type) }
       let(:graph) { spy("graph") }
+      let(:equivalences) { spy("equivalences") }
+      let(:context) { Context.new(graph, equivalences) }
 
       subject do
-        class DummyAnalyser < Analyser
+        class DummyPropagater < Propagater
           def internal_flow_edges
-            [[:s1, :e1], [:s2, :e2]]
+            [%i(s1 e1), %i(s2 e2)]
           end
 
-          def start_nodes
-            [:s1, :s2]
+          def start_node
+            :s1
           end
 
           def end_nodes
-            [:e1, :e2]
+            %i(e1 e2)
+          end
+
+          def nodes
+            %i(s1 s2 e1 e2)
           end
         end
 
-        DummyAnalyser.new(ast, graph, nil)
+        DummyPropagater.new(ast, context)
       end
 
       it "should add a CFG edge for every internal flow edge" do
@@ -31,14 +37,13 @@ module RDG
         expect(graph).to have_received(:add_edge).with(:s2, :e2)
       end
 
-      it "should move any incoming edges to start nodes" do
+      it "should move any incoming edges to start node" do
         allow(graph).to receive(:each_predecessor).and_yield(:predecessor)
 
         subject.analyse
 
         expect(graph).to have_received(:remove_edge).with(:predecessor, ast)
         expect(graph).to have_received(:add_edge).with(:predecessor, :s1)
-        expect(graph).to have_received(:add_edge).with(:predecessor, :s2)
       end
 
       it "should move any outgoing edges to end nodes" do
@@ -56,6 +61,12 @@ module RDG
 
         expect(graph).to have_received(:remove_vertex).with(ast)
       end
+
+      it "should add equivalences" do
+        subject.analyse
+
+        expect(equivalences).to have_received(:add).with(ast, %i(s1 s2 e1 e2))
+      end
     end
   end
 end

data/spec/unit/analysis/registry_spec.rb

@@ -0,0 +1,61 @@
+require "rdg/analysis/registry"
+
+module RDG
+  module Analysis
+    describe Registry do
+      let(:ast) { FakeAst.new(:if) }
+
+      before(:each) do
+        Registry.clear
+      end
+
+      it "should allow analysers to be added by type" do
+        Registry.register_by_type FakeIfAnalyser, :if
+        analyser = subject.analyser_for(ast, :context)
+
+        expect(analyser.class).to eq(FakeIfAnalyser)
+      end
+
+      it "should select the correct analyser based on the AST's type" do
+        Registry.register_by_type FakeIfAnalyser, :if
+        Registry.register_by_type FakeForAnalyser, :for
+        analyser = subject.analyser_for(ast, :context)
+
+        expect(analyser.class).to eq(FakeIfAnalyser)
+      end
+
+      it "should select the default analyser if the AST's type is not recognised" do
+        Registry.register_by_type FakeForAnalyser, :for
+        Registry.register_default FakeDefaultAnalyser
+        analyser = subject.analyser_for(ast, :context)
+
+        expect(analyser.class).to eq(FakeDefaultAnalyser)
+      end
+
+      context "customisation" do
+        before(:each) do
+          Registry.register_by_type FakeIfAnalyser, :if
+          subject.prepend_for(ast, FakeExtraAnalyser)
+        end
+
+        it "should allow an additional handler to be prepended for a specific AST node" do
+          analyser = subject.analyser_for(ast, :context)
+
+          expect(analyser.class.superclass).to eq(Composite)
+          expect(analyser.types).to eq([FakeExtraAnalyser, FakeIfAnalyser])
+        end
+
+        it "should not run a prepended analyser for a different AST node of the same type" do
+          analyser = subject.analyser_for(FakeAst.new(:if), :context)
+
+          expect(analyser.class).to eq(FakeIfAnalyser)
+        end
+      end
+
+      class FakeDefaultAnalyser < Analyser; end
+      class FakeIfAnalyser < Analyser; end
+      class FakeForAnalyser < Analyser; end
+      class FakeExtraAnalyser < Analyser; end
+    end
+  end
+end

data/spec/unit/control/begin_spec.rb

@@ -3,14 +3,11 @@ require "rdg/control/begin"
 module RDG
   module Control
     describe Begin do
-      subject do
-        ast = double("ast")
-        allow(ast).to receive(:children) { [1, 2, 3] }
-        Begin.new(ast, nil, nil)
-      end
+      let(:ast) { FakeAst.new(:begin, children: [1, 2, 3]) }
+      subject { Begin.new(ast) }
 
       it "should have control flow start at the first child" do
-        expect(subject.start_nodes).to eq([1])
+        expect(subject.start_node).to eq(1)
       end
 
       it "should have control flow end at the last child" do

data/spec/unit/control/break_spec.rb

@@ -0,0 +1,26 @@
+require "rdg/control/break"
+
+module RDG
+  module Control
+    describe Break do
+      let(:graph) { spy("graph") }
+      let(:equivalences) { spy("equivalences") }
+      let(:context) { Analysis::Context.new(graph, equivalences) }
+
+      let(:inside_ast) { FakeAst.new(:send, ancestors: [loop_ast]) }
+      let(:outside_ast) { FakeAst.new(:send) }
+
+      let(:loop_ast) { FakeAst.new(:while, children: [:abstract_test]) }
+      let(:ast) { FakeAst.new(:thing, ancestors: [loop_ast]) }
+
+      subject { Break.new(ast, context) }
+
+      it "should use successor of test that are outside the loop as new successors" do
+        allow(equivalences).to receive(:first).with(:abstract_test).and_return(:test)
+        allow(graph).to receive(:each_successor).with(:test).and_return([inside_ast, outside_ast])
+
+        expect(subject.new_successors).to eq([outside_ast])
+      end
+    end
+  end
+end

data/spec/unit/control/case_spec.rb

@@ -0,0 +1,66 @@
+require "rdg/control/case"
+
+module RDG
+  module Control
+    describe Case do
+      context "sole (when) part" do
+        let(:ast) { FakeAst.new(:case, children: [:expression, :when, :""]) }
+        subject { Case.new(ast) }
+
+        it "should have control flow start at the expression" do
+          expect(subject.start_node).to eq(:expression)
+        end
+
+        it "should have control flow end at the when part" do
+          expect(subject.end_nodes).to eq([:when])
+        end
+
+        it "should have control flow edge between expression and when" do
+          expect(subject.internal_flow_edges).to eq([[:expression, :when]])
+        end
+      end
+
+      context "with else part" do
+        let(:ast) { FakeAst.new(:case, children: [:expression, :when, :alt]) }
+        subject { Case.new(ast) }
+
+        it "should have control flow start at the expression" do
+          expect(subject.start_node).to eq(:expression)
+        end
+
+        it "should have control flow end at the when and alternative" do
+          expect(subject.end_nodes).to eq([:when, :alt])
+        end
+
+        it "should have control flow edge from expression to when and then to alternative" do
+          expect(subject.internal_flow_edges).to eq([
+            [:expression, :when],
+            [:when, :alt]
+          ])
+        end
+      end
+
+      context "with several alternatives" do
+        let(:ast) { FakeAst.new(:case, children: [:expression, :when1, :when2, :when3, :alt]) }
+        subject { Case.new(ast) }
+
+        it "should have control flow start at the expression" do
+          expect(subject.start_node).to eq(:expression)
+        end
+
+        it "should have control flow end at the whens and alternative" do
+          expect(subject.end_nodes).to eq([:when1, :when2, :when3, :alt])
+        end
+
+        it "should have control flow edge from expression through whens to alternative" do
+          expect(subject.internal_flow_edges).to eq([
+            [:expression, :when1],
+            [:when1, :when2],
+            [:when2, :when3],
+            [:when3, :alt]
+          ])
+        end
+      end
+    end
+  end
+end

data/spec/unit/control/conditional_loop_spec.rb

@@ -0,0 +1,22 @@
+require "rdg/control/conditional_loop"
+
+module RDG
+  module Control
+    describe ConditionalLoop do
+      let(:ast) { FakeAst.new(:while, children: [:predicate, :body]) }
+      subject { ConditionalLoop.new(ast) }
+
+      it "should have control flow start at the predicate" do
+        expect(subject.start_node).to eq(:predicate)
+      end
+
+      it "should have control flow end at the predicate" do
+        expect(subject.end_nodes).to eq([:predicate])
+      end
+
+      it "should have control flow edges between predicate and body, and vice-versa" do
+        expect(subject.internal_flow_edges).to eq([[:predicate, :body], [:body, :predicate]])
+      end
+    end
+  end
+end