rdg 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af60440c383c82705747bf477f53b83e1cad635f
-  data.tar.gz: e815153ed63da6c542a6da44175131ccce12e613
+  metadata.gz: 3267ca615757cdfe8bb5552efafc08f53ce883c7
+  data.tar.gz: e91b39981bfb05cb0737e372c05d26f18cedf738
 SHA512:
-  metadata.gz: a3cf79483cbd687128ea25905ee796f50582f89c5e4d0d7d23a22cf12e22371f4de81d15a0c8ed01ee1d25335410ebdef64abd0253a776f95d574437f799f5d4
-  data.tar.gz: 2695d85dd9d28e27c51e91872ee595cf4febc8a16c09246ab08a5c4cb9d187eb9f10dd3cec6e5be22310e2416e0b5cdd6124267c67bcee9a50c619b0b40a031b
+  metadata.gz: bdd71c1d0de2ce1f8f6223177a690fe5f91d70b0a23bbd469af41b4a236ff0a4636ff85d6eae3fd60219f570f9dd036d728d07fe78c3a348aa3fbad7ba13bbd2
+  data.tar.gz: 819759b62d7dd041329595424b654b8772310ac086ad732664bb1bcb64c3a5f50d39f767bf5d17fbffdbd24a428e49863e85947f4abe2c19744ee02f02157ad7

data/.rubocop.yml

@@ -15,3 +15,6 @@ LineLength:
 
 Documentation:
   Enabled: false
+
+Style/TrivialAccessors:
+  ExactNameMatch: true

data/.ruby-version

@@ -0,0 +1 @@
+2.2.2

data/.travis.yml

@@ -1,8 +1,8 @@
 language: ruby
 rvm:
-  - 2.2.0
+  - 2.2.2
 before_install:
   - gem update bundler
 addons:
   code_climate:
-    repo_token: 437cae623819bbf323bd0dbc9e2b857149c9f725841f3825ca55e09f564d8e0a
+    repo_token: 437cae623819bbf323bd0dbc9e2b857149c9f725841f3825ca55e09f564d8e0a

data/Gemfile

@@ -1,4 +1,4 @@
-ruby "2.2.0"
+ruby "2.2.2"
 source "https://rubygems.org"
 
 # Specify your gem's dependencies in rdg.gemspec

data/RELEASES.md

@@ -0,0 +1,10 @@
+# Release History
+
+## v0.1.0 (April 2015)
+* Complete implementation of intra-procedural control flow graphs.
+
+## v0.0.2 (March 2015)
+* Provide initial partial implementation of intra-procedural control flow graphs.
+
+## v0.0.1 (February 2015)
+* Provide basic support for importing abstract syntax trees and iterating over them.

data/TODO.md

@@ -0,0 +1,68 @@
+## Control Flow Graphs
+
+### Basics
+- [x] `begin` ... `end`
+- [x] `def` ... `end`
+
+### Conditionals
+
+#### `if` expressions
+- [x] no `else`
+- [x] `else`
+- [x] `elsif`
+- [x] ternary `a ? b : c`
+- [x] expression modifier `if`
+
+#### `unless` expressions
+- [x] no else
+- [x] else
+- [x] expression modifier `unless`
+
+#### `case` expressions
+- [x] single when
+- [x] else
+- [x] several when
+
+### Loops
+
+#### Looping expressions
+- [x] `while`
+- [x] `until`
+- [x] `for`
+- [x] `while` and `until` as modifiers
+
+#### Skipping
+- [x] `break`
+- [x] `next`
+- [x] `redo`
+
+### Exceptions
+- [x] `begin` / `rescue`
+- [x] def / `rescue`
+- [x] multiple `rescues`
+- [x] `retry`
+- [x] `ensure` part
+- [x] `ensure` part with rescues
+- [x] `ensure` part with rescues and else
+- [x] `else` part
+
+Exception control flow might be neater if there was some notion of hierarchy in the CFG. Right now, every statement within the rescuable block has a control flow edge to each of the exception handlers. It would be neater to have a single control flow edge from some kind of "parent" node which contains each of the statements in the rescuable block.
+
+### Blocks
+
+Not too sure how to approach this yet.
+
+It might be reasonable to assume that any method that takes a block could cause control to flow into that block. If we have the source for that method, we could also check for yield or a call before adding this control flow edge.
+
+No matter what, blocks support the same skipping constructs as loops:
+
+- [ ] `break`
+- [ ] `next`
+- [ ] `redo`
+
+## Inter-method Control Flow Graphs
+
+- [ ] `return` expressions
+- [ ] direct method invocations
+- [ ] method invocations via `send` ?
+- [ ] ensure control flow edges from a method invocation to a block only added when callee yields to block

