rdg 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b4773e86f8072218af847f45bb3fd7144b17280d
-  data.tar.gz: bc71864a750e80a115446322711ace2d9a36684c
+  metadata.gz: af60440c383c82705747bf477f53b83e1cad635f
+  data.tar.gz: e815153ed63da6c542a6da44175131ccce12e613
 SHA512:
-  metadata.gz: d6194df5a3f39aab8a8d3819e2ec310a24611c53fa15ffc947edf7fec96aa02fa8b5bbad142b84bb228011b1bc65086ddf9e55ac527ed752f9e08cc571073225
-  data.tar.gz: 35e161070ace8d798444f3c857328fde3c5eb785989d7182e1b06a56b0c6c124c3190e3cb6b7e3183ed4cc30d1e39507023d8d5d25ea7512346780d5c05a814a
+  metadata.gz: a3cf79483cbd687128ea25905ee796f50582f89c5e4d0d7d23a22cf12e22371f4de81d15a0c8ed01ee1d25335410ebdef64abd0253a776f95d574437f799f5d4
+  data.tar.gz: 2695d85dd9d28e27c51e91872ee595cf4febc8a16c09246ab08a5c4cb9d187eb9f10dd3cec6e5be22310e2416e0b5cdd6124267c67bcee9a50c619b0b40a031b

data/.gitignore

@@ -15,3 +15,5 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+sample*
+target*

data/.rspec

@@ -1,2 +1,3 @@
 --color
 --format progress
+--require spec_helper

data/.rubocop.yml

