visualize_ruby 0.11.0 → 0.16.0

data/lib/visualize_ruby/highlight_tracer.rb

@@ -8,9 +8,12 @@ module VisualizeRuby
     # @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
+      @builder           = builder
+      @executed_events   = executed_events
+      @color             = color
+      @last_touched_node = nil
+      @last_touched_edge = nil
+      @step_increment    = 0
     end
 
     # @return [VisualizeRuby::Builder::Result]
@@ -21,43 +24,105 @@ module VisualizeRuby
 
     private
 
-    attr_reader :builder, :color, :executed_events
+    attr_reader :builder,
+                :color,
+                :executed_events,
+                :last_touched_node,
+                :last_touched_edge
 
     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)
+      paired_line_events.to_a.each.with_index do |(a, c)|
+        build_exe_edge(a, c) unless find_edge(a, c)
       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)
+    def find_edge(a, c)
+      all_edges.detect do |e|
+        if e.node_a.line == a && (e.node_b.line || executed_lines.last) == c # end nodes do not have lineno
+          check_lineno_connections(e)
+          touch(e)
         end
       end
     end
 
-    def touch_nodes(edge, except: [])
-      edge.nodes.each { |n| n.touch(color) unless except.include?(n) }
+    def step(increment=true)
+      if increment
+        @step_increment += 1
+      else
+        @step_increment
+      end
+    end
+
+    def touch(e, except = nil)
+      touched_edge = false
+      e.nodes.reject { |n| n == last_touched_node || n == except }.each do |n|
+        touched_edge = touch_in_order(e, n, touched_edge)
+      end
+      touch_edge(e, touched_edge) # if it didn't happen already
+    end
+
+    def touch_in_order(e, n, touched_edge)
+      if e.node_a == last_touched_node
+        touched_edge = touch_edge(e, touched_edge)
+        n.touch(color, step: step)
+      else
+        n.touch(color, step: step)
+        touched_edge = touch_edge(e, touched_edge)
+      end
+      @last_touched_node = n
+      touched_edge
+    end
+
+    def touch_edge(e, touched_edge)
+      if !touched_edge && e != last_touched_edge
+        e.touch(color, step: step)
+        @last_touched_edge = e
+        touched_edge       = true
+      end
+      touched_edge
+    end
+
+    def build_exe_edge(a, c)
+      node_a, graph_a = find_node(line: a, graphs: builder.graphs)
+      node_b, _ = find_node(line: c, graphs: builder.graphs)
+      if node_a && node_b && node_a != node_b
+        touch(exe_edge(graph_a, node_a, node_b))
+      end
+    end
+
+    def find_node(line:, graphs: builder.graphs)
+      graphs.each do |graph|
+        graph = graph
+        node  = graph.nodes.detect { |n| n.line == line }
+        return node, graph if node
+      end
+    end
+
+    def exe_edge(graph_a, node_a, node_b)
+      if (exe_edge = all_edges.detect { |e| e.node_b == node_b && e.node_a == node_a })
+        exe_edge
+      else
+        new = Edge.new(nodes: [node_a, node_b], type: :execution, style: :dotted)
+        graph_a.edges << new
+        new
+      end
+    end
+
+    # Associated nodes and edges that are on the same line
+    def check_lineno_connections(e)
+      e.nodes.each do |n|
+        touch(n.lineno_connection, e.nodes) if n.lineno_connection
+      end
     end
 
     def all_edges
-      @all_edges ||= builder.graphs.flat_map(&: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]]
+      setup_paring(line_events) do |a, c|
+        [line_events[a][:line], line_events[c][:line]]
       end
     end
 

data/lib/visualize_ruby/input_coercer.rb

@@ -0,0 +1,61 @@
+require "tempfile"
+
+module VisualizeRuby
+  class InputCoercer
+    attr_reader :name, :input
+
+    def initialize(input, name:)
+      @input = input
+      @name = name
+    end
+
+    def to_file
+      @to_file ||= case input
+                   when File
+                     input
+                   when Pathname
+                     File.open(input)
+                   when String
+                     temp_file
+                   else
+                     raise ArgumentError, "#{name} was given an unknown type #{input.class}"
+                   end
+    end
+
+    def read
+      case input
+      when String
+        input
+      when File, Tempfile, Pathname
+        to_file.read
+      else
+        raise ArgumentError, "#{name} was given an unknown type #{input.class}"
+      end
+    end
+
+    def close!
+      @temp_file.close! if @temp_file
+    end
+
+    def temp_file
+      @temp_file ||= begin
+        file = Tempfile.new(%w(calling_code .rb))
+        file.write(input)
+        file.rewind
+        file
+      end
+    end
+
+    def load_file
+      load(to_file.path)
+    end
+
+    def to_proc
+      if input.is_a?(Proc)
+        input
+      else
+        Proc.new { load_file }
+      end
+    end
+  end
+end

