rdg 0.0.2 → 0.1.0

data/spec/unit/control/ensure_spec.rb

@@ -0,0 +1,33 @@
+require "rdg/control/ensure"
+
+module RDG
+  module Control
+    describe Ensure do
+      let(:registry) { spy('registry') }
+      let(:context) { Analysis::Context.new(spy('graph'), spy('equivalences'), registry) }
+
+      let(:main_ast) { FakeAst.new(:if) }
+      let(:ensure_ast) { FakeAst.new(:send) }
+      let(:ast) { FakeAst.new(:rescue, children: [main_ast, ensure_ast]) }
+      subject { Ensure.new(ast, context) }
+
+      it "should have control flow start at the main block" do
+        expect(subject.start_node).to eq(main_ast)
+      end
+
+      it "should have control flow end at the ensure block" do
+        expect(subject.end_nodes).to eq([ensure_ast])
+      end
+
+      it "should have control flow from main block to ensure block" do
+        expect(subject.internal_flow_edges).to eq([[main_ast, ensure_ast]])
+      end
+
+      it "should prepend Handler so that edges back to main_ast are created for ensure block" do
+        subject.analyse
+
+        expect(registry).to have_received(:prepend_for).with(ensure_ast, Handler)
+      end
+    end
+  end
+end

data/spec/unit/control/for_spec.rb

@@ -0,0 +1,26 @@
+require "rdg/control/for"
+
+module RDG
+  module Control
+    describe For do
+      let(:ast) { FakeAst.new(:for, children: [:iterator, :iterable, :body]) }
+      subject { For.new(ast) }
+
+      it "should have control flow start at the iterable object" do
+        expect(subject.start_node).to eq(:iterable)
+      end
+
+      it "should have control flow end at the iterable object" do
+        expect(subject.end_nodes).to eq(%i(iterable))
+      end
+
+      it "should have control flow edges between iterable and body, and vice-versa" do
+        expect(subject.internal_flow_edges).to eq([%i(iterable body), %i(body iterable)])
+      end
+
+      it "should have control flow nodes only for iterable and body, and not for iterator" do
+        expect(subject.nodes).to eq(%i(iterable body))
+      end
+    end
+  end
+end

data/spec/unit/control/handler_spec.rb

@@ -0,0 +1,27 @@
+require "rdg/control/handler"
+
+module RDG
+  module Control
+    describe Handler do
+      let(:graph) { spy("graph") }
+      let(:equivalences) { spy("equivalences") }
+      let(:context) { Analysis::Context.new(graph, equivalences) }
+
+      let(:block_ast) { FakeAst.new(:rescue, children: [:rescuable]) }
+      let(:ast) { FakeAst.new(:resbody, ancestors: [block_ast]) }
+
+      subject { Handler.new(ast, context) }
+
+      it "should add edges from main to handler" do
+        allow(equivalences).to receive(:all).with(:rescuable).and_return(
+          %i(first_rescuable second_rescuable)
+        )
+
+        subject.analyse
+
+        expect(graph).to have_received(:add_edge).with(:first_rescuable, ast)
+        expect(graph).to have_received(:add_edge).with(:second_rescuable, ast)
+      end
+    end
+  end
+end

data/spec/unit/control/if_spec.rb

@@ -4,14 +4,11 @@ module RDG
   module Control
     describe If do
       context "without any alternatives" do
-        subject do
-          ast = double("ast")
-          allow(ast).to receive(:children) { [:predicate, :consequence, :""] }
-          If.new(ast, nil, nil)
-        end
+        let(:ast) { FakeAst.new(:if, children: [:predicate, :consequence, :""]) }
+        subject { If.new(ast) }
 
         it "should have control flow start at the predicate" do
-          expect(subject.start_nodes).to eq([:predicate])
+          expect(subject.start_node).to eq(:predicate)
         end
 
         it "should have control flow end at the predicate and the consequence" do
