visualize_ruby 0.8.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 065c1db111e1a4716755a68ff69bce287b3192d4939f86cd2913d67ff8aaa0ad
-  data.tar.gz: 3440f90a823b7fe3c4a1b236f39948a237ecc645ca0e86fcf7cf5b82ea78d864
+  metadata.gz: d233d2d1af5c3e092d04d497fddfc4c7165d56dbd021662cd58703d04ada8ce4
+  data.tar.gz: f60ac523929e8ae331ef4af3811ed600a4aa380ca9738d3bcdb72a6377f60097
 SHA512:
-  metadata.gz: 8179f8b332606875a3fde94e873abee27aa5eb3edb68a3d210a9eef522ba6431013d83be06d77061a31f58eca6d032404d67529b8537c96e9898f8cff6d8d0c3
-  data.tar.gz: be6299a6bbcf6f6e61e552f050a78ee8710190b4eb4afcbdf0a329bea2ef320cb33aa67ce4b27ed6db0c7532c68f724ae50346f05e1a3ed65da27ecb4754070a
+  metadata.gz: c46c248303e7d46e42ea47ddf2928baedfaa58cb12e6e2ed1b0f95b2f85df677d921278abac0a50bef8d13fdd820005a833866d9df1b6c87044fadab67eb79f4
+  data.tar.gz: 515f8cc61f5ecc2944402106db9707a365c35ad2a343811fd02ef7acd63b365aa27de36c339df308220221ae7bf80aacfedbe91517e298fde4d7da8f00a480d4

data/CHANGELOG.md

@@ -1,6 +1,23 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## 0.11.0 - 2018-07-26
+### Enhancement
+* Improved highlights execution path on flow chart. It using ruby code file or string to build the graph then a file or string of calling code.
+* Better display blocks without arguments.
+* Added DSL for graphing and tracing code.
+
+## 0.10.0 - 2018-07-20
+### Enhancement
+* Highlights execution path on flow chart. It using ruby code file or string to build the graph then a file or string of calling code.
+
+## 0.9.0 - 2018-07-17
+### Enhancement
+* Properly render Messy code, gilded Rose as example https://github.com/amckinnell/Gilded-Rose-Ruby/blob/master/lib/gilded_rose.rb
+* Conditions with no else statement have an edge to an END node.
+* All nodes have unique IDs based on source location. 
+Nodes can be merged based on there label with VisualizeRuby::Graphviz(graphs, label, unique_nodes: false)
+
 ## 0.8.0 - 2018-07-17
 ### Enhancement
 * Better handle conditions outside of if statements.

data/README.md

@@ -1,6 +1,6 @@
 # VisualizeRuby
 
-Write a Ruby class and see method interactions. Works with procedural code and bare methods.</span>
+Write a Ruby code and see method interactions on a flow chart. Works with procedural code, bare methods, and Classes.
 This is experimental project and does not support all types of code. 
 If you'd like it to support more types of code please pull request.
 
@@ -21,13 +21,25 @@ And then execute:
 Or install it yourself as:
 
     $ gem install visualize_ruby
+    
+### Install GraphViz
+
+ MacOS
+
+    $ brew install graphviz
+    
+ Linux
+    
+    $ sudo apt-get install graphviz
 
 ## Usage
 
+### Create a graph by statically parsing the code. 
+
 ```ruby
 require "visualize_ruby"
 
-ruby_code = <<-RUBY
+ruby_code = <<~RUBY
   if hungry?
     eat
   else
@@ -36,8 +48,83 @@ ruby_code = <<-RUBY
 RUBY
 
 results = VisualizeRuby::Builder.new(ruby_code: ruby_code).build
-VisualizeRuby::Graphviz.new(*results).to_graph(path: "example.png")
+VisualizeRuby::Graphviz.new(results).to_graph(path: "example.png")
+```
+[![graph](./spec/examples/base_method.png)](./spec/examples/base_method.png)
+### Add an execution path to graph
+```ruby
+require "visualize_ruby"
+
+ruby_code = <<~RUBY
+  class Worker
+    def initialize(hungry:)
+      @hungry = hungry
+    end
+
+    def next_action
+      if hungry?
+        :eat
+      else
+        :work
+      end
+    end
+
+    def hungry?
+      @hungry
+    end
+  end
+RUBY
+
+calling_code = <<~RUBY
+  Worker.new(hungry: true).next_action
+RUBY
+
+VisualizeRuby.new do |vb|
+  vb.ruby_code = ruby_code # String, IO
+  vb.trace(calling_code)  # String, IO - optional
+  vb.output_path = "runner_trace.png" # file name with media extension.
+end
 ```