@@ -4,6 +4,8 @@ AllCops:
     - Rakefile
   Exclude:
     - vendor/*
+    - sample.rb
+    - target.rb
 
 StringLiterals:
   Enabled: false

data/bin/ast

@@ -2,7 +2,7 @@
 require_relative "../lib/rdg/tree/ast"
 
 if ARGV.size == 1
-  RDG::Tree::AST.from_path(ARGV[0]).write_to_graphic_file('png', ARGV[0])
+  RDG::Tree::AST.from_path(ARGV[0]).write_to_graphic_file('png', ARGV[0] + ".ast")
 else
   puts "ast: expected 1 argument but received #{ARGV.size}"
   puts "Usage:"

data/bin/cfg

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+require_relative "../lib/rdg/cfg"
+
+if ARGV.size == 1
+  RDG::CFG.from_path(ARGV[0]).write_to_graphic_file('png', ARGV[0] + ".cfg")
+else
+  puts "cfg: expected 1 argument but received #{ARGV.size}"
+  puts "Usage:"
+  puts "  cfg path/to/source.rb"
+end

data/lib/rdg/cfg.rb

@@ -0,0 +1,76 @@
+require_relative "tree/ast"
+require_relative "control/def"
+require_relative "control/begin"
+require_relative "control/if"
+require_relative "control/while"
+require_relative "control/return"
+require_relative "control/none"
+
+module RDG
+  class CFG
+    def self.from_path(path)
+      new(Tree::AST.from_path(path))
+    end
+
+    def self.from_source(source)
+      new(Tree::AST.from_source(source))
+    end
+
+    def initialize(ast)
+      @graph = BiDiDirectedAdjacencyGraph.new
+      analyse(ast)
+    end
+
+    def write_to_graphic_file(format = 'png', filename = "cfg")
+      @graph.write_to_graphic_file(format, filename)
+    end
+
+    def vertices
+      @graph.each_vertex.to_a
+    end
+
+    def successors(v)
+      @graph.each_adjacent(v).to_a
+    end
+
+    def has_edge?(u, v)
+      @graph.has_edge?(u, v)
+    end
+
+    private
+
+    def analyse(ast)
+      state = {}
+      ast.pre_order_iterator.select(&:compound?).each do |ast_node|
+        analyser_for(ast_node.type).new(ast_node, @graph, state).analyse
+      end
+    end
+
+    def analyser_for(ast_node_type)
+      case ast_node_type
+      when :def
+        Control::Def
+      when :begin, :kwbegin
+        Control::Begin
+      when :if
+        Control::If
+      when :while
+        Control::While
+      when :return
+        Control::Return
+      else
+        Control::None
+      end
+    end
+
+    class BiDiDirectedAdjacencyGraph < ::RGL::DirectedAdjacencyGraph
+      def each_predecessor(vertex, &block)
+        each_vertex.select { |v| each_adjacent(v).include?(vertex) }.each(&block)
+      end
+
+      def each_successor(vertex, &block)
+        each_adjacent(vertex, &block) if has_vertex?(vertex)
+      end
+    end
+  end
+end

data/lib/rdg/control/analyser.rb

@@ -0,0 +1,44 @@
+module RDG
+  module Control
+    class Analyser
+      def initialize(ast_node, graph, state)
+        @ast_node, @graph, @state = ast_node, graph, state
+      end
+
+      def analyse
+        add_internal_flow_edges
+        propogate_incoming_flow
+        propogate_outgoing_flow
+        remove_non_flow_vertices
+      end
+
+      private
+
+      def children
+        @ast_node.children
+      end
+
+      def add_internal_flow_edges
+        internal_flow_edges.each { |s, t| @graph.add_edge(s, t) }
+      end
+
+      def propogate_incoming_flow
+        @graph.each_predecessor(@ast_node) do |predecessor|
+          @graph.remove_edge(predecessor, @ast_node)
+          start_nodes.each { |n| @graph.add_edge(predecessor, n) }
+        end
+      end
+
+      def propogate_outgoing_flow
+        @graph.each_successor(@ast_node) do |successor|
+          @graph.remove_edge(@ast_node, successor)
+          end_nodes.each { |n| @graph.add_edge(n, successor) }
+        end
+      end
+
+      def remove_non_flow_vertices
+        @graph.remove_vertex(@ast_node)
+      end
+    end
+  end
+end

data/lib/rdg/control/begin.rb

@@ -0,0 +1,19 @@
+require_relative "analyser"
+
+module RDG
+  module Control
+    class Begin < Analyser
+      def internal_flow_edges
+        children.each_cons(2).to_a
+      end
+
+      def start_nodes
+        children.first(1)
+      end
+
+      def end_nodes
+        children.last(1)
+      end
+    end
+  end
+end

data/lib/rdg/control/def.rb

@@ -0,0 +1,15 @@
+module RDG
+  module Control
+    class Def
+      def initialize(ast_node, graph, state)
+        @graph, @state = graph, state
+        @name, @args, @body = ast_node.children
+      end
+
+      def analyse
+        @state[:current_method] = @name
+        @graph.add_edge(@name, @body)
+      end
+    end
+  end
+end

data/lib/rdg/control/if.rb

@@ -0,0 +1,28 @@
+require_relative "analyser"
+
+module RDG
+  module Control
+    class If < Analyser
+      def initialize(ast_node, graph, state)
+        super(ast_node, graph, state)
+        @predicate, *@consequences = children.reject(&:empty?)
+      end
+
+      def internal_flow_edges
+        @consequences.map { |consequence| [@predicate, consequence] }
+      end
+
+      def start_nodes
+        [@predicate]
+      end
+
+      def end_nodes
+        if @consequences.size == 1
+          [@predicate, @consequences.first]
+        else
+          @consequences
+        end
+      end
+    end
+  end
+end

data/lib/rdg/control/none.rb

@@ -0,0 +1,11 @@
+module RDG
+  module Control
+    class None
+      def initialize(_ast_node, _graph, _state)
+      end
+
+      def analyse
+      end
+    end
+  end
+end

data/lib/rdg/control/return.rb

@@ -0,0 +1,14 @@
+module RDG
+  module Control
+    class Return
+      def initialize(ast_node, graph, state)
+        @graph, @ast_node, @state = graph, ast_node, state
+      end
+
+      def analyse
+        return unless @state.key?(:current_method)
+        @graph.each_successor(@ast_node) { |s| @graph.remove_edge(@ast_node, s) }
+      end
+    end
+  end
+end

data/lib/rdg/control/while.rb

@@ -0,0 +1,24 @@
+require_relative "analyser"
+
+module RDG
+  module Control
+    class While < Analyser
+      def initialize(ast_node, graph, state)
+        super(ast_node, graph, state)
+        @predicate, @body = children
+      end
+
+      def internal_flow_edges
+        [[@predicate, @body], [@body, @predicate]]
+      end
+
+      def start_nodes
+        [@predicate]
+      end
+
+      def end_nodes
+        [@body]
+      end
+    end
+  end
+end

data/lib/rdg/tree/ast.rb

@@ -20,6 +20,10 @@ module RDG
         import(ast)
       end
 
+      def root
+        @graph.each_vertex.first
+      end
+
       def pre_order_iterator
         RGL::PreOrderIterator.new(@graph)
       end
@@ -35,30 +39,59 @@ module RDG
       private
 
       def import(ast)
-        Node.new(ast).tap do |current_node|
+        Node.new(ast, @graph).tap do |current_node|
           @graph.add_vertex(current_node)
 
-          current_node.children.each do |child|
-            @graph.add_edge(current_node, import(child))
+          if ast.respond_to?(:children)
+            ast.children.each do |child|
+              @graph.add_edge(current_node, import(child))
+            end
           end
         end
       end
 
       class Node
-        def initialize(wrapped)
+        attr_accessor :wrapped
+
+        def initialize(wrapped, graph)
           @wrapped = wrapped
+          @graph = graph
+        end
+
+        def compound?
+          wrapped.is_a?(Parser::AST::Node)
+        end
+
+        def scalar?
+          !compound?
+        end
+
+        def empty?
+          wrapped.nil?
+        end
+
+        def type
+          compound? ? wrapped.type : nil
         end
 
         def children
-          if @wrapped.is_a?(Parser::AST::Node)
-            @wrapped.children
+          @graph.each_adjacent(self).to_a
+        end
+
+        def ==(other)
+          if scalar?
+            wrapped == other.wrapped
           else
-            []
+            type == other.type && children == other.children
           end
         end
 
+        def inspect
+          to_s
+        end
+
         def to_s
-          @wrapped.to_s
+          wrapped.to_s
         end
       end
     end

data/lib/rdg/version.rb

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

data/spec/integration/cfg/if_spec.rb

@@ -0,0 +1,69 @@
+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
+        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
+
+      it "should show control flowing into predicate and through longer consequence" do
+        cfg = CFG.from_source("a = 1; if 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
+    end
+
+    context "for if expressions with several consequences" do
+      it "should show control flowing from predicate to (and out of) all consequences" do
+        cfg = CFG.from_source("a = 1; if 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
+
+      it "should show control flowing over each condition and its consequences" do
+        cfg = CFG.from_source("a = 1;" \
+                              "if b == 1 then; c = 1; elsif b == 2; d = 1; else; e = 1; end;" \
+                              "z = 1")
+
+        expect(cfg).to contain("a = 1", "b == 1", "c = 1", "b == 2", "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("b == 1", "b == 2")
+        expect(cfg).to flow_between("b == 2", "d = 1")
+        expect(cfg).to flow_between("b == 2", "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/methods_spec.rb

@@ -0,0 +1,39 @@
+require "rdg/cfg"
+
+module RDG
+  describe CFG do
+    context "for a simple method" do
+      it "should show control flowing from the method name to the body" do
+        cfg = CFG.from_source("def foo; a = 1; a = 2; end")
+        name, first, _ = cfg.vertices
+
+        expect(cfg.vertices.size).to eq(3)
+        expect(cfg.has_edge?(name, first)).to be_truthy
+      end
+    end
+
+    context "for a method containing an early return" do
+      before(:all) do
+        @cfg = CFG.from_source("def foo; a = 1; if a == 2; return; end; a = 2; end")
+        @name, @first, _, _, @ret = @cfg.vertices
+      end
+
+      it "should show control flowing from the method name to the body" do
+        expect(@cfg.has_edge?(@name, @first)).to be_truthy
+      end
+
+      it "should not show control flowing from return to successor" do
+        expect(@cfg.has_edge?(@ret, @second)).to be_falsey
+      end
+    end
+
+    context "return from no method" do
+      it "should do nothing" do
+        cfg = CFG.from_source("return")
+
+        puts cfg.vertices
+        expect(cfg.vertices.empty?).to be_truthy
+      end
+    end
+  end
+end

data/spec/integration/cfg/sequence_spec.rb

@@ -0,0 +1,40 @@
+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
+        cfg = CFG.from_source("a = 1")
+
+        expect(cfg).to contain("a = 1")
+      end
+
+      it "should show control flowing between children in order" do
+        cfg = CFG.from_source("a = 1; b = 2; c = 3")
+
+        expect(cfg).to contain("a = 1", "b = 2", "c = 3")
+
+        expect(cfg).to flow_between("a = 1", "b = 2")
+        expect(cfg).to flow_between("b = 2", "c = 3")
+      end
+
+      it "should show control flowing into the first child" do
+        cfg = CFG.from_source("a = 1; begin; b = 1; b = 2; end")
+
+        expect(cfg).to contain("a = 1", "b = 1", "b = 2")
+
+        expect(cfg).to flow_between("a = 1", "b = 1")
+        expect(cfg).to flow_between("b = 1", "b = 2")
+      end
+
+      it "should show control flowing out of the last child" do
+        cfg = CFG.from_source("begin; b = 1; b = 2; end; b = 3")
+
+        expect(cfg).to contain("b = 1", "b = 2", "b = 3")
+
+        expect(cfg).to flow_between("b = 1", "b = 2")
+        expect(cfg).to flow_between("b = 2", "b = 3")
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,8 @@
 require "codeclimate-test-reporter"
 CodeClimate::TestReporter.start
 
+Dir["./spec/support/**/*.rb"].each { |f| require f }
+
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
 # Require this file using `require "spec_helper"` to ensure that it is only