@@ -23,15 +20,29 @@ module RDG
         end
       end
 
-      context "with one alternative" do
-        subject do
-          ast = double("ast")
-          allow(ast).to receive(:children) { [:predicate, :consequence, :alternative] }
-          If.new(ast, nil, nil)
+      context "without any consequence (i.e., the `parser` gem's representation of unless)" do
+        let(:ast) { FakeAst.new(:if, children: [:predicate, :"", :alternative]) }
+        subject { If.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 and the alternative" do
+          expect(subject.end_nodes).to eq([:predicate, :alternative])
         end
 
+        it "should have control flow edge between predicate and alternative" do
+          expect(subject.internal_flow_edges).to eq([[:predicate, :alternative]])
+        end
+      end
+
+      context "with one alternative" do
+        let(:ast) { FakeAst.new(:if, children: [:predicate, :consequence, :alternative]) }
+        subject { If.new(ast) }
+
         it "should have control flow start at the predicate" do
-          expect(subject.start_nodes).to eq([:predicate])
+          expect(subject.start_node).to eq(:predicate)
         end
 
         it "should have control flow end at the consequences" do
@@ -47,14 +58,11 @@ module RDG
       end
 
       context "with several alternatives" do
-        subject do
-          ast = double("ast")
-          allow(ast).to receive(:children) { [:predicate, :consequence, :a1, :a2, :a3] }
-          If.new(ast, nil, nil)
-        end
+        let(:ast) { FakeAst.new(:if, children: [:predicate, :consequence, :a1, :a2, :a3]) }
+        subject { If.new(ast) }
 
         it "should have control flow start at the predicate" do
-          expect(subject.start_nodes).to eq([:predicate])
+          expect(subject.start_node).to eq(:predicate)
         end
 
         it "should have control flow end at the consequences" do

data/spec/unit/control/jump_spec.rb

@@ -0,0 +1,43 @@
+require "rdg/control/jump"
+
+module RDG
+  module Control
+    describe Jump do
+      let(:graph) { spy("graph") }
+      let(:block_ast) { FakeAst.new(:while) }
+      let(:ast) { FakeAst.new(:thing, ancestors: [block_ast]) }
+
+      subject do
+        class DummyJump < Jump
+          def new_successors
+            %i(first_new_successor second_new_successor)
+          end
+        end
+
+        DummyJump.new(ast, graph)
+      end
+
+      it "should remove any edges to existing successors" do
+        allow(graph).to receive(:each_successor).and_yield(:successor)
+        subject.analyse
+
+        expect(graph).to have_received(:remove_edge).with(ast, :successor)
+      end
+
+      it "should add an edge from jump to each new successor" do
+        subject.analyse
+
+        expect(graph).to have_received(:add_edge).with(ast, :first_new_successor)
+        expect(graph).to have_received(:add_edge).with(ast, :second_new_successor)
+      end
+
+      it "should do nothing when not contained within a block" do
+        ast.ancestors = []
+        subject.analyse
+
+        expect(graph).not_to have_received(:add_edge)
+        expect(graph).not_to have_received(:remove_edge)
+      end
+    end
+  end
+end

data/spec/unit/control/jump_to_start_spec.rb

@@ -0,0 +1,22 @@
+require "rdg/control/jump_to_start"
+
+module RDG
+  module Control
+    describe JumpToStart do
+      let(:graph) { spy("graph") }
+      let(:equivalences) { spy("equivalences") }
+      let(:context) { Analysis::Context.new(graph, equivalences) }
+
+      let(:block_ast) { FakeAst.new(:while, children: [:jumpable]) }
+      let(:ast) { FakeAst.new(:thing, ancestors: [block_ast]) }
+
+      subject { JumpToStart.new(ast, context) }
+
+      it "should use equivalents of block's first child as new successors" do
+        allow(equivalences).to receive(:first).with(:jumpable).and_return(:new_successor)
+
+        expect(subject.new_successors).to eq([:new_successor])
+      end
+    end
+  end
+end

data/spec/unit/control/rescue_body_spec.rb

@@ -0,0 +1,26 @@
+require "rdg/control/rescue_body"
+
+module RDG
+  module Control
+    describe RescueBody do
+      let(:ast) { FakeAst.new(:resbody, children: [:ts, :e, 1, 2, 3]) }
+      subject { RescueBody.new(ast) }
+
+      it "should have control flow start at the first child" do
+        expect(subject.start_node).to eq(1)
+      end
+
+      it "should have control flow end at the last child" do
+        expect(subject.end_nodes).to eq([3])
+      end
+
+      it "should have control flow edges between each pair of children" do
+        expect(subject.internal_flow_edges).to eq([[1, 2], [2, 3]])
+      end
+
+      it "should have control flow nodes only for statements, and not for ex types or variable" do
+        expect(subject.nodes).to eq([1, 2, 3])
+      end
+    end
+  end
+end

data/spec/unit/control/rescue_spec.rb

@@ -0,0 +1,62 @@
+require "rdg/control/rescue"
+
+module RDG
+  module Control
+    describe Rescue do
+      let(:registry) { spy('registry') }
+      let(:context) { Analysis::Context.new(spy('graph'), spy('equivalences'), registry) }
+
+      let(:main_ast) { FakeAst.new(:if) }
+      let(:handler1) { FakeAst.new(:send) }
+      let(:handler2) { FakeAst.new(:raise) }
+
+      context "rescue without an else" do
+        let(:ast) { FakeAst.new(:rescue, children: [main_ast, handler1, handler2, :""]) }
+        subject { Rescue.new(ast, context) }
+
+        it "should have control flow start at the main block" do
+          expect(subject.start_node).to eq(main_ast)
+        end
+
+        it "should have control flow end at the main block and each fallback" do
+          expect(subject.end_nodes).to eq([main_ast, handler1, handler2])
+        end
+
+        it "should have no control flow edges (yet)" do
+          expect(subject.internal_flow_edges).to eq([])
+        end
+
+        it "should prepend Handler so that edges back to main_ast are created for each handler" do
+          subject.analyse
+
+          expect(registry).to have_received(:prepend_for).with(handler1, Handler)
+          expect(registry).to have_received(:prepend_for).with(handler2, Handler)
+        end
+      end
+
+      context "rescue with an else" do
+        let(:ast) { FakeAst.new(:rescue, children: [main_ast, handler1, handler2, :else]) }
+        subject { Rescue.new(ast, context) }
+
+        it "should have control flow start at the main block" do
+          expect(subject.start_node).to eq(main_ast)
+        end
+
+        it "should have control flow end at each fallback and the else" do
+          expect(subject.end_nodes).to eq([handler1, handler2, :else])
+        end
+
+        it "should have control flow from the main block to the else and nothing more (yet)" do
+          expect(subject.internal_flow_edges).to eq([[main_ast, :else]])
+        end
+
+        it "should prepend Handler so that edges back to main_ast are created for each handler" do
+          subject.analyse
+
+          expect(registry).to have_received(:prepend_for).with(handler1, Handler)
+          expect(registry).to have_received(:prepend_for).with(handler2, Handler)
+        end
+      end
+    end
+  end
+end

data/spec/unit/control/return_spec.rb

@@ -4,8 +4,7 @@ module RDG
   module Control
     describe Return do
       let(:graph) { spy("graph") }
-      let(:state) { { current_method: :do_important_stuff } }
-      subject { Return.new(:return, graph, state) }
+      subject { Return.new(:return, graph) }
 
       it "should remove existing edges out of return node" do
         allow(graph).to receive(:each_successor).and_yield(:successor)
@@ -14,14 +13,6 @@ module RDG
 
         expect(graph).to have_received(:remove_edge).with(:return, :successor)
       end
-
-      it "should do nothing if there is no current method" do
-        state.delete(:current_method)
-        subject.analyse
-
-        expect(graph).not_to have_received(:add_edge)
-        expect(graph).not_to have_received(:remove_edge)
-      end
     end
   end
 end

data/spec/unit/control/when_spec.rb

@@ -0,0 +1,59 @@
+require "rdg/control/when"
+
+module RDG
+  module Control
+    describe When do
+      let(:ast) { FakeAst.new(:when, children: [:test, :action]) }
+      let(:graph) { spy("graph") }
+      subject { When.new(ast, graph) }
+
+      context "two successors" do
+        before(:each) do
+          allow(graph).to receive(:each_successor).with(ast) { [:next_when, :successor] }
+        end
+
+        it "should have control flow start at the expression" do
+          expect(subject.start_node).to eq(:test)
+        end
+
+        it "should have control flow edge between test and action" do
+          expect(subject.internal_flow_edges).to eq([[:test, :action]])
+        end
+
+        it "should propagate outgoing flow from test to next when" do
+          subject.propogate_outgoing_flow
+          expect(graph).to have_received(:add_edge).with(:test, :next_when)
+        end
+
+        it "should propagate outgoing flow from action to successor" do
+          subject.propogate_outgoing_flow
+          expect(graph).to have_received(:add_edge).with(:action, :successor)
+        end
+      end
+
+      context "one successor" do
+        before(:each) do
+          allow(graph).to receive(:each_successor).with(ast) { [:successor] }
+        end
+
+        it "should have control flow start at the expression" do
+          expect(subject.start_node).to eq(:test)
+        end
+
+        it "should have control flow edge between test and action" do
+          expect(subject.internal_flow_edges).to eq([[:test, :action]])
+        end
+
+        it "should propagate outgoing flow from test to successor" do
+          subject.propogate_outgoing_flow
+          expect(graph).to have_received(:add_edge).with(:test, :successor)
+        end
+
+        it "should propagate outgoing flow from action to successor" do
+          subject.propogate_outgoing_flow
+          expect(graph).to have_received(:add_edge).with(:action, :successor)
+        end
+      end
+    end
+  end
+end

data/spec/unit/graph/bidirected_adjacency_graph_spec.rb

@@ -0,0 +1,49 @@
+require "rdg/graph/bidirected_adjacency_graph"
+
+module RDG
+  module Graph
+    describe BidirectedAdjacencyGraph do
+      subject do
+        BidirectedAdjacencyGraph[
+          :f, :b,  #       F
+          :b, :a,  #     /   \
+          :b, :d,  #    B    G
+          :d, :c,  #   / \  /  \
+          :d, :e,  #  A   D    I
+          :f, :g,  #     / \   /
+          :g, :i,  #    C  E  H
+          :i, :h,  #
+          :g, :d   # NB: edges are directed downwards
+        ]
+      end
+
+      context "successors" do
+        it "should yield a list of successors" do
+          expect { |block| subject.each_successor(:b, &block) }.to yield_successive_args(:a, :d)
+        end
+
+        it "should not yield for a leaf" do
+          expect { |block| subject.each_successor(:c, &block) }.not_to yield_control
+        end
+
+        it "should not yield for an unknown node" do
+          expect { |block| subject.each_successor(:unknown, &block) }.not_to yield_control
+        end
+      end
+
+      context "predecessors" do
+        it "should yield a list of predecessors" do
+          expect { |block| subject.each_predecessor(:d, &block) }.to yield_successive_args(:b, :g)
+        end
+
+        it "should not yield for a root" do
+          expect { |block| subject.each_predecessor(:f, &block) }.not_to yield_control
+        end
+
+        it "should not yield for an unknown node" do
+          expect { |block| subject.each_predecessor(:unknown, &block) }.not_to yield_control
+        end
+      end
+    end
+  end
+end