chaos_detector 0.4.9

data/lib/chaos_detector/graph_theory/edge.rb

@@ -0,0 +1,76 @@
+module ChaosDetector
+  module GraphTheory
+    class Edge
+      attr_accessor :edge_type
+      attr_writer :graph_props
+      attr_accessor :src_node
+      attr_accessor :dep_node
+      attr_accessor :reduction
+
+      EDGE_TYPES = {
+        default: 0,
+        superclass: 1,
+        association: 2,
+        class_association: 3
+      }.freeze
+
+      def initialize(src_node, dep_node, edge_type: :default, reduction: nil)
+        raise ArgumentError, 'src_node is required ' unless src_node
+        raise ArgumentError, 'dep_node is required ' unless dep_node
+
+        @src_node = src_node
+        @dep_node = dep_node
+        @reduction = reduction
+        @edge_type = edge_type
+        @graph_props = {}
+      end
+
+      def edge_rank
+        EDGE_TYPES.fetch(@edge_type, 0)
+      end
+
+      def weight
+        @reduction&.reduction_sum || 1
+      end
+
+      def hash
+        [@src_node, @dep_node].hash
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      # Default behavior is accessor for @graph_props
+      def graph_props
+        @graph_props
+      end
+
+
+
+      def ==(other)
+        # puts "Checking src and dep"
+        src_node == other.src_node && dep_node == other.dep_node
+      end
+
+      def to_s
+        s = format('[%s] -> [%s]', src_node.title, dep_node.title)
+        s << "(#{reduction.reduction_sum})" if reduction&.reduction_sum.to_i > 1
+        s
+      end
+
+      # Mutate this Edge; combining attributes from other:
+      def merge!(other)
+        raise ArgumentError, ('Argument other should be Edge object (was %s)' % other.class) unless other.is_a?(Edge)
+
+        if EDGE_TYPES.dig(other.edge_type) > EDGE_TYPES.dig(edge_type)
+          @edge_type = other.edge_type
+        end
+
+        # puts("EDGE REDUCTION: #{@reduction.class} -- #{other.class}  // #{other.reduction.class}")
+        @reduction = ChaosDetector::GraphTheory::Reduction.combine(@reduction, other.reduction)
+        self
+      end
+    end
+  end
+end

data/lib/chaos_detector/graph_theory/graph.rb