@@ -8,7 +10,6 @@ CodeClimate::TestReporter.start
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 

data/spec/support/matchers/contain_matcher.rb

@@ -0,0 +1,22 @@
+RSpec::Matchers.define :contain do |*sources|
+  match do |graph|
+    expected = expected_vertices(sources)
+    actual = graph.vertices
+
+    equivalent_ignoring_order(actual, expected)
+  end
+
+  failure_message do |graph|
+    "expected graph to contain the vertices #{expected_vertices(sources)} " \
+    "but got #{graph.vertices}"
+  end
+
+  def expected_vertices(sources)
+    sources.map { |s| RDG::Tree::AST.from_source(s).root }
+  end
+
+  def equivalent_ignoring_order(first_array, second_array)
+    first_array.size == second_array.size &&
+      first_array.all? { |e| second_array.include?(e) }
+  end
+end

data/spec/support/matchers/flow_between_matcher.rb

@@ -0,0 +1,18 @@
+RSpec::Matchers.define :flow_between do |source_of_start, source_of_end|
+  match do |graph|
+    graph.has_edge?(
+      find_vertex(graph, source_of_start),
+      find_vertex(graph, source_of_end)
+    )
+  end
+
+  failure_message do |graph|
+    "expected to find an edge from #{source_of_start} to #{source_of_end} " \
+    "but from #{source_of_start} the only edges are: " \
+    "#{graph.successors(find_vertex(graph, source_of_start))}"
+  end
+
+  def find_vertex(graph, source)
+    graph.vertices.detect { |v| v == RDG::Tree::AST.from_source(source).root }
+  end
+end

data/spec/unit/control/analyser_spec.rb

@@ -0,0 +1,61 @@
+require "rdg/control/analyser"
+
+module RDG
+  module Control
+    describe Analyser do
+      let(:ast) { double("ast") }
+      let(:graph) { spy("graph") }
+
+      subject do
+        class DummyAnalyser < Analyser
+          def internal_flow_edges
+            [[:s1, :e1], [:s2, :e2]]
+          end
+
+          def start_nodes
+            [:s1, :s2]
+          end
+
+          def end_nodes
+            [:e1, :e2]
+          end
+        end
+
+        DummyAnalyser.new(ast, graph, nil)
+      end
+
+      it "should add a CFG edge for every internal flow edge" do
+        subject.analyse
+
+        expect(graph).to have_received(:add_edge).with(:s1, :e1)
+        expect(graph).to have_received(:add_edge).with(:s2, :e2)
+      end
+
+      it "should move any incoming edges to start nodes" 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
+        allow(graph).to receive(:each_successor).and_yield(:successor)
+
+        subject.analyse
+
+        expect(graph).to have_received(:remove_edge).with(ast, :successor)
+        expect(graph).to have_received(:add_edge).with(:e1, :successor)
+        expect(graph).to have_received(:add_edge).with(:e2, :successor)
+      end
+
+      it "should remove the AST node from the CFG" do
+        subject.analyse
+
+        expect(graph).to have_received(:remove_vertex).with(ast)
+      end
+    end
+  end
+end

data/spec/unit/control/begin_spec.rb

@@ -0,0 +1,25 @@
+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
+
+      it "should have control flow start at the first child" do
+        expect(subject.start_nodes).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
+    end
+  end
+end

data/spec/unit/control/def_spec.rb

@@ -0,0 +1,28 @@
+require "rdg/control/def"
+
+module RDG
+  module Control
+    describe Def do
+      let(:state) { Hash.new }
+      let(:graph) { spy("graph") }
+      subject do
+        ast = double("ast")
+        allow(ast).to receive(:children) { [:name, :args, :body] }
+        Def.new(ast, graph, state)
+      end
+
+      it "should have control flow from name to body" do
+        subject.analyse
+
+        expect(graph).to have_received(:add_edge).with(:name, :body)
+        expect(graph).to have_received(:add_edge).once
+      end
+
+      it "should have updated state with name node" do
+        subject.analyse
+
+        expect(state[:current_method]).to eq(:name)
+      end
+    end
+  end
+end

data/spec/unit/control/if_spec.rb

@@ -0,0 +1,75 @@
+require "rdg/control/if"
+
+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
+
+        it "should have control flow start at the predicate" do
+          expect(subject.start_nodes).to eq([:predicate])
+        end
+
+        it "should have control flow end at the predicate and the consequence" do
+          expect(subject.end_nodes).to eq([:predicate, :consequence])
+        end
+
+        it "should have control flow edge between predicate and consequence" do
+          expect(subject.internal_flow_edges).to eq([[:predicate, :consequence]])
+        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)
+        end
+
+        it "should have control flow start at the predicate" do
+          expect(subject.start_nodes).to eq([:predicate])
+        end
+
+        it "should have control flow end at the consequences" do
+          expect(subject.end_nodes).to eq([:consequence, :alternative])
+        end
+
+        it "should have control flow edge between predicate and consequences" do
+          expect(subject.internal_flow_edges).to eq([
+            [:predicate, :consequence],
+            [:predicate, :alternative]
+          ])
+        end
+      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
+
+        it "should have control flow start at the predicate" do
+          expect(subject.start_nodes).to eq([:predicate])
+        end
+
+        it "should have control flow end at the consequences" do
+          expect(subject.end_nodes).to eq([:consequence, :a1, :a2, :a3])
+        end
+
+        it "should have control flow edge between predicate and all consequences" do
+          expect(subject.internal_flow_edges).to eq([
+            [:predicate, :consequence],
+            [:predicate, :a1],
+            [:predicate, :a2],
+            [:predicate, :a3]
+          ])
+        end
+      end
+    end
+  end
+end

data/spec/unit/control/return_spec.rb

@@ -0,0 +1,27 @@
+require "rdg/control/return"
+
+module RDG
+  module Control
+    describe Return do
+      let(:graph) { spy("graph") }
+      let(:state) { { current_method: :do_important_stuff } }
+      subject { Return.new(:return, graph, state) }
+
+      it "should remove existing edges out of return node" do
+        allow(graph).to receive(:each_successor).and_yield(:successor)
+
+        subject.analyse
+
+        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/while_spec.rb

@@ -0,0 +1,25 @@
+require "rdg/control/while"
+
+module RDG
+  module Control
+    describe While do
+      subject do
+        ast = double("ast")
+        allow(ast).to receive(:children) { [:predicate, :body] }
+        While.new(ast, nil, nil)
+      end
+
+      it "should have control flow start at the predicate" do
+        expect(subject.start_nodes).to eq([:predicate])
+      end
+
+      it "should have control flow end at the body" do
+        expect(subject.end_nodes).to eq([:body])
+      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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rdg
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Louis Rose
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-12 00:00:00.000000000 Z
+date: 2015-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -114,6 +114,7 @@ email:
 - louis.rose@york.ac.uk
 executables:
 - ast
+- cfg
 extensions: []
 extra_rdoc_files: []
 files:
@@ -126,12 +127,32 @@ files:
 - README.md
 - Rakefile
 - bin/ast
+- bin/cfg
+- lib/rdg/cfg.rb
+- lib/rdg/control/analyser.rb
+- lib/rdg/control/begin.rb
+- lib/rdg/control/def.rb
+- lib/rdg/control/if.rb
+- lib/rdg/control/none.rb
+- lib/rdg/control/return.rb
+- lib/rdg/control/while.rb
 - lib/rdg/tree/ast.rb
 - lib/rdg/tree/rgl/post_order_iterator.rb
 - lib/rdg/tree/rgl/pre_order_iterator.rb
 - lib/rdg/version.rb
 - rdg.gemspec
+- spec/integration/cfg/if_spec.rb
+- spec/integration/cfg/methods_spec.rb
+- spec/integration/cfg/sequence_spec.rb
 - spec/spec_helper.rb
+- spec/support/matchers/contain_matcher.rb
+- spec/support/matchers/flow_between_matcher.rb
+- spec/unit/control/analyser_spec.rb
+- spec/unit/control/begin_spec.rb
+- spec/unit/control/def_spec.rb
+- spec/unit/control/if_spec.rb
+- spec/unit/control/return_spec.rb
+- spec/unit/control/while_spec.rb
 - spec/unit/tree/ast_spec.rb
 - spec/unit/tree/rgl/post_order_iterator_spec.rb
 - spec/unit/tree/rgl/pre_order_iterator_spec.rb
@@ -160,7 +181,18 @@ signing_key:
 specification_version: 4
 summary: Dependency analysis for Ruby programs
 test_files:
+- spec/integration/cfg/if_spec.rb
+- spec/integration/cfg/methods_spec.rb
+- spec/integration/cfg/sequence_spec.rb
 - spec/spec_helper.rb
+- spec/support/matchers/contain_matcher.rb
+- spec/support/matchers/flow_between_matcher.rb
+- spec/unit/control/analyser_spec.rb
+- spec/unit/control/begin_spec.rb
+- spec/unit/control/def_spec.rb
+- spec/unit/control/if_spec.rb
+- spec/unit/control/return_spec.rb
+- spec/unit/control/while_spec.rb
 - spec/unit/tree/ast_spec.rb
 - spec/unit/tree/rgl/post_order_iterator_spec.rb
 - spec/unit/tree/rgl/pre_order_iterator_spec.rb