ZerethShell — File Manager

dot_visitor.rb

# frozen_string_literal: true
# :markup: markdown

=begin
--
This file is generated by the templates/template.rb script and should not be
modified manually. See templates/lib/prism/dot_visitor.rb.erb
if you are looking to modify the template
++
=end

require "cgi/escape"
require "cgi/util" unless defined?(CGI::EscapeExt)

module Prism
  # This visitor provides the ability to call Node#to_dot, which converts a
  # subtree into a graphviz dot graph.
  class DotVisitor < Visitor
    class Field # :nodoc:
      attr_reader :name, :value, :port

def initialize(name, value, port)
        @name = name
        @value = value
        @port = port
      end

def to_dot
        if port
          "<tr><td align=\"left\" colspan=\"2\" port=\"#{name}\">#{name}</td></tr>"
        else
          "<tr><td align=\"left\">#{name}</td><td>#{CGI.escapeHTML(value || raise)}</td></tr>"
        end
      end
    end

class Table # :nodoc:
      attr_reader :name, :fields

def initialize(name)
        @name = name
        @fields = []
      end

def field(name, value = nil, port: false)
        fields << Field.new(name, value, port)
      end

def to_dot
        dot = <<~DOT
          <table border="0" cellborder="1" cellspacing="0" cellpadding="4">
            <tr><td colspan="2"><b>#{name}</b></td></tr>
        DOT

if fields.any?
          "#{dot}  #{fields.map(&:to_dot).join("\n  ")}\n</table>"
        else
          "#{dot}</table>"
        end
      end
    end

class Digraph # :nodoc:
      attr_reader :nodes, :waypoints, :edges

def initialize
        @nodes = []
        @waypoints = []
        @edges = []
      end

def node(value)
        nodes << value
      end

def waypoint(value)
        waypoints << value
      end

def edge(value)
        edges << value
      end

def to_dot
        <<~DOT
          digraph "Prism" {
            node [
              fontname=\"Courier New\"
              shape=plain
              style=filled
              fillcolor=gray95
            ];

#{nodes.map { |node| node.gsub(/\n/, "\n  ") }.join("\n  ")}
            node [shape=point];
            #{waypoints.join("\n  ")}

#{edges.join("\n  ")}
          }
        DOT
      end
    end

private_constant :Field, :Table, :Digraph

# The digraph that is being built.
    attr_reader :digraph

# Initialize a new dot visitor.
    def initialize
      @digraph = Digraph.new
    end

# Convert this visitor into a graphviz dot graph string.
    def to_dot
      digraph.to_dot
    end

# Visit a AliasGlobalVariableNode node.
    def visit_alias_global_variable_node(node)
      table = Table.new("AliasGlobalVariableNode")
      id = node_id(node)

# new_name
      table.field("new_name", port: true)
      digraph.edge("#{id}:new_name -> #{node_id(node.new_name)};")

# old_name
      table.field("old_name", port: true)
      digraph.edge("#{id}:old_name -> #{node_id(node.old_name)};")

# keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a AliasMethodNode node.
    def visit_alias_method_node(node)
      table = Table.new("AliasMethodNode")
      id = node_id(node)

# new_name
      table.field("new_name", port: true)
      digraph.edge("#{id}:new_name -> #{node_id(node.new_name)};")

# old_name
      table.field("old_name", port: true)
      digraph.edge("#{id}:old_name -> #{node_id(node.old_name)};")

# keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a AlternationPatternNode node.
    def visit_alternation_pattern_node(node)
      table = Table.new("AlternationPatternNode")
      id = node_id(node)

# left
      table.field("left", port: true)
      digraph.edge("#{id}:left -> #{node_id(node.left)};")

# right
      table.field("right", port: true)
      digraph.edge("#{id}:right -> #{node_id(node.right)};")

# operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a AndNode node.
    def visit_and_node(node)
      table = Table.new("AndNode")
      id = node_id(node)

# left
      table.field("left", port: true)
      digraph.edge("#{id}:left -> #{node_id(node.left)};")

# right
      table.field("right", port: true)
      digraph.edge("#{id}:right -> #{node_id(node.right)};")

# operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a ArgumentsNode node.
    def visit_arguments_node(node)
      table = Table.new("ArgumentsNode")
      id = node_id(node)

# flags
      table.field("flags", arguments_node_flags_inspect(node))

# arguments
      if node.arguments.any?
        table.field("arguments", port: true)

waypoint = "#{id}_arguments"
        digraph.waypoint("#{waypoint};")

digraph.edge("#{id}:arguments -> #{waypoint};")
        node.arguments.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("arguments", "[]")
      end

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a ArrayNode node.
    def visit_array_node(node)
      table = Table.new("ArrayNode")
      id = node_id(node)

# flags
      table.field("flags", array_node_flags_inspect(node))

# elements
      if node.elements.any?
        table.field("elements", port: true)

waypoint = "#{id}_elements"
        digraph.waypoint("#{waypoint};")

digraph.edge("#{id}:elements -> #{waypoint};")
        node.elements.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("elements", "[]")
      end