@@ -0,0 +1,144 @@
+# Maintains all nodes and edges as stack calls are pushed and popped via Frames.
+module ChaosDetector
+  module GraphTheory
+    class Graph
+      attr_reader :root_node
+      attr_reader :edges
+
+      def node_count
+        @nodes.length
+      end
+
+      def edge_count
+        @edges.length
+      end
+
+      def initialize(root_node:, nodes: nil, edges: nil)
+        # raise ArgumentError, 'Root node required.' unless root_node
+
+        @root_node = root_node
+        @nodes = nodes || []
+        @edges = edges || []
+      end
+
+      def nodes(include_root: true)
+        include_root ? @nodes : @nodes.reject(&:root?)
+      end
+
+      # Return a new Graph object that only includes the given nodes and matching edges:
+#       def arrange_with(nodes:, include_root: true)
+#         gnodes = nodes.map(&:clone)
+#         if include_root
+#           gnodes << root_node unless(gnodes.include?(root_node))
+#         else
+#           gnodes.delete(root_node)
+#         end
+#
+#         gedges = edges.filter do |edge|
+#           gnodes.include?(edge.src_node) && gnodes.include?(edge.dep_node)
+#         end
+#
+#         ChaosDetector::GraphTheory::Graph.new(
+#           root_node: root_node,
+#           nodes: gnodes,
+#           edges: gedges
+#         ).tap do |graph|
+#           graph.whack_node(root_node) unless include_root
+#         end
+#       end
+
+      # Remove node and src and dep edges:
+      def whack_node(node)
+        @edges.delete_if { |e| e.src_node == node || e.dep_node == node }
+        @nodes.delete(node)
+      end
+
+      def traversal
+        to_enum(:traverse).map(&:itself) # {|n| puts "TNode:#{n}"; n.label}
+      end
+
+      # Possibly useful:
+      # def traversal(loop_detector: nil)
+      #   trace_nodes = []
+
+      #   traverse do |node|
+      #     if loop_detector.nil? || loop_detector.tolerates?(trace_nodes, node)
+      #       trace_nodes << node
+      #     end
+      #   end
+
+      #   trace_nodes
+      # end
+
+      ### Depth-first traversal
+      # Consumes each edge as it used
+      def traverse(origin_node: nil)
+        raise ArgumentError, 'traverse requires block' unless block_given?
+        edges = @edges
+        nodes_to_visit = [origin_node || root_node]
+        while nodes_to_visit.length > 0
+          node = nodes_to_visit.shift
+          yield(node)
+          out_edges, edges = edges.partition { |e| e.src_node == node }
+          child_nodes = out_edges.map(&:dep_node)
+          nodes_to_visit = child_nodes + nodes_to_visit
+        end
+      end
+
+      def children(node)
+        @edges.select { |e| e.src_node == node }.map(&:dep_node).inject do |child_nodes|
+          puts "Found children for #{node.label}: #{child_nodes}"
+        end
+      end
+
+      def node_for(obj)
+        raise ArgumentError, '#node_for requires obj' unless obj
+
+        node_n = @nodes.index(obj)
+        if node_n
+          @nodes[node_n]
+        else
+          yield.tap { |n| @nodes << n }
+        end
+      end
+
+      def edges_for_node(node)
+        edges.filter do |e|
+          e.src_node == node || e.dep_node == node
+        end
+      end
+
+      def edge_for_nodes(src_node, dep_node)
+        # puts "EEEDGE_FOR_NODES::: #{src_node.to_s} / #{dep_node.class.to_s}"
+        edge = edges.find do |e|
+          e.src_node == src_node && e.dep_node == dep_node
+        end
+
+        edges << edge = ChaosDetector::GraphTheory::Edge.new(src_node, dep_node) if edge.nil?
+
+        edge
+      end
+
+      def ==(other)
+        root_node == other.root_node &&
+          nodes == other.nodes &&
+          edges == other.edges
+      end
+
+      def to_s
+        format('Nodes: %d, Edges: %d', @nodes.length, @edges.length)
+      end
+
+      def inspect
+        buffy = []
+        buffy << "\tNodes (#{nodes.length})"
+        buffy.concat(nodes.map { |n| "\t\t#{n.title}"})
+
+        # buffy << "Edges (#{@edges.length})"
+        # buffy.concat(@edges.map {|e|"\t\t#{e.to_s}"})
+
+        buffy.join("\n")
+      end
+    end
+  end
+end

data/lib/chaos_detector/graph_theory/loop_detector.rb

@@ -0,0 +1,32 @@
+# Maintains all nodes and edges as stack calls are pushed and popped via Frames.
+module ChaosDetector
+  module GraphTheory
+    class LoopDetector
+      def initialize(detection: :simple, lookback: 0, tolerance: 0, grace_period: 0)
+        @detection = detection
+        @lookback = lookback
+        @tolerance = tolerance
+        @grace_period = grace_period
+      end
+
+      def tolerates?(nodes, node)
+        return true if (nodes.length <= @grace_period)
+        # return false if (lookback.zero? && tolerance.zero? && nodes.include?(node))
+
+        # TODO: lookback
+        nodes.count(node) > tolerance
+
+      end
+
+      private
+        def form_lookback
+        end
+
+      class << self
+        def simple
+          @simple ||= LoopDetector.new
+        end
+      end
+    end
+  end
+end

data/lib/chaos_detector/graph_theory/node.rb

@@ -0,0 +1,70 @@
+require 'chaos_detector/utils/str_util'
+require 'chaos_detector/chaos_utils'
+
+module ChaosDetector
+  module GraphTheory
+    class Node
+      ROOT_NODE_NAME = 'ROOT'.freeze
+
+      attr_writer :graph_props
+      attr_reader :is_root
+      attr_accessor :node_origin
+      attr_reader :reduction
+
+      def root?
+        !!is_root
+      end
+
+      def initialize(name: nil, root: false, node_origin: nil, reduction: nil)
+        raise ArgumentError, "Must have name or be root (name=#{name})" unless ChaosUtils.aught?(name) || root
+
+        @is_root = root
+        @name = @is_root ? ROOT_NODE_NAME : name
+        @node_origin = node_origin
+        @reduction = reduction
+        @graph_props = {}
+      end
+
+      def ==(other)
+        name == other.name &&
+          is_root == other.is_root
+      end
+
+      # Should be a reusable unique hash key for node:
+      def to_k
+        ChaosDetector::Utils::StrUtil.snakeize(name)
+      end
+
+      def to_s(_scope=nil)
+        name
+      end
+
+      def name
+        @is_root ? ROOT_NODE_NAME : @name
+      end
+
+      def title
+        name
+      end
+
+      def subtitle
+        nil
+      end
+
+      def root?
+        !!is_root
+      end
+
+      # Default behavior is accessor for @graph_props
+      def graph_props
+        @graph_props
+      end
+
+      # Mutate this Edge; combining attributes from other:
+      def merge!(other)
+        @reduction = ChaosDetector::GraphTheory::Reduction.combine(@reduction, other.reduction)
+        self
+      end
+    end
+  end
+end