data/lib/visualize_ruby/namable.rb

@@ -0,0 +1,37 @@
+module VisualizeRuby
+  module Namable
+    DEFAULT_DISPLAYER = -> (attr) do
+      r = attr.values.compact.join(" ")
+      r.empty? ? nil : r
+    end
+
+    def post_initialize(name_displayer: nil, **args)
+      @name_displayer = name_displayer || DEFAULT_DISPLAYER
+      super if defined? super
+    end
+
+    def name
+      @name_displayer.call(build_name_list)
+    end
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def add_names(*names)
+        @name_registry = name_registry.concat(names).uniq
+      end
+
+      def name_registry
+        @name_registry ||= []
+      end
+    end
+
+    private
+
+    def build_name_list
+      self.class.name_registry.each_with_object({}) { |meth, hash| hash[meth] = __send__(meth) }
+    end
+  end
+end

data/lib/visualize_ruby/node.rb

@@ -1,15 +1,16 @@
 module VisualizeRuby
   class Node
+    include Namable
+    add_names :label
     include Touchable
     include Optionalable
-    attr_reader :style, :line
+    attr_reader :style, :line, :label
     attr_accessor :type, :id, :lineno_connection
-
     def initialize(name: nil, type: :action, style: :rounded, ast: nil, line: nil, id: nil, **opts)
-      @name  = name || (ast ? AstHelper.new(ast).description : nil)
+      @label  = name || (ast ? AstHelper.new(ast).description : nil)
       @type  = type
       @style = style
-      @id    = id || (ast ? AstHelper.new(ast).id : nil)
+      @id    = id || (ast ? AstHelper.new(ast).id : @label)
       @line  = line || AstHelper.new(ast).first_line
       post_initialize(opts)
     end

data/lib/visualize_ruby/parser.rb

@@ -12,6 +12,7 @@ require_relative "parser/true"
 require_relative "parser/false"
 require_relative "parser/case"
 require_relative "parser/block"
+require_relative "parser/return"
 
 module VisualizeRuby
   class Parser

data/lib/visualize_ruby/parser/begin.rb

@@ -23,7 +23,7 @@ module VisualizeRuby
             edge          = _edges.detect { |e| e.node_b == n }
             edge.nodes[1] = last_node
             nodes.delete(n)
-          else # 1. (-> n) 2. (-> n -> last_node)
+          elsif n.type != :return # 1. (-> n) 2. (-> n -> last_node)
             edges << Edge.new(nodes: [n, last_node])
           end
         end

data/lib/visualize_ruby/parser/block.rb

@@ -18,17 +18,8 @@ module VisualizeRuby
 
       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
-
+        edges << Edge.new(nodes: [on_object_node, action_node], name: item, color: color)
         edges << Edge.new(nodes: [action_node, on_object_node], color: color, name: "↺") if enumerable
       end
 

data/lib/visualize_ruby/parser/case.rb

@@ -3,20 +3,25 @@ module VisualizeRuby
     class Case < Base
       # @return [Array<VisualizeRuby::Node>, Array<VisualizeRuby::Edge>]
       def parse
-        condition, *_whens, _else = @ast.children
-        condition_node = Node.new(ast: condition, type: :decision)
+        ast_condition_node, *ast_when_nodes, ast_else_node = @ast.children
+        condition_node = Node.new(ast: ast_condition_node, type: :decision)
         nodes << condition_node
-        _whens.each do |_when|
-          edge_name, actions = _when.children
+
+        ast_when_nodes.each do |ast_when_node|
+          edge_name, actions = ast_when_node.children
           action_nodes, action_edges = Parser.new(ast: actions).parse
           edges << Edge.new(name:  AstHelper.new(edge_name).description, nodes: [condition_node, action_nodes.first])
           nodes.concat(action_nodes)
           edges.concat(action_edges)
         end