# opening_loc
      unless (opening_loc = node.opening_loc).nil?
        table.field("opening_loc", location_inspect(opening_loc))
      end

# closing_loc
      unless (closing_loc = node.closing_loc).nil?
        table.field("closing_loc", location_inspect(closing_loc))
      end

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a ArrayPatternNode node.
    def visit_array_pattern_node(node)
      table = Table.new("ArrayPatternNode")
      id = node_id(node)

# constant
      unless (constant = node.constant).nil?
        table.field("constant", port: true)
        digraph.edge("#{id}:constant -> #{node_id(constant)};")
      end

# requireds
      if node.requireds.any?
        table.field("requireds", port: true)

waypoint = "#{id}_requireds"
        digraph.waypoint("#{waypoint};")

digraph.edge("#{id}:requireds -> #{waypoint};")
        node.requireds.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("requireds", "[]")
      end

# rest
      unless (rest = node.rest).nil?
        table.field("rest", port: true)
        digraph.edge("#{id}:rest -> #{node_id(rest)};")
      end

# posts
      if node.posts.any?
        table.field("posts", port: true)

waypoint = "#{id}_posts"
        digraph.waypoint("#{waypoint};")

digraph.edge("#{id}:posts -> #{waypoint};")
        node.posts.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("posts", "[]")
      end

# opening_loc
      unless (opening_loc = node.opening_loc).nil?
        table.field("opening_loc", location_inspect(opening_loc))
      end

# closing_loc
      unless (closing_loc = node.closing_loc).nil?
        table.field("closing_loc", location_inspect(closing_loc))
      end

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a AssocNode node.
    def visit_assoc_node(node)
      table = Table.new("AssocNode")
      id = node_id(node)

# key
      table.field("key", port: true)
      digraph.edge("#{id}:key -> #{node_id(node.key)};")

# value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

# operator_loc
      unless (operator_loc = node.operator_loc).nil?
        table.field("operator_loc", location_inspect(operator_loc))
      end

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a AssocSplatNode node.
    def visit_assoc_splat_node(node)
      table = Table.new("AssocSplatNode")
      id = node_id(node)

# value
      unless (value = node.value).nil?
        table.field("value", port: true)
        digraph.edge("#{id}:value -> #{node_id(value)};")
      end

# operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a BackReferenceReadNode node.
    def visit_back_reference_read_node(node)
      table = Table.new("BackReferenceReadNode")
      id = node_id(node)

# name
      table.field("name", node.name.inspect)

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a BeginNode node.
    def visit_begin_node(node)
      table = Table.new("BeginNode")
      id = node_id(node)

# begin_keyword_loc
      unless (begin_keyword_loc = node.begin_keyword_loc).nil?
        table.field("begin_keyword_loc", location_inspect(begin_keyword_loc))
      end

# statements
      unless (statements = node.statements).nil?
        table.field("statements", port: true)
        digraph.edge("#{id}:statements -> #{node_id(statements)};")
      end

# rescue_clause
      unless (rescue_clause = node.rescue_clause).nil?
        table.field("rescue_clause", port: true)
        digraph.edge("#{id}:rescue_clause -> #{node_id(rescue_clause)};")
      end

# else_clause
      unless (else_clause = node.else_clause).nil?
        table.field("else_clause", port: true)
        digraph.edge("#{id}:else_clause -> #{node_id(else_clause)};")
      end

# ensure_clause
      unless (ensure_clause = node.ensure_clause).nil?
        table.field("ensure_clause", port: true)
        digraph.edge("#{id}:ensure_clause -> #{node_id(ensure_clause)};")
      end

# end_keyword_loc
      unless (end_keyword_loc = node.end_keyword_loc).nil?
        table.field("end_keyword_loc", location_inspect(end_keyword_loc))
      end

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a BlockArgumentNode node.
    def visit_block_argument_node(node)
      table = Table.new("BlockArgumentNode")
      id = node_id(node)

# expression
      unless (expression = node.expression).nil?
        table.field("expression", port: true)
        digraph.edge("#{id}:expression -> #{node_id(expression)};")
      end

# operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a BlockLocalVariableNode node.
    def visit_block_local_variable_node(node)
      table = Table.new("BlockLocalVariableNode")
      id = node_id(node)

# flags
      table.field("flags", parameter_flags_inspect(node))

# name
      table.field("name", node.name.inspect)

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a BlockNode node.
    def visit_block_node(node)
      table = Table.new("BlockNode")
      id = node_id(node)

# locals
      table.field("locals", node.locals.inspect)

# parameters
      unless (parameters = node.parameters).nil?
        table.field("parameters", port: true)
        digraph.edge("#{id}:parameters -> #{node_id(parameters)};")
      end

# body
      unless (body = node.body).nil?
        table.field("body", port: true)
        digraph.edge("#{id}:body -> #{node_id(body)};")
      end

# opening_loc
      table.field("opening_loc", location_inspect(node.opening_loc))