data/lib/chaos_detector/graph_theory/node_metrics.rb

@@ -0,0 +1,68 @@
+require 'forwardable'
+
+module ChaosDetector
+  module GraphTheory
+    class NodeMetrics
+      GRAPH_PROPERTIES = %i[ total_couplings afference efference instability ].freeze
+
+      extend Forwardable
+      attr_accessor :afference
+      attr_accessor :efference
+      attr_accessor :terminal_routes
+      attr_accessor :circular_routes
+      attr_reader :node
+
+      def_delegators :@node, :title, :subtitle
+
+      def reduction_sum
+        @node&.reduction&.reduction_sum || 1
+      end
+
+      def reduction_count
+        @node&.reduction&.reduction_count || 1
+      end
+
+      def initialize(node, afference: 0, efference: 0, terminal_routes:, circular_routes:)
+        raise ArgumentError("node is required") if node.nil?
+
+        @node = node
+        @afference = afference
+        @efference = efference
+        @terminal_routes = terminal_routes || []
+        @circular_routes = circular_routes || []
+      end
+
+      # https://en.wikipedia.org/wiki/Software_package_metrics
+      # I = Ce / (Ce + Ca).
+      # I = efference / (total couplings)
+      # Value from 0.0 to 1.0
+      # I = 0.0 is maximally stable while
+      # I = 1.0 is maximally unstable.
+      def instability
+        cT = total_couplings.to_f
+        (cT.zero?) ? 0.0 : @efference / cT
+      end
+
+      def total_couplings
+        @afference + @efference
+      end
+
+      def summary
+        'I = Ce / (Ce + Ca)'
+      end
+
+      def to_h
+        {
+          afference: afference,
+          efference: efference,
+          instability: instability.round(2),
+          total_couplings: total_couplings
+        }
+      end
+
+      def to_s
+        "Ce: #{@efference}, Ca: #{@afference}, I: #{instability}"
+      end
+    end
+  end
+end

data/lib/chaos_detector/graph_theory/reduction.rb

@@ -0,0 +1,40 @@
+# Trackking of reduction(merging/removing dups)
+require 'set'
+module ChaosDetector
+  module GraphTheory
+    class Reduction
+      attr_reader :reduction_count
+      attr_reader :reduction_sum
+
+      def initialize(reduction_count: 1, reduction_sum: 1)
+        @reduction_count = reduction_count
+        @reduction_sum = reduction_sum
+      end
+
+      def merge!(other)
+        @reduction_sum += (other&.reduction_count || 1)
+        @reduction_count += 1 #(other&.reduction_count || 1)
+        self
+      end
+
+      def to_s
+        'Reduction (count/sum)=(%d, %d)' % [reduction_count, reduction_sum]
+      end
+
+      class << self
+        def combine(primary, secondary)
+          raise ArgumentError, ('Argument #primary should be Reduction object (was %s)' % primary.class) unless primary.is_a?(ChaosDetector::GraphTheory::Reduction)
+          # raise ArgumentError, ('Argument #secondary should be Reduction object (was %s)' % secondary.class) unless secondary.is_a?(ChaosDetector::GraphTheory::Reduction)
+
+          combined = primary ? primary.clone(freeze: false) : ChaosDetector::GraphTheory::Reduction.new
+          combined.merge!(secondary)
+        end
+
+        def combine_all(reductions)
+          red_sum = reductions.reduce(0) { |tally, r| tally + (r ? r.reduction_count : 1) }
+          Reduction.new(reduction_count: reductions.count, reduction_sum: red_sum)
+        end
+      end
+    end
+  end
+end

data/lib/chaos_detector/graphing/directed_graphs.rb