data/bin/ast

@@ -1,10 +1,11 @@
 #!/usr/bin/env ruby
 require_relative "../lib/rdg/tree/ast"
 
-if ARGV.size == 1
-  RDG::Tree::AST.from_path(ARGV[0]).write_to_graphic_file('png', ARGV[0] + ".ast")
+if ARGV.size == 1 || ARGV.size == 2
+  image_format = ARGV.size == 2 ? ARGV[1] : 'pdf'
+  RDG::Tree::AST.from_path(ARGV[0]).write_to_graphic_file(image_format, ARGV[0] + ".ast")
 else
-  puts "ast: expected 1 argument but received #{ARGV.size}"
+  puts "ast: expected 1 or 2 arguments but received #{ARGV.size}"
   puts "Usage:"
-  puts "  ast path/to/source.rb"
+  puts "  ast path/to/source.rb [image_format]"
 end

data/bin/cfg

@@ -1,10 +1,11 @@
 #!/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")
+if ARGV.size == 1 || ARGV.size == 2
+  image_format = ARGV.size == 2 ? ARGV[1] : 'pdf'
+  RDG::CFG.from_path(ARGV[0]).write_to_graphic_file(image_format, ARGV[0] + ".cfg")
 else
-  puts "cfg: expected 1 argument but received #{ARGV.size}"
+  puts "cfg: expected 1 or 2 arguments but received #{ARGV.size}"
   puts "Usage:"
-  puts "  cfg path/to/source.rb"
+  puts "  cfg path/to/source.rb [image_format]"
 end

data/lib/rdg/analysis/analyser.rb

@@ -0,0 +1,30 @@
+require_relative "context"
+require_relative "registry"
+
+module RDG
+  module Analysis
+    class Analyser
+      extend Forwardable
+      def_delegators :@context, :graph, :equivalences, :registry
+
+      def self.register_analyser(*types)
+        Registry.register_by_type(self, *types)
+      end
+
+      def self.register_default_analyser
+        Registry.register_default(self)
+      end
+
+      def initialize(ast_node, context = Context.new)
+        @ast_node, @context = ast_node, context
+        prepare
+      end
+
+      private
+
+      def prepare
+        # do nothing
+      end
+    end
+  end
+end

data/lib/rdg/analysis/composite.rb

@@ -0,0 +1,23 @@
+require_relative "analyser"
+
+module RDG
+  module Analysis
+    class Composite < Analyser
+      def self.compose(*ts)
+        Class.new(Composite) do
+          define_method :types do
+            ts
+          end
+        end
+      end
+
+      def initialize(ast_node, context = Context.new)
+        @delegates = types.map { |t| t.new(ast_node, context) }
+      end
+
+      def analyse
+        @delegates.each(&:analyse)
+      end
+    end
+  end
+end

data/lib/rdg/analysis/context.rb

@@ -0,0 +1,17 @@
+require_relative "../graph/bidirected_adjacency_graph"
+require_relative "equivalences"
+require_relative "registry"
+
+module RDG
+  module Analysis
+    class Context
+      attr_reader :graph, :equivalences, :registry
+
+      def initialize(graph = nil, equivalences = nil, registry = nil)
+        @graph = graph || Graph::BidirectedAdjacencyGraph.new
+        @equivalences = equivalences || Equivalences.new
+        @registry = registry || Registry.new
+      end
+    end
+  end
+end