-        _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
+
+        if ast_else_node
+          else_node = Node.new(ast: ast_else_node, type: :action)
+          else_edge = Edge.new(name: "else", nodes: [condition_node, else_node])
+          nodes << else_node
+          edges << else_edge
+        end
+
         return nodes, edges
       end
     end

data/lib/visualize_ruby/parser/conditions.rb

@@ -4,24 +4,23 @@ module VisualizeRuby
       def set_conditions(condition)
         condition_nodes, condition_edges = Parser.new(ast: condition).parse
         condition_nodes.first.type       = :decision
-        nodes.concat(condition_nodes)
-        edges.concat(condition_edges)
+        nodes.unshift(*condition_nodes)
+        edges.unshift(*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
+        @ast.children.reverse.map do |c|
+          node = set_conditions(c).last
           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
+        end
         return nodes, edges
       end
     end

data/lib/visualize_ruby/parser/return.rb

@@ -0,0 +1,12 @@
+module VisualizeRuby
+  class Parser
+    class Return < Base
+      # @return [Array<VisualizeRuby::Node>, Array<VisualizeRuby::Edge>]
+      def parse
+        nodes, edges = Parser.new(ast: @ast.children[0]).parse
+        nodes.last.type = :return
+        return [nodes, edges]
+      end
+    end
+  end
+end

data/lib/visualize_ruby/runner.rb

@@ -1,36 +1,98 @@
+require "active_support/core_ext/hash/compact"
+
 module VisualizeRuby
   class Runner
-    # @return [String, IO]
+    # @return [String, File, Pathname, Proc] The code that calls the graphed code.
     attr_accessor :calling_code
-    # @return [String, IO]
+    # @return [String, File, Pathname] The code to be graphed.
     attr_accessor :ruby_code
-    # @return [Symbol, NilClass]
+    # @return [Symbol, NilClass, String] To output DOT format as a string use String class as value.
     attr_accessor :output_format
-    # @return [String]
+    # @return [String, Pathname] Add the exe name to select a format ie. png, jpg, svg, dot...
     attr_accessor :output_path
-    # @param [String, IO]
-    attr_reader :calling_code
-
-    # @param [String, IO]
-    def trace(calling_code)
-      @calling_code = calling_code
+    # @param [TrueClass, FalseClass] in line body when calling methods on self. Looks better when tracing execution.
+    attr_writer :in_line_local_method_calls
+    # @param [TrueClass, FalseClass] Duplicate nodes with the same description are merged to point single node.
+    attr_writer :unique_nodes
+    # @params [Array<String>, NilClass] When a graph has many sub-graphs only include listed.
+    attr_writer :only_graphs
+    # @param [String, File]
+    # @param [Proc]
+    def trace(calling_code = nil, &block)
+      @calling_code = calling_code || block
     end
 
+    attr_reader :output
+
     def run!
-      highlight_trace
-      VisualizeRuby::Graphviz.new(builder).to_graph({ path: output_path, format: output_format }.compact)
+      @run ||= begin
+        highlight_trace
+        @output ||= VisualizeRuby::Graphviz.new(
+          builder,
+          graphs:       filter_graphs,
+          unique_nodes: unique_nodes,
+          only_graphs:  only_graphs,
+        ).to_graph({ path: output_path, format: output_format }.compact)
+      end
+      self
+    end
+
+    def in_line_local_method_calls
+      @in_line_local_method_calls ||= traced?
+    end
+
+    def options(opts={})
+      opts.each do |key, value|
+        public_send("#{key}=", value)
+      end
+    end
+
+    def graphs
+      graphs = builder.graphs.map(&:name).compact
+      [builder.options.fetch(:label, "default")].concat(graphs)
     end
 
     private
 
     def builder
-      @builder ||= VisualizeRuby::Builder.new(ruby_code: ruby_code).build
+      @builder ||= VisualizeRuby::Builder.new(
+        ruby_code:                  ruby_code,
+        in_line_local_method_calls: in_line_local_method_calls
+      ).build
+    end
+
+    def filter_graphs
+      if traced?
+        builder.graphs.select do |g|
+          g.nodes.any? { |n| n.touched > 0 }
+        end
+      else
+        builder.graphs
+      end
+    end
+
+    def traced?
+      !!calling_code
+    end
+
+    def unique_nodes
+      @unique_nodes ||= true
+    end
+
+    def only_graphs
+      @only_graphs ||= nil
     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!
+      return unless traced?
+      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