+[![graph](./spec/examples/runner_trace.png)](./spec/examples/runner_trace.png)
+
+### Visualize Loops
+Adds a count if the node is called more than once.
+
+```ruby
+require "visualize_ruby"
+
+ruby_code = <<~RUBY
+  class Looping
+    def call
+      (0..5).each do
+        paint_town!
+      end
+    end
+
+    def paint_town!
+      "hello"
+    end
+  end
+RUBY
+
+calling_code = <<~RUBY
+  Worker.new(hungry: true).next_action
+RUBY
+
+VisualizeRuby.new do |vb|
+  vb.ruby_code = ruby_code # String, IO
+  vb.trace(calling_code)  # String, IO - optional
+  vb.output_path = "loop.png" # file name with media extension.
+end
+```
+
+[![graph](./spec/examples/highlight_tracer_loop.png)](./spec/examples/highlight_tracer_loop.png)
+
+### Complex unrefactored code example
+[Gilded Rose](https://github.com/amckinnell/Gilded-Rose-Ruby)
+
+[![graph](./spec/examples/gilded_rose.png)](./spec/examples/gilded_rose.png)
+
 
 ## Development
 

data/lib/visualize_ruby/ast_helper.rb

@@ -0,0 +1,21 @@
+module VisualizeRuby
+  class AstHelper
+    def initialize(ast)
+      @ast = ast
+    end
+
+    def description
+      return @ast unless @ast.respond_to?(:type)
+      Unparser.unparse(@ast)
+    end
+
+    def id(description: self.description)
+      description.to_s + " L#{[@ast.location.first_line, @ast.location.last_line].compact.uniq.join("-")}"
+    end
+
+    def first_line
+      return unless @ast
+      @ast.location.first_line
+    end
+  end
+end

data/lib/visualize_ruby/builder.rb

@@ -1,22 +1,55 @@
 require "dissociated_introspection"
+require "stringio"
+require "tempfile"
 
 module VisualizeRuby
   class Builder
-
+    # @param [String, IO] ruby_code
     def initialize(ruby_code:)
-      @ruby_code = ruby_code
+      @ruby_code = ruby_code.is_a?(String) ? StringIO.new(ruby_code) : ruby_code
     end
 
     def build
-      ruby_code  = DissociatedIntrospection::RubyCode.build_from_source(@ruby_code)
+      ruby_code  = DissociatedIntrospection::RubyCode.build_from_source(@ruby_code.read)
       ruby_class = DissociatedIntrospection::RubyClass.new(ruby_code)
 
       if ruby_class.class?
-        [build_from_class(ruby_class), { label: ruby_class.class_name }]
+        Result.new(
+            ruby_code: ruby_class.ruby_code.source,
+            ast:       ruby_code.ast,
+            graphs:    build_from_class(ruby_class),
+            options:   { label: ruby_class.class_name }
+        )
       elsif bare_methods?(ruby_code)
-        wrap_bare_methods(ruby_code)
+        Result.new(
+            ruby_code: @ruby_code,
+            ast:       ruby_code.ast,
+            graphs:    wrap_bare_methods(ruby_code)
+        )
       else
-        Graph.new(ruby_code: @ruby_code)
+        Result.new(
+            ruby_code: @ruby_code,
+            ast:       ruby_code.ast,
+            graphs:    [Graph.new(ast: ruby_code.ast)]
+        )
+      end
+    end
+
+    class Result
+      # @return [Array<VisualizeRuby::Graph>]
+      attr_reader :graphs
+      # @return [Hash{Symbol => Object}]
+      attr_reader :options
+      # @return [IO]
+      attr_reader :ruby_code
+      # @return [Parser:AST]
+      attr_reader :ast
+
+      def initialize(ruby_code:, graphs:, options: {}, ast:)
+        @ruby_code = ruby_code
+        @graphs    = graphs
+        @options   = options
+        @ast       = ast
       end
     end
 
@@ -28,11 +61,22 @@ module VisualizeRuby
       graphs.each do |graph|
         graphs.each do |sub_graph|
           sub_graph.nodes.each do |node|
-            sub_graph.edges << Edge.new(
-                nodes: [node, graph.nodes.first],
-                dir:   :none,
-                style: :dashed
-            ) if node.name == graph.name
+            if node.name == graph.name
+              found = sub_graph.edges.select do |e|
+                e.node_a == node
+              end
+              found.first
+
+              graph_edge = Edge.new(
+                  nodes:   [node, graph.nodes.first],
+                  style:   :dashed, # indicate method call
+              )
+              sub_graph.edges.insert(sub_graph.edges.index(found.first) || -1, graph_edge)
+              found.each do |edge|
+                edge.options(style: :dashed) # indicate method call
+                edge.nodes[0] = graph.nodes.first
+              end
+            end
           end
         end
       end
@@ -40,15 +84,25 @@ module VisualizeRuby
       graphs
     end
 
+    def edge_search(a: nil, b: nil, edges:)
+      edges.select do |e|
+        e.node_a == a || e.node_b == b
+      end
+    end
+
     def build_graphs_by_method(ruby_class)
-     ruby_class.defs.map do |meth|
-        Graph.new(ruby_code: meth.body, name: meth.name)
+      ruby_class.defs.map do |meth|
+        Graph.new(
+            ruby_code: meth.body,
+            name:      meth.name,
+            ast:       meth.send(:ruby_code).ast.children[2] # method body ast
+        )
       end
     end
 
     def bare_methods?(ruby_code)
       ruby_code.ast.type == :def ||
-      ruby_code.ast.type == :begin && ruby_code.ast.children.map(&:type).uniq == [:def]
+          ruby_code.ast.type == :begin && ruby_code.ast.children.map(&:type).uniq == [:def]
     end
 
     def wrap_bare_methods(ruby_code)
@@ -57,8 +111,8 @@ module VisualizeRuby
           #{ruby_code.source}
         end
       Ruby
-      di_ruby_code  = DissociatedIntrospection::RubyCode.build_from_source(wrapped_ruby_code)
-      ruby_class = DissociatedIntrospection::RubyClass.new(di_ruby_code)
+      di_ruby_code = DissociatedIntrospection::RubyCode.build_from_source(wrapped_ruby_code)
+      ruby_class   = DissociatedIntrospection::RubyClass.new(di_ruby_code)
       build_from_class(ruby_class)
     end
   end

data/lib/visualize_ruby/edge.rb

@@ -1,19 +1,31 @@
 module VisualizeRuby
   class Edge
-    attr_reader :name,
-                :node_a,
-                :node_b,
+    include Touchable
+    include Optionalable
+    attr_reader :nodes,
                 :dir,
-                :style,
-                :color
+                :style
 
-    def initialize(name: nil, nodes:, dir: :forward, style: :solid, color: nil)
-      @name   = name.to_s if name
-      @node_a = nodes[0]
-      @node_b = nodes[1]
-      @dir    = dir
-      @style  = style
-      @color  = color
+    attr_accessor :color,
+                  :display
+
+    def initialize(name: nil, nodes:, dir: :forward, type: :default, display: :visual, **opts)
+      @name    = name.to_s if name
+      @nodes   = nodes
+      @dir     = dir
+      @style   = style
+      @color   = color
+      @type    = type
+      @display = display
+      post_initialize(opts)
+    end
+
+    def node_a
+      nodes[0]
+    end
+
+    def node_b
+      nodes[1]
     end
 
     def to_a
@@ -38,6 +50,16 @@ module VisualizeRuby
       "#<VisualizeRuby::Edge #{to_a.join(" ")}>"
     end
 
+    def ==(other)
+      other.class == self.class && other.hash == self.hash
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      [dir, name, nodes.map(&:hash), style, color].hash
+    end
+
     alias_method :to_s, :inspect
   end
 end

data/lib/visualize_ruby/execution_tracer.rb

@@ -0,0 +1,64 @@
+require "tracer"
+require "tempfile"
+
+module VisualizeRuby
+  class ExecutionTracer
+    TRACE_POINT_OPTIONS = [
+        :line
+    ]
+    attr_reader :executed_events
+    # @param [String, File] ruby_code
+    # @param [File, String] calling_code
+    # @param [Array<Symbol>] trace_point_options
+    def initialize(builder = nil, ruby_code: builder.ruby_code, calling_code:, trace_point_options: TRACE_POINT_OPTIONS)
+      @ruby_code           = ruby_code
+      @calling_code        = calling_code
+      @trace_point_options = trace_point_options
+      @temp_files          = []
+      @executed_events      = []
+    end
+
+    def trace
+      load(ruby_file.path)
+      tracer.enable { eval(calling_file.read) }
+      self
+    ensure
+      temp_files.each(&:close!)
+    end
+
+    private
+
+    attr_reader :trace_point_options
+
+    def tracer
+      @tracer ||= TracePoint.new(*trace_point_options) do |tp|
+        if tp.path == ruby_file.path
+          executed_events << { line: tp.lineno, event: tp.event}
+        end
+      end
+    end
+
+    attr_reader :temp_files
+
+    def temp_file(ruby_code)
+      @temp_files ||= []
+      file        = Tempfile.new(%w(ruby_file .rb), File.expand_path(File.join(File.dirname(__FILE__), "../../tmp")))
+      file.write(ruby_code)
+      file.rewind
+      @temp_files << file
+      file
+    end
+
+    def ruby_file
+      @ruby_file ||= file!(@ruby_code)
+    end
+
+    def calling_file
+      @calling_file ||= file!(@calling_code)
+    end
+
+    def file!(code)
+      code.is_a?(String) ? temp_file(code) : code
+    end
+  end
+end

data/lib/visualize_ruby/graph.rb

@@ -1,10 +1,17 @@
 module VisualizeRuby
   class Graph
-    attr_reader :name, :nodes, :edges
+    attr_accessor :name, :nodes, :edges
 
-    def initialize(ruby_code:, name: nil)
-      @name          = name.to_s if name
-      @nodes, @edges = Parser.new(ruby_code).parse
+    def initialize(ruby_code: nil, name: nil, ast: nil, **opts)
+      @name              = name.to_s if name
+      @nodes, @edges     = (ast ? Parser.new(ast: ast) : Parser.new(ruby_code)).parse
+      @ast               = ast
+      @graph_viz_options = opts
+    end
+
+    def options(**args)
+      @graph_viz_options.merge!(args)
+      @graph_viz_options
     end
 
     def to_hash
@@ -14,5 +21,11 @@ module VisualizeRuby
           nodes: nodes.map(&:to_a),
       }
     end