data/lib/rdg/analysis/equivalences.rb

@@ -0,0 +1,25 @@
+module RDG
+  module Analysis
+    class Equivalences
+      def initialize
+        @equivalences = {}
+      end
+
+      def add(original, results)
+        @equivalences[original] = results
+      end
+
+      def all(original)
+        if @equivalences.key?(original)
+          @equivalences[original].map { |e| all(e) }.flatten
+        else
+          [original]
+        end
+      end
+
+      def first(original)
+        all(original).first
+      end
+    end
+  end
+end

data/lib/rdg/analysis/propagater.rb

@@ -0,0 +1,51 @@
+require_relative "analyser"
+
+module RDG
+  module Analysis
+    class Propagater < Analyser
+      def analyse
+        add_internal_flow_edges
+        propogate_incoming_flow
+        propogate_outgoing_flow
+        remove_non_flow_vertices
+        add_equivalences
+      end
+
+      private
+
+      def children
+        @ast_node.children
+      end
+
+      def nodes
+        children.reject(&:empty?)
+      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)
+          graph.add_edge(predecessor, start_node)
+        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
+
+      def add_equivalences
+        equivalences.add(@ast_node, nodes)
+      end
+    end
+  end
+end

data/lib/rdg/analysis/registry.rb

@@ -0,0 +1,35 @@
+module RDG
+  module Analysis
+    class Registry
+      def self.register_by_type(analyser, *types)
+        types.each { |type| by_type[type] = analyser }
+      end
+
+      def self.register_default(analyser)
+        by_type.default = analyser
+      end
+
+      def self.clear
+        by_type.clear
+      end
+
+      def analyser_for(ast_node, context)
+        by_node[ast_node].new(ast_node, context)
+      end
+
+      def prepend_for(ast_node, analyser)
+        by_node[ast_node] = Composite.compose(analyser, by_node[ast_node])
+      end
+
+      private
+
+      def self.by_type
+        @by_type ||= {}
+      end
+
+      def by_node
+        @by_node ||= Hash.new { |h, node| h[node] = Registry.by_type[node.type] }
+      end
+    end
+  end
+end

data/lib/rdg/cfg.rb

@@ -1,10 +1,8 @@
+require "require_all"
+
 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"
+require_rel "analysis/*"
+require_rel "control/*"
 
 module RDG
   class CFG
@@ -17,59 +15,32 @@ module RDG
     end
 
     def initialize(ast)
-      @graph = BiDiDirectedAdjacencyGraph.new
+      @context = Analysis::Context.new
+      @context.graph.add_vertex(ast.root)
       analyse(ast)
     end
 
     def write_to_graphic_file(format = 'png', filename = "cfg")
-      @graph.write_to_graphic_file(format, filename)
+      @context.graph.write_to_graphic_file(format, filename)
     end
 
     def vertices
-      @graph.each_vertex.to_a
+      @context.graph.each_vertex.to_a
     end
 
     def successors(v)
-      @graph.each_adjacent(v).to_a
+      @context.graph.each_adjacent(v).to_a
     end
 
-    def has_edge?(u, v)
-      @graph.has_edge?(u, v)
+    def edge?(u, v)
+      @context.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)
+        @context.registry.analyser_for(ast_node, @context).analyse
       end
     end
   end

data/lib/rdg/control/begin.rb

@@ -1,14 +1,16 @@
-require_relative "analyser"
+require "rdg/analysis/propagater"
 
 module RDG
   module Control
-    class Begin < Analyser
+    class Begin < Analysis::Propagater
+      register_analyser :begin, :kwbegin
+
       def internal_flow_edges
         children.each_cons(2).to_a
       end
 
-      def start_nodes
-        children.first(1)
+      def start_node
+        children.first
       end
 
       def end_nodes