@@ -0,0 +1,396 @@
+require 'ruby-graphviz'
+require 'chaos_detector/utils/str_util'
+require 'chaos_detector/chaos_utils'
+
+module ChaosDetector
+  module Graphing
+    class DirectedGraphs
+      attr_reader :root_graph
+      attr_reader :node_hash
+      attr_reader :cluster_node_hash
+      attr_reader :render_folder
+      attr_reader :rendered_path
+      attr_reader :edges
+
+      BR = '<BR/>'
+      LF = "\r"
+      EDGE_MIN = 0.75
+      EDGE_BASELINE = 10.5
+
+      CLR_BLACK = 'black'.freeze
+      CLR_DARKRED = 'red4'.freeze
+      CLR_DARKGREEN = 'darkgreen'.freeze
+      CLR_BRIGHTGREEN = 'yellowgreen'.freeze
+      CLR_CYAN = 'cyan'.freeze
+      CLR_GREY = 'snow3'.freeze
+      CLR_ORANGE = 'orange'.freeze
+      CLR_NICEGREY = 'snow4'.freeze
+      CLR_PALEGREEN = 'palegreen'.freeze
+      CLR_PINK = 'deeppink1'.freeze
+      CLR_PURPLE = '#662D91'.freeze
+      CLR_SLATE = '#778899'.freeze
+      CLR_WHITE = 'white'.freeze
+      CLR_BLUE = 'darkblue'.freeze
+
+      GRAPH_ATTRS = {
+        type: :digraph,
+        bgcolor: CLR_SLATE,
+        center: 'false',
+        clusterrank: 'local',
+        color: CLR_WHITE,
+        compound: 'true',
+        # concentrate: 'true',
+        # engine: 'dot',
+        fontcolor: CLR_WHITE,
+        fontname: 'Georgia',
+        fontsize: '48',
+        labelloc: 't',
+        labeljust: 'l',
+        # mindist: '0.5',
+        # nojustify: 'true',
+        pad: '0.5',
+        # pack: 'true',
+        # packmode: 'graph',
+        pencolor: CLR_WHITE,
+        # outputorder: 'edgesfirst',
+        # ordering: 'out',
+        outputorder: 'nodesfirst',
+        nodesep: '0.5',
+        # sep: '0.5',
+        newrank: 'false',
+        rankdir: 'LR',
+        ranksep: '1.5',
+        # ranksep: 'equally',
+        ratio: 'auto',
+        # size: '50',
+        # page: '50',
+        size: '34,44',
+        # splines: 'spline',
+        # strict: 'true'
+      }.freeze
+
+      SUBDOMAIN_ATTRS = {
+        pencolor: CLR_ORANGE,
+        bgcolor: CLR_NICEGREY,
+        fillcolor: CLR_NICEGREY,
+        fontsize: '24',
+        rank: 'same',
+        fontname: 'Verdana',
+        labelloc: 't',
+        margin: '32,32',
+        # pencolor: CLR_GREY,
+        penwidth: '2',
+        style: 'rounded'
+      }.freeze
+
+      NODE_ATTRS = {
+        color: CLR_WHITE,
+        fontname: 'Verdana',
+        fontsize: '12',
+        # fixedsize: 'shape',
+        # height: '2.0',
+        # width: '2.0',
+        # fillcolor: CLR_WHITE,
+        fontcolor: CLR_WHITE,
+        margin: '0.25, 0.125',
+        shape: 'egg',
+      }.freeze
+
+      EDGE_ATTRS = {
+        color:CLR_WHITE,
+        constraint: 'true',
+        dir:'forward',
+        fontname:'Verdana',
+        fontcolor:CLR_ORANGE,
+        fontsize:'16',
+        # minlen: '3.0',
+        style:'solid',
+        penwidth:'1.0',
+      }.freeze
+
+      STUB_NODE_ATTRS = {
+        fixedsize: 'true',
+        size: '0.5, 0.5',
+        style: 'invis',
+      }
+
+      # Status messages:
+      PRE_STATUS_MSG = %(
+        Will update %<count>d record types from [%<from_type>s] to [%<to_type>s]'
+      ).freeze
+
+      TBL_HTML = <<~HTML
+        <TABLE BORDER='0' CELLBORDER='1' CELLSPACING='0' CELLPADDING='4'>
+          %s
+        </TABLE>
+      HTML
+
+      TBL_ROW_HTML = %(<TR BGCOLOR="%<color>s">%<cells>s</TR>)
+      TBL_CELL_HTML = %(<TD>%s</TD>)
+      BOLD_HTML = %(<BOLD>%s</BOLD>)
+
+      # TODO: integrate options as needed:
+      def initialize(render_folder: nil)
+        @root_graph = nil
+        @node_hash = {}
+        @cluster_node_hash = {}
+        @edges = Set.new
+        @render_folder = render_folder || 'render'
+      end
+
+      def create_directed_graph(title, graph_attrs: nil)
+        @title = title
+
+        @node_hash.clear
+        @cluster_node_hash.clear
+        @cluster_node_hash.clear
+
+        lbl = title_html(@title, subtitle: graph_attrs&.dig(:subtitle))
+
+        attrs = {
+          label: "<#{lbl}>",
+          **GRAPH_ATTRS,
+        }
+        attrs.merge(graph_attrs) if graph_attrs&.any?
+        attrs.delete(:subtitle)
+
+        @root_graph = GraphViz.digraph(:G, attrs)
+      end
+
+      def node_label(node, metrics_table: false)
+        if metrics_table
+          tbl_hash = {title: node.title,  subtitle: node.subtitle,  **node.graph_props}
+          html = html_tbl_from(hash: tbl_hash) do |k, v|
+            if k==:title
+              [in_font(k, font_size: 24), in_font(v, font_size: 16)]#[BOLD_HTML % k, BOLD_HTML % v]
+            else
+              [k, v]
+            end
+          end
+        else
+          html = title_html(node.title, subtitle: node.subtitle)
+        end
+        html.strip!
+        # puts '_' * 50
+        # puts "html: #{html}"
+        '<%s>' % html
+      end
+
+      # HTML Label with subtitle:
+      def title_html(title, subtitle:nil, font_size:24, subtitle_fontsize:nil)
+        lbl_buf = [in_font(title, font_size: font_size)]
+
+        sub_fontsize = subtitle_fontsize || 3 * font_size / 4
+        if ChaosUtils.aught?(subtitle)
+          lbl_buf << in_font(subtitle, font_size: sub_fontsize)
+        end
+
+        # Fake out some padding:
+        lbl_buf << in_font(' ', font_size: sub_fontsize)
+
+        lbl_buf.join(BR)
+      end
+
+      def in_font(str, font_size:12)
+        "<FONT POINT-SIZE='#{font_size}'>#{str}</FONT>"
+      end
+
+      def html_tbl_from(hash:)
+        trs = hash.map.with_index do |h, n|
+          k, v = h
+          key_content, val_content = yield(k, v) if block_given?
+          key_td = TBL_CELL_HTML % (key_content || k)
+          val_td = TBL_CELL_HTML % (val_content || v)
+          td_html = [key_td, val_td].join
+          html = format(TBL_ROW_HTML, {
+            color: n.even? ? 'blue' : 'white',
+            cells: td_html.strip
+          })
+          html.strip
+        end
+
+        TBL_HTML % trs.join().strip
+      end
+
+      def assert_graph_state
+        raise '@root_graph is not set yet.  Call create_directed_graph.' unless @root_graph
+      end
+
+      # Add node to given parent_node, assuming parent_node is a subgraph
+      def add_node_to_parent(node, parent_node:, as_cluster: false, metrics_table:false)
+        assert_graph_state
+        raise 'node is required' unless node
+
+        parent_graph = if parent_node
+          _clust, p_graph = find_graph_node(parent_node)
+          raise "Couldn't find parent node: #{parent_node}" unless p_graph
+          p_graph
+        else
+          @root_graph
+        end
+
+        add_node_to_graph(node, graph: parent_graph, as_cluster: as_cluster, metrics_table: metrics_table)
+      end
+
+      def add_node_to_graph(node, graph: nil, as_cluster: false, metrics_table:false)
+        assert_graph_state
+        raise 'node is required' unless node
+
+        parent_graph = graph || @root_graph
+        key = node.to_k
+
+        attrs = { label: node_label(node, metrics_table: metrics_table) }
+
+        if as_cluster
+          # tab good shape
+          subgraph_name = "cluster_#{key}"
+          attrs.merge!(SUBDOMAIN_ATTRS)
+          # attrs = {}.merge(SUBDOMAIN_ ATTRS)
+          @cluster_node_hash[key] = parent_graph.add_graph(subgraph_name, attrs)
+
+          @cluster_node_hash[key].add_nodes(node_key(node, cluster: :stub), STUB_NODE_ATTRS)
+
+          # @cluster_node_hash[key].attrs(attrs)
+          # puts ("attrs: #{key}: #{attrs}  / #{@cluster_node_hash.length}")
+        else
+          attrs = attrs.merge!(NODE_ATTRS)
+          @node_hash[key] = parent_graph.add_nodes(key, attrs)
+        end
+      end
+
+      def append_nodes(nodes, as_cluster: false, metrics_table: false)
+        assert_graph_state
+        return unless nodes
+        # raise 'node is required' unless nodes
+
+        nodes.each do |node|
+          parent_node = block_given? ? yield(node) : nil
+          # puts "gotit #{parent_node}" if parent_node
+          add_node_to_parent(node, parent_node: parent_node, as_cluster: as_cluster, metrics_table: metrics_table)
+        end
+      end
+
+      def node_key(node, cluster: false)
+        if cluster==:stub
+          "cluster_stub_#{node.to_k}"
+        elsif !!cluster
+          "cluster_#{node.to_k}"
+        else
+          node.to_k
+        end
+      end
+
+      def add_edges(edges, calc_weight:true, node_safe:true)
+        assert_graph_state
+
+        # @node_hash.each do |k, v|
+        #   log("NODE_HASH: Has value for #{ChaosUtils.decorate(k)} => #{ChaosUtils.decorate(v)}")
+        # end
+
+        weight_max  = edges.map(&:weight).max
+
+        edges.each do |edge|
+          src_clust, src = find_graph_node(edge.src_node)
+          dep_clust, dep = find_graph_node(edge.dep_node)
+          next unless !node_safe || (src && dep)
+
+          @edges << [src, dep]          
+          edge_attrs = build_edge_attrs(edge, calc_weight: calc_weight, max_weight: weight_max, src_clust: src_clust, dep_clust: dep_clust)
+          
+          @root_graph.add_edges(
+            node_key(edge.src_node, cluster: src_clust ? :stub : false),
+            node_key(edge.dep_node, cluster: dep_clust ? :stub : false),
+            edge_attrs
+          ) # , {label: e.reduce_sum, penwidth: weight})
+        end
+      end
+
+      def render_graph
+        assert_graph_state
+
+        filename = "#{@title}.png"
+        @rendered_path = File.join(@render_folder, filename).to_s
+
+        log("Rendering graph to to #{@rendered_path}")
+        ChaosDetector::Utils::FSUtil.ensure_paths_to_file(@rendered_path)
+        @root_graph.output(png: @rendered_path)
+        self
+      end
+
+    private
+
+      def build_edge_attrs(edge, calc_weight: true, max_weight: nil, src_clust: nil, dep_clust: nil)        
+        edge_attrs = EDGE_ATTRS.dup
+        
+        # Edge attaches to cluster if possible:
+        edge_attrs[:ltail] = node_key(edge.src_node, cluster: true) if src_clust
+        edge_attrs[:lhead] = node_key(edge.dep_node, cluster: true) if dep_clust
+
+        # Proportional edge weight:
+        if calc_weight && max_weight
+          edge_attrs.merge!(
+            label: edge.weight,
+            penwidth: edge_weight(edge.weight / max_weight)
+          )          
+        end
+ 
+        # Intra-domain:
+        if edge.src_node.domain_name == edge.dep_node.domain_name
+          edge_attrs.merge!(
+            style: 'dotted',
+            color: CLR_ORANGE,
+            constraint: 'true',
+          )
+        end
+        
+        # Props for edge_type:
+        edge_attrs.merge!(       
+          case edge.edge_type
+            when :superclass
+              {
+                arrowhead: 'empty',
+                arrowsize: 1.0,
+                color: CLR_BLUE
+              }
+            when :association
+              {
+                arrowhead: 'diamond',
+                arrowsize: 1.0,
+                color: CLR_ORANGE
+              }
+            when :class_association
+              {
+                arrowhead: 'diamond',
+                arrowsize: 1.0,
+                color: CLR_PINK
+              }
+            else
+              {
+                arrowhead: 'open',
+                arrowsize: 1.0
+              }
+          end
+        )
+      end
+
+      def find_graph_node(node)
+        assert_graph_state
+        # log("NODE_HASH: LOOKING UP #{ChaosUtils.decorate(node)}")
+        cnode = @cluster_node_hash[node.to_k]
+        if cnode
+          [true, cnode]
+        else
+          [false, @node_hash[node.to_k]]
+        end
+      end
+
+      def edge_weight(n, edge_min: EDGE_MIN, edge_baseline: EDGE_BASELINE)
+        edge_min + n * edge_baseline
+      end
+
+      def log(msg, **opts)
+        ChaosUtils.log_msg(msg, subject: 'DGraphDiagram', **opts)
+      end
+    end
+  end
+end