# closing_loc
      table.field("closing_loc", location_inspect(node.closing_loc))

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a BlockParameterNode node.
    def visit_block_parameter_node(node)
      table = Table.new("BlockParameterNode")
      id = node_id(node)

# flags
      table.field("flags", parameter_flags_inspect(node))

# name
      table.field("name", node.name.inspect)

# name_loc
      unless (name_loc = node.name_loc).nil?
        table.field("name_loc", location_inspect(name_loc))
      end

# operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a BlockParametersNode node.
    def visit_block_parameters_node(node)
      table = Table.new("BlockParametersNode")
      id = node_id(node)

# parameters
      unless (parameters = node.parameters).nil?
        table.field("parameters", port: true)
        digraph.edge("#{id}:parameters -> #{node_id(parameters)};")
      end

# locals
      if node.locals.any?
        table.field("locals", port: true)

waypoint = "#{id}_locals"
        digraph.waypoint("#{waypoint};")

digraph.edge("#{id}:locals -> #{waypoint};")
        node.locals.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("locals", "[]")
      end

# opening_loc
      unless (opening_loc = node.opening_loc).nil?
        table.field("opening_loc", location_inspect(opening_loc))
      end

# closing_loc
      unless (closing_loc = node.closing_loc).nil?
        table.field("closing_loc", location_inspect(closing_loc))
      end

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a BreakNode node.
    def visit_break_node(node)
      table = Table.new("BreakNode")
      id = node_id(node)

# arguments
      unless (arguments = node.arguments).nil?
        table.field("arguments", port: true)
        digraph.edge("#{id}:arguments -> #{node_id(arguments)};")
      end

# keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a CallAndWriteNode node.
    def visit_call_and_write_node(node)
      table = Table.new("CallAndWriteNode")
      id = node_id(node)

# flags
      table.field("flags", call_node_flags_inspect(node))

# receiver
      unless (receiver = node.receiver).nil?
        table.field("receiver", port: true)
        digraph.edge("#{id}:receiver -> #{node_id(receiver)};")
      end

# call_operator_loc
      unless (call_operator_loc = node.call_operator_loc).nil?
        table.field("call_operator_loc", location_inspect(call_operator_loc))
      end

# message_loc
      unless (message_loc = node.message_loc).nil?
        table.field("message_loc", location_inspect(message_loc))
      end

# read_name
      table.field("read_name", node.read_name.inspect)

# write_name
      table.field("write_name", node.write_name.inspect)

# operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

# value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a CallNode node.
    def visit_call_node(node)
      table = Table.new("CallNode")
      id = node_id(node)

# flags
      table.field("flags", call_node_flags_inspect(node))

# receiver
      unless (receiver = node.receiver).nil?
        table.field("receiver", port: true)
        digraph.edge("#{id}:receiver -> #{node_id(receiver)};")
      end

# call_operator_loc
      unless (call_operator_loc = node.call_operator_loc).nil?
        table.field("call_operator_loc", location_inspect(call_operator_loc))
      end

# name
      table.field("name", node.name.inspect)

# message_loc
      unless (message_loc = node.message_loc).nil?
        table.field("message_loc", location_inspect(message_loc))
      end

# opening_loc
      unless (opening_loc = node.opening_loc).nil?
        table.field("opening_loc", location_inspect(opening_loc))
      end

# arguments
      unless (arguments = node.arguments).nil?
        table.field("arguments", port: true)
        digraph.edge("#{id}:arguments -> #{node_id(arguments)};")
      end

# closing_loc
      unless (closing_loc = node.closing_loc).nil?
        table.field("closing_loc", location_inspect(closing_loc))
      end

# equal_loc
      unless (equal_loc = node.equal_loc).nil?
        table.field("equal_loc", location_inspect(equal_loc))
      end

# block
      unless (block = node.block).nil?
        table.field("block", port: true)
        digraph.edge("#{id}:block -> #{node_id(block)};")
      end

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a CallOperatorWriteNode node.
    def visit_call_operator_write_node(node)
      table = Table.new("CallOperatorWriteNode")
      id = node_id(node)

# flags
      table.field("flags", call_node_flags_inspect(node))

# receiver
      unless (receiver = node.receiver).nil?
        table.field("receiver", port: true)
        digraph.edge("#{id}:receiver -> #{node_id(receiver)};")
      end

# call_operator_loc
      unless (call_operator_loc = node.call_operator_loc).nil?
        table.field("call_operator_loc", location_inspect(call_operator_loc))
      end

# message_loc
      unless (message_loc = node.message_loc).nil?
        table.field("message_loc", location_inspect(message_loc))
      end

# read_name
      table.field("read_name", node.read_name.inspect)

# write_name
      table.field("write_name", node.write_name.inspect)

# binary_operator
      table.field("binary_operator", node.binary_operator.inspect)

# binary_operator_loc
      table.field("binary_operator_loc", location_inspect(node.binary_operator_loc))

# value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

super
    end

# Visit a CallOrWriteNode node.
    def visit_call_or_write_node(node)
      table = Table.new("CallOrWriteNode")
      id = node_id(node)