+
+    def uniq_elements!
+      @edges = edges.uniq
+      @nodes = nodes.uniq
+      self
+    end
   end
 end

data/lib/visualize_ruby/graphviz.rb

@@ -2,11 +2,12 @@ require "graphviz"
 
 module VisualizeRuby
   class Graphviz
-    attr_reader :graphs, :label
+    attr_reader :graphs, :label, :unique_nodes
 
-    def initialize(graphs, label: nil)
-      @graphs = [*graphs]
-      @label  = label
+    def initialize(builder_result = nil, graphs: nil, label: nil, unique_nodes: true)
+      @graphs       = graphs || builder_result.graphs
+      @label        = builder_result ? builder_result.options[:label] : label
+      @unique_nodes = unique_nodes
     end
 
     def to_graph(format: nil, path: nil)
@@ -46,14 +47,23 @@ module VisualizeRuby
       @nodes ||= {}
     end
 
+    def node_id(node)
+      if unique_nodes
+        node.id
+      else
+        node.name
+      end
+    end
+
     def create_edges(sub_graphs)
       sub_graphs.each do |r_graph, g_graph|
         r_graph.edges.each do |edge|
+          next unless edge.display == :visual
           ::Graphviz::Edge.new(
               g_graph,
-              nodes[edge.node_a.name],
-              nodes[edge.node_b.name],
-              **compact({ label: edge.name, dir: edge.dir, style: edge.style, color: edge.color })
+              nodes[node_id(edge.node_a)],
+              nodes[node_id(edge.node_b)],
+              **compact({ label: edge.name, dir: edge.dir, style: edge.style, **edge.options})
           )
         end
       end
@@ -62,16 +72,20 @@ module VisualizeRuby
     def create_sub_graph(graph, index)
       main_graph.add_subgraph(
           "cluster_#{index}",
-          **compact({ label: graph.name, style: graphs.count == 1 ? :invis : :dotted })
+          **compact({ label: graph.name, style: graphs.count == 1 ? :invis : :dotted, **graph.options })
       )
     end
 
     def create_nodes(graph, sub_graph)
       graph.nodes.each do |node|
-        nodes[node.name] = sub_graph.add_node(
-            node.name,
-            shape: node.shape,
-            style: node.style
+        nodes[node_id(node)] = sub_graph.add_node(
+            node_id(node),
+            compact({
+                        shape: node.shape,
+                        style: node.style,
+                        label: node.name,
+                        **node.options
+                    })
         )
       end
     end

data/lib/visualize_ruby/highlight_tracer.rb

@@ -0,0 +1,74 @@
+module VisualizeRuby
+  class HighlightTracer
+    OPTIONS = {
+        color: :forestgreen
+    }
+
+    # @param [VisualizeRuby::Builder::Result] builder
+    # @param [Hash{line: Integer, event: Symbol}] executed_events
+    # @param [Symbol] color
+    def initialize(builder:, executed_events: [], color: OPTIONS.fetch(:color))
+      @builder         = builder
+      @executed_events = executed_events
+      @color           = color
+    end
+
+    # @return [VisualizeRuby::Builder::Result]
+    def highlight!
+      mark!
+      builder
+    end
+
+    private
+
+    attr_reader :builder, :color, :executed_events
+
+    def mark!
+      last_touch = nil
+      (paired_line_events).to_a.each do |a, b|
+        all_edges.detect do |e|
+          if e.node_a.line == a && (e.node_b.line || executed_lines.last) == b # end nodes do not have lineno
+            touch_nodes(e, except: [last_touch])
+            last_touch = e.nodes[1]
+            check_lineno_connections(e)
+            e.touch(color)
+          end
+        end || (last_touch = nil)
+      end
+    end
+
+    def check_lineno_connections(e)
+      e.nodes.each do |n|
+        if n.lineno_connection
+          n.lineno_connection.touch(color)
+          touch_nodes(n.lineno_connection, except: e.nodes)
+        end
+      end
+    end
+
+    def touch_nodes(edge, except: [])
+      edge.nodes.each { |n| n.touch(color) unless except.include?(n) }
+    end
+
+    def all_edges
+      @all_edges ||= builder.graphs.flat_map(&:edges)
+    end
+
+    def paired_line_events
+      line_events = executed_events.select { |e| e[:event] == :line } + [executed_events.last]
+      setup_paring(line_events) do |a, b|
+        [line_events[a][:line], line_events[b][:line]]
+      end
+    end
+
+    def setup_paring(array, offset = -2)
+      (0..(array.length + offset)).to_a.map do |l|
+        yield(l, l + 1)
+      end
+    end
+
+    def executed_lines
+      @executed_lines ||= executed_events.map { |event| event[:line] }
+    end
+  end
+end

data/lib/visualize_ruby/node.rb

@@ -1,16 +1,17 @@
 module VisualizeRuby
   class Node
-    attr_reader :name, :style
-    attr_accessor :type
+    include Touchable
+    include Optionalable
+    attr_reader :style, :line
+    attr_accessor :type, :id, :lineno_connection
 
-    def initialize(name:, type: :action, style: :rounded)
-      @name  = name.to_s
+    def initialize(name: nil, type: :action, style: :rounded, ast: nil, line: nil, id: nil, **opts)
+      @name  = name || (ast ? AstHelper.new(ast).description : nil)
       @type  = type
       @style = style
-    end
-
-    def to_sym
-      name.to_s.gsub(" ", "_").to_sym
+      @id    = id || (ast ? AstHelper.new(ast).id : nil)
+      @line  = line || AstHelper.new(ast).first_line
+      post_initialize(opts)
     end
 
     def to_a
@@ -36,11 +37,23 @@ module VisualizeRuby
         :ellipse
       when :argument
         :box
+      else
+        :box
       end
     end
 
     def inspect
-      "#<VisualizeRuby::Node #{type_display} #{name}>"
+      "#<VisualizeRuby::Node #{type_display} #{id}>"
+    end
+
+    def ==(other)
+      other.class == self.class && other.hash == self.hash
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      [type, name, style, id].hash
     end
 
     alias_method :to_s, :inspect

data/lib/visualize_ruby/optionalable.rb

@@ -0,0 +1,15 @@
+module VisualizeRuby
+  module Optionalable
+    def post_initialize(**opts)
+      @graph_viz_options = opts
+      super if defined? super
+    end
+
+    def options(args={})
+      @graph_viz_options.merge!(args)
+      @graph_viz_options
+    end
+
+    attr_reader :graph_viz_options
+  end
+end

data/lib/visualize_ruby/parser/and.rb

@@ -2,18 +2,6 @@ module VisualizeRuby
   class Parser
     class And < Base
       include Conditions
-      # @return [Array<VisualizeRuby::Node>, Array<VisualizeRuby::Edge>]
-      def parse
-        last_node = nil
-        edges     = []
-        nodes     = @ast.children.reverse.map do |c|
-          node = set_conditions(c).first
-          edges << Edge.new(name: "AND", nodes: [node, last_node]) if last_node
-          last_node = node
-          node
-        end.reverse
-        return nodes, edges
-      end
     end
   end
 end

data/lib/visualize_ruby/parser/begin.rb

@@ -4,16 +4,36 @@ module VisualizeRuby
       # @return [Array<VisualizeRuby::Node>, Array<VisualizeRuby::Edge>]
       def parse
         last_node = nil
-        @ast.children.to_a.compact.reverse.each do |a|
+        @ast.children.to_a.compact.reverse.each do |a| # builds tree from bottom up
           _nodes, _edges = Parser.new(ast: a).parse
           edges.concat(_edges.reverse)
           nodes.concat(_nodes.reverse)
-          edges << Edge.new(nodes: [_nodes.first, last_node]) if last_node
+          connect_nodes(_edges, _nodes, last_node) if last_node
           last_node = _nodes.first
         end
-
         return nodes.reverse, edges.reverse
       end
+
+      private
+
+      def connect_nodes(_edges, _nodes, last_node)
+        no_top_edge_nodes(_edges, _nodes).each do |n|
+          if n.type == :branch_leaf # remove inserted branch leaf, added from Parser::If, and connect to last_node
+            # (node-bool->branch_leaf) REPLACE WITH (node-bool->last_node)
+            edge          = _edges.detect { |e| e.node_b == n }
+            edge.nodes[1] = last_node
+            nodes.delete(n)
+          else # 1. (-> n) 2. (-> n -> last_node)
+            edges << Edge.new(nodes: [n, last_node])
+          end
+        end
+      end
+
+      def no_top_edge_nodes(_edges, _nodes)
+        _nodes.select do |n| # ONLY (-> n) NOT (n ->)
+          _edges.none? { |e| e.node_a == n }
+        end
+      end
     end
   end
 end

data/lib/visualize_ruby/parser/block.rb

@@ -7,32 +7,29 @@ module VisualizeRuby
         item                        = arguments.children[0]
         collection, iterator_type   = iterator.to_a
         if enumerable?(collection) || enumerable?(iterator_type)
-          enumerable(action, collection, iterator_type, item)
+          yield_block(action, item, iterator, "blue", true)
         else
-          yield_block(action, item, iterator)
+          yield_block(action, item, iterator, "orange", false)
         end
         return nodes, edges
       end
 
       private
 
-      def yield_block(action, item, on_object)
-        nodes << on_object_node = Node.new(name: AstHelper.new(on_object).description)
-        nodes << item_node = Node.new(name: AstHelper.new(item).description, type: :argument)
-        nodes << action_node = Node.new(name: AstHelper.new(action).description)
-        edges << Edge.new(nodes: [on_object_node, item_node])
-        edges << Edge.new(nodes: [item_node, action_node], color: "orange")
-      end
+      def yield_block(action, item, on_object, color, enumerable)
+        nodes << on_object_node = Node.new(ast: on_object, color: color)
+        nodes << item_node = Node.new(type: :argument, ast: item, color: color) if item
+        nodes << action_node = Node.new(ast: action, color: color)
+
+        if item_node
+          edges << Edge.new(nodes: [on_object_node, item_node], color: color)
+          edges << Edge.new(nodes: [item_node, action_node], color: color)
+          action_node.lineno_connection = edges.last
+        else
+          edges << Edge.new(nodes: [on_object_node, action_node], color: color)
+        end
 
-      def enumerable(action, collection, iterator_type, item)
-        nodes << collection_node = Node.new(name: AstHelper.new(collection).description)
-        nodes << item_node = Node.new(name: AstHelper.new(item).description, type: :argument)
-        nodes << iterator_node = Node.new(name: iterator_type)
-        nodes << action_node = Node.new(name: AstHelper.new(action).description)
-        edges << Edge.new(nodes: [collection_node, iterator_node])
-        edges << Edge.new(nodes: [iterator_node, item_node], color: "blue")
-        edges << Edge.new(nodes: [item_node, action_node], color: "blue")
-        edges << Edge.new(nodes: [action_node, iterator_node], color: "blue", name: "↺")
+        edges << Edge.new(nodes: [action_node, on_object_node], color: color, name: "↺") if enumerable
       end
 
       def enumerable?(meth)

data/lib/visualize_ruby/parser/case.rb

@@ -4,7 +4,7 @@ module VisualizeRuby
       # @return [Array<VisualizeRuby::Node>, Array<VisualizeRuby::Edge>]
       def parse
         condition, *_whens, _else = @ast.children
-        condition_node = Node.new(name: AstHelper.new(condition).description, type: :decision)
+        condition_node = Node.new(ast: condition, type: :decision)
         nodes << condition_node
         _whens.each do |_when|
           edge_name, actions = _when.children
@@ -13,7 +13,7 @@ module VisualizeRuby
           nodes.concat(action_nodes)
           edges.concat(action_edges)
         end
-        _else_node = Node.new(name: AstHelper.new(_else).description, type: :action)
+        _else_node = Node.new(ast: _else, type: :action)
         _else_edge = Edge.new(name: "else", nodes: [condition_node, _else_node])
         nodes << _else_node
         edges << _else_edge

data/lib/visualize_ruby/parser/conditions.rb

@@ -8,6 +8,22 @@ module VisualizeRuby
         edges.concat(condition_edges)
         condition_nodes
       end
+
+      # @return [Array<VisualizeRuby::Node>, Array<VisualizeRuby::Edge>]
+      def parse
+        last_node = nil
+        edges     = []
+        nodes     = @ast.children.reverse.map do |c|
+          node = set_conditions(c).first
+          if last_node
+            edges << Edge.new(name: self.class.name.split("::").last.upcase, nodes: [node, last_node])
+            last_node.lineno_connection = edges.last
+          end
+          last_node = node
+          node
+        end.reverse
+        return nodes, edges
+      end
     end
   end
 end

data/lib/visualize_ruby/parser/if.rb

@@ -6,28 +6,37 @@ module VisualizeRuby
       def parse
         break_ast
 
-        condition_nodes               = set_conditions(condition)
-        on_true_node, on_true_edges   = branch(on_true)
-        on_false_node, on_false_edges = branch(on_false) if on_false
-
-        condition_nodes.each do |condition_node|
-          edges << Edge.new(name: "true", nodes: [condition_node, on_true_node])
-          edges << Edge.new(name: "false", nodes: [condition_node, on_false_node]) if on_false
-        end
-        edges.concat(on_false_edges) if on_false
+        condition_nodes                = set_conditions(condition)
+        on_true_nodes, on_true_edges   = branch(on_true)
+        on_false_nodes, on_false_edges = branch(on_false)
+        last_condition                 = condition_nodes.last
+        on_true_nodes[0]               = on_true_node = (on_true_nodes.first || branch_leaf(last_condition, "true"))
+        on_false_nodes[0]              = on_false_node = (on_false_nodes.first || branch_leaf(last_condition, "false"))
+        nodes.concat(on_true_nodes)
+        nodes.concat(on_false_nodes)
+        edges << Edge.new(name: "true", nodes: [last_condition, on_true_node])
+        edges << Edge.new(name: "false", nodes: [last_condition, on_false_node])
+        edges.concat(on_false_edges)
         edges.concat(on_true_edges)
         return [nodes, edges]
       end
 
       def branch(on_bool)
+        return [], [] unless on_bool
         on_bool_nodes, on_bool_edges = Parser.new(ast: on_bool).parse
-        on_bool_node                 = on_bool_nodes.first
-        nodes.concat(on_bool_nodes)
-        return on_bool_node, on_bool_edges
+        return on_bool_nodes, on_bool_edges
       end
 
       private
 
+      def branch_leaf(last_condition, type)
+        Node.new(
+            name: "END",
+            type: :branch_leaf,
+            id:   "end-#{type}-'#{last_condition.id}'"
+        )
+      end
+
       attr_reader :condition, :on_true, :on_false
 
       def break_ast

data/lib/visualize_ruby/parser/or.rb

@@ -2,16 +2,6 @@ module VisualizeRuby
   class Parser
     class Or < Base
       include Conditions
-      # @return [Array<VisualizeRuby::Node>, Array<VisualizeRuby::Edge>]
-      def parse
-        last_node = nil
-        @ast.children.reverse.map do |c|
-          node = set_conditions(c).first
-          edges << Edge.new(name: "OR", nodes: [node, last_node]) if last_node
-          last_node = node
-        end
-        return nodes.reverse, edges
-      end
     end
   end
 end

data/lib/visualize_ruby/parser/send.rb

@@ -3,7 +3,7 @@ module VisualizeRuby
     class Send < Base
       # @return [Array<VisualizeRuby::Node>, Array<VisualizeRuby::Edge>]
       def parse
-        return [Node.new(name: AstHelper.new(@ast).description, type: :action)], []
+        return [Node.new(ast: @ast, type: :action)], []
       end
     end
   end

data/lib/visualize_ruby/parser/str.rb

@@ -3,7 +3,7 @@ module VisualizeRuby
     class Str < Base
       # @return [Array<VisualizeRuby::Node>, Array<VisualizeRuby::Edge>]
       def parse
-        return [Node.new(name: AstHelper.new(@ast).description, type: :action)], []
+        return [Node.new(ast: @ast, type: :action)], []
       end
     end
   end

data/lib/visualize_ruby/parser.rb

@@ -3,7 +3,6 @@ require_relative "parser/conditions"
 require_relative "parser/base"
 require_relative "parser/or"
 require_relative "parser/and"
-require_relative "parser/ast_helper"
 require_relative "parser/begin"
 require_relative "parser/send"
 require_relative "parser/str"

data/lib/visualize_ruby/runner.rb

@@ -0,0 +1,36 @@
+module VisualizeRuby
+  class Runner
+    # @return [String, IO]
+    attr_accessor :calling_code
+    # @return [String, IO]
+    attr_accessor :ruby_code
+    # @return [Symbol, NilClass]
+    attr_accessor :output_format
+    # @return [String]
+    attr_accessor :output_path
+    # @param [String, IO]
+    attr_reader :calling_code
+
+    # @param [String, IO]
+    def trace(calling_code)
+      @calling_code = calling_code
+    end
+
+    def run!
+      highlight_trace
+      VisualizeRuby::Graphviz.new(builder).to_graph({ path: output_path, format: output_format }.compact)
+    end
+
+    private
+
+    def builder
+      @builder ||= VisualizeRuby::Builder.new(ruby_code: ruby_code).build
+    end
+
+    def highlight_trace
+      return unless calling_code
+      executed_events = VisualizeRuby::ExecutionTracer.new(builder, calling_code: calling_code).trace.executed_events
+      VisualizeRuby::HighlightTracer.new(builder: builder, executed_events: executed_events).highlight!
+    end
+  end
+end

data/lib/visualize_ruby/touchable.rb

@@ -0,0 +1,23 @@
+module VisualizeRuby
+  module Touchable
+    def post_initialize(**args)
+      @touched = 0
+      super if defined? super
+    end
+
+    def touch(color)
+      options.merge!(color: color)
+      @touched += 1
+    end
+
+    def name
+      if [0,1].include?(@touched)
+        @name
+      else
+        "#{@name} (#{@touched})"
+      end
+    end
+
+    attr_reader :touched
+  end
+end

data/lib/visualize_ruby/version.rb

@@ -1,3 +1,3 @@
 module VisualizeRuby
-  VERSION = "0.8.0"
+  VERSION = "0.11.0"
 end

data/lib/visualize_ruby.rb

@@ -1,10 +1,25 @@
 require "visualize_ruby/version"
 require "visualize_ruby/parser"
+require "visualize_ruby/optionalable"
+require "visualize_ruby/touchable"
 require "visualize_ruby/node"
 require "visualize_ruby/edge"
 require "visualize_ruby/graph"
 require "visualize_ruby/builder"
 require "visualize_ruby/graphviz"
+require "visualize_ruby/ast_helper"
+require "visualize_ruby/runner"
+require "visualize_ruby/execution_tracer"
+require "visualize_ruby/highlight_tracer"
 
 module VisualizeRuby
+  def self.new
+    runner = Runner.new
+    if block_given?
+      yield(runner)
+      runner.run!
+    else
+      runner
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: visualize_ruby
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Dustin Zeisler
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-17 00:00:00.000000000 Z
+date: 2018-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -127,14 +127,17 @@ files:
 - bin/setup
 - exe/visualize_ruby
 - lib/visualize_ruby.rb
+- lib/visualize_ruby/ast_helper.rb
 - lib/visualize_ruby/builder.rb
 - lib/visualize_ruby/edge.rb
+- lib/visualize_ruby/execution_tracer.rb
 - lib/visualize_ruby/graph.rb
 - lib/visualize_ruby/graphviz.rb
+- lib/visualize_ruby/highlight_tracer.rb
 - lib/visualize_ruby/node.rb
+- lib/visualize_ruby/optionalable.rb
 - lib/visualize_ruby/parser.rb
 - lib/visualize_ruby/parser/and.rb
-- lib/visualize_ruby/parser/ast_helper.rb
 - lib/visualize_ruby/parser/base.rb
 - lib/visualize_ruby/parser/begin.rb
 - lib/visualize_ruby/parser/block.rb
@@ -147,6 +150,8 @@ files:
 - lib/visualize_ruby/parser/str.rb
 - lib/visualize_ruby/parser/true.rb
 - lib/visualize_ruby/parser/type.rb
+- lib/visualize_ruby/runner.rb
+- lib/visualize_ruby/touchable.rb
 - lib/visualize_ruby/version.rb
 - visualize_ruby.gemspec
 homepage: https://github.com/zeisler/visualize_ruby

data/lib/visualize_ruby/parser/ast_helper.rb

@@ -1,14 +0,0 @@
-module VisualizeRuby
-  class Parser
-    class AstHelper
-      def initialize(ast)
-        @ast = ast
-      end
-
-      def description(ast: @ast)
-        return ast unless ast.respond_to?(:type)
-        Unparser.unparse(ast)
-      end
-    end
-  end
-end