rdg 0.0.2 → 0.1.0

data/lib/rdg/control/break.rb

@@ -0,0 +1,19 @@
+require_relative "jump"
+
+module RDG
+  module Control
+    class Break < Jump
+      register_analyser :break
+
+      def new_successors
+        graph
+          .each_successor(test)
+          .reject { |s| s.ancestors.include?(block) }
+      end
+
+      def test
+        equivalences.first(block.children.first)
+      end
+    end
+  end
+end

data/lib/rdg/control/case.rb

@@ -0,0 +1,25 @@
+require "rdg/analysis/propagater"
+
+module RDG
+  module Control
+    class Case < Analysis::Propagater
+      register_analyser :case
+
+      def prepare
+        @expression, *@consequences = nodes
+      end
+
+      def internal_flow_edges
+        nodes.each_cons(2).to_a
+      end
+
+      def start_node
+        @expression
+      end
+
+      def end_nodes
+        @consequences
+      end
+    end
+  end
+end

data/lib/rdg/control/{while.rb → conditional_loop.rb}

@@ -1,10 +1,11 @@
-require_relative "analyser"
+require "rdg/analysis/propagater"
 
 module RDG
   module Control
-    class While < Analyser
-      def initialize(ast_node, graph, state)
-        super(ast_node, graph, state)
+    class ConditionalLoop < Analysis::Propagater
+      register_analyser :while, :until
+
+      def prepare
         @predicate, @body = children
       end
 
@@ -12,12 +13,12 @@ module RDG
         [[@predicate, @body], [@body, @predicate]]
       end
 
-      def start_nodes
-        [@predicate]
+      def start_node
+        @predicate
       end
 
       def end_nodes
-        [@body]
+        [@predicate]
       end
     end
   end

data/lib/rdg/control/def.rb

@@ -1,14 +1,28 @@
+require "rdg/analysis/propagater"
+
 module RDG
   module Control
-    class Def
-      def initialize(ast_node, graph, state)
-        @graph, @state = graph, state
-        @name, @args, @body = ast_node.children
+    class Def < Analysis::Propagater
+      register_analyser :def
+
+      def prepare
+        _name, _args, @body = children
+      end
+
+      def internal_flow_edges
+        []
+      end
+
+      def start_node
+        @body
+      end
+
+      def end_nodes
+        [@body]
       end
 
-      def analyse
-        @state[:current_method] = @name
-        @graph.add_edge(@name, @body)
+      def nodes
+        [@body]
       end
     end
   end

data/lib/rdg/control/ensure.rb

@@ -0,0 +1,30 @@
+require "rdg/analysis/propagater"
+
+module RDG
+  module Control
+    class Ensure < Analysis::Propagater
+      register_analyser :ensure
+
+      def prepare
+        @body, @finaliser = nodes
+      end
+
+      def analyse
+        super
+        registry.prepend_for(@finaliser, Handler)
+      end
+
+      def internal_flow_edges
+        [[@body, @finaliser]]
+      end
+
+      def start_node
+        @body
+      end
+
+      def end_nodes
+        [@finaliser]
+      end
+    end
+  end
+end

data/lib/rdg/control/for.rb

@@ -0,0 +1,29 @@
+require "rdg/analysis/propagater"
+
+module RDG
+  module Control
+    class For < Analysis::Propagater
+      register_analyser :for
+
+      def prepare
+        _, @iterable, @body = children
+      end
+
+      def internal_flow_edges
+        [[@iterable, @body], [@body, @iterable]]
+      end
+
+      def start_node
+        @iterable
+      end
+
+      def end_nodes
+        [@iterable]
+      end
+
+      def nodes
+        [@iterable, @body]
+      end
+    end
+  end
+end

data/lib/rdg/control/handler.rb

@@ -0,0 +1,25 @@
+require "rdg/analysis/analyser"
+
+module RDG
+  module Control
+    class Handler < Analysis::Analyser
+      def analyse
+        add_an_edge_from_every_main_node_to_the_handler
+      end
+
+      private
+
+      def add_an_edge_from_every_main_node_to_the_handler
+        main.each { |m| graph.add_edge(m, @ast_node) }
+      end
+
+      def main
+        equivalences.all(block.children.first)
+      end
+
+      def block
+        @ast_node.parent
+      end
+    end
+  end
+end

data/lib/rdg/control/if.rb

@@ -1,10 +1,11 @@
-require_relative "analyser"
+require "rdg/analysis/propagater"
 
 module RDG
   module Control
-    class If < Analyser
-      def initialize(ast_node, graph, state)
-        super(ast_node, graph, state)
+    class If < Analysis::Propagater
+      register_analyser :if
+
+      def prepare
         @predicate, *@consequences = children.reject(&:empty?)
       end
 
@@ -12,8 +13,8 @@ module RDG
         @consequences.map { |consequence| [@predicate, consequence] }
       end
 
-      def start_nodes
-        [@predicate]
+      def start_node
+        @predicate
       end
 
       def end_nodes

data/lib/rdg/control/jump.rb

@@ -0,0 +1,33 @@
+require "rdg/analysis/analyser"
+
+module RDG
+  module Control
+    class Jump < Analysis::Analyser
+      def analyse
+        return unless block
+        remove_all_successors
+        add_new_successors
+      end
+
+      protected
+
+      def block_types
+        %i(while until for)
+      end
+
+      private
+
+      def remove_all_successors
+        graph.each_successor(@ast_node) { |s| graph.remove_edge(@ast_node, s) }
+      end
+
+      def add_new_successors
+        new_successors.each { |s| graph.add_edge(@ast_node, s) }
+      end
+
+      def block
+        @ast_node.ancestors.detect { |a| block_types.include?(a.type) }
+      end
+    end
+  end
+end

data/lib/rdg/control/jump_to_start.rb

@@ -0,0 +1,11 @@
+require_relative "jump"
+
+module RDG
+  module Control
+    class JumpToStart < Jump
+      def new_successors
+        [equivalences.first(block.children.first)]
+      end
+    end
+  end
+end

data/lib/rdg/control/next.rb

@@ -0,0 +1,9 @@
+require_relative "jump_to_start"
+
+module RDG
+  module Control
+    class Next < JumpToStart
+      register_analyser :next
+    end
+  end
+end

data/lib/rdg/control/none.rb

@@ -1,10 +1,12 @@
+require "rdg/analysis/analyser"
+
 module RDG
   module Control
-    class None
-      def initialize(_ast_node, _graph, _state)
-      end
+    class None < Analysis::Analyser
+      register_default_analyser
 
       def analyse
+        # do nothing
       end
     end
   end

data/lib/rdg/control/redo.rb

@@ -0,0 +1,9 @@
+require_relative "jump_to_start"
+
+module RDG
+  module Control
+    class Redo < JumpToStart
+      register_analyser :redo
+    end
+  end
+end

data/lib/rdg/control/rescue.rb

@@ -0,0 +1,31 @@
+require "rdg/analysis/propagater"
+require_relative "handler"
+
+module RDG
+  module Control
+    class Rescue < Analysis::Propagater
+      register_analyser :rescue
+
+      def prepare
+        @main, *@handlers, @alternative = children
+      end
+
+      def analyse
+        super
+        @handlers.each { |h| registry.prepend_for(h, Handler) }
+      end
+
+      def internal_flow_edges
+        @alternative.empty? ? [] : [[@main, @alternative]]
+      end
+
+      def start_node
+        @main
+      end
+
+      def end_nodes
+        @alternative.empty? ? nodes : @handlers.push(@alternative)
+      end
+    end
+  end
+end

data/lib/rdg/control/rescue_body.rb

@@ -0,0 +1,29 @@
+require "rdg/analysis/propagater"
+
+module RDG
+  module Control
+    class RescueBody < Analysis::Propagater
+      register_analyser :resbody
+
+      def prepare
+        _exception_types, _variable_name, *@statements = children
+      end
+
+      def internal_flow_edges
+        @statements.each_cons(2).to_a
+      end
+
+      def start_node
+        @statements.first
+      end
+
+      def end_nodes
+        @statements.last(1)
+      end
+
+      def nodes
+        @statements
+      end
+    end
+  end
+end

data/lib/rdg/control/retry.rb

@@ -0,0 +1,13 @@
+require_relative "jump_to_start"
+
+module RDG
+  module Control
+    class Retry < JumpToStart
+      register_analyser :retry
+
+      def block_types
+        %i(rescue)
+      end
+    end
+  end
+end

data/lib/rdg/control/return.rb

@@ -1,13 +1,12 @@
+require "rdg/analysis/analyser"
+
 module RDG
   module Control
-    class Return
-      def initialize(ast_node, graph, state)
-        @graph, @ast_node, @state = graph, ast_node, state
-      end
+    class Return < Analysis::Analyser
+      register_analyser :return
 
       def analyse
-        return unless @state.key?(:current_method)
-        @graph.each_successor(@ast_node) { |s| @graph.remove_edge(@ast_node, s) }
+        graph.each_successor(@ast_node) { |s| graph.remove_edge(@ast_node, s) }
       end
     end
   end

data/lib/rdg/control/when.rb

@@ -0,0 +1,27 @@
+require "rdg/analysis/propagater"
+
+module RDG
+  module Control
+    class When < Analysis::Propagater
+      register_analyser :when
+
+      def prepare
+        @test, @action = children
+      end
+
+      def internal_flow_edges
+        [[@test, @action]]
+      end
+
+      def start_node
+        @test
+      end
+
+      def propogate_outgoing_flow
+        successors = graph.each_successor(@ast_node).to_a
+        graph.add_edge(@test, successors.first)
+        graph.add_edge(@action, successors.last)
+      end
+    end
+  end
+end

data/lib/rdg/graph/bidirected_adjacency_graph.rb

@@ -0,0 +1,19 @@
+require "rgl/adjacency"
+require "rgl/dot"
+require_relative "rgl/allow_duplicates"
+
+module RDG
+  module Graph
+    class BidirectedAdjacencyGraph < ::RGL::DirectedAdjacencyGraph
+      include RGL::AllowDuplicates
+
+      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