chaos_detector 0.4.9

data/lib/chaos_detector/chaos_graphs/domain_metrics.rb

@@ -0,0 +1,19 @@
+require 'chaos_detector/graph_theory/graph_theory'
+
+# Dependency Count total/normalized
+#
+module ChaosDetector
+  module ChaosGraphs
+    class DomainMetrics
+      attr_reader :dep_count
+      attr_reader :dep_count_norm
+
+      def initialize
+        @dep_count = 0
+        @dep_count_norm = 0.0
+      end
+
+      def to_s; end
+    end
+  end
+end

data/lib/chaos_detector/chaos_graphs/domain_node.rb

@@ -0,0 +1,57 @@
+require 'chaos_detector/graph_theory/node'
+# Domain node
+module ChaosDetector
+  module ChaosGraphs
+    class DomainNode < ChaosDetector::GraphTheory::Node
+      alias domain_name name
+
+      def initialize(domain_name: nil, node_origin: nil, is_root: false, reduction: nil)
+        super(name: domain_name, root: is_root, node_origin: node_origin, reduction: reduction)
+      end
+
+      def hash
+        domain_name.hash
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def ==(other)
+        domain_name&.to_s == other&.domain_name&.to_s
+      end
+
+      def title
+        super
+      end
+
+      def subtitle
+        root? ? 'Root Node' : ''
+      end
+
+      def graph_props
+        props = super
+        if reduction
+          props.merge!(
+            cardinality_modules: reduction.reduction_count,
+            cardinality_functions: reduction.reduction_sum
+          )
+        end
+        super.merge(props)
+      end
+
+      # Must be name/domain_name for comparisons:
+      def to_s
+        domain_name
+      end
+
+      class << self
+        attr_reader :root_node
+        def root_node(force_new: false)
+          @root_node = new(is_root: true) if force_new || @root_node.nil?
+          @root_node
+        end
+      end
+    end
+  end
+end

data/lib/chaos_detector/chaos_graphs/function_node.rb

@@ -0,0 +1,112 @@
+require 'chaos_detector/stacker/fn_info'
+require 'chaos_detector/stacker/mod_info'
+require 'forwardable'
+require 'chaos_detector/graph_theory/edge'
+require 'chaos_detector/graph_theory/node'
+
+require 'chaos_detector/chaos_utils'
+
+module ChaosDetector
+  module ChaosGraphs
+    class FunctionNode < ChaosDetector::GraphTheory::Node
+      extend Forwardable
+      alias fn_name name
+      attr_accessor :domain_name
+      attr_accessor :fn_path
+      attr_accessor :fn_line
+      attr_accessor :fn_line_end
+
+      # Modules to which this Function Node is associated:
+      attr_reader :mod_infos
+      def_delegator :@mod_infos, :first, :mod_info_prime
+
+      def initialize(
+        fn_name: nil,
+        fn_path: nil,
+        fn_line: nil,
+        domain_name: nil,
+        is_root: false,
+        mod_info: nil,
+        reduction: nil
+      )
+        super(name: fn_name, root: is_root, reduction: reduction)
+
+        @domain_name = domain_name&.to_s
+        @fn_path = fn_path
+        @fn_line = fn_line
+        @mod_infos = []
+
+        # Add module info, if supplied:
+        add_module(mod_info)
+      end
+
+      def add_module(mod_info)
+        @mod_infos << mod_info if mod_info
+      end
+
+      def add_module_attrs(mod_name:, mod_path:, mod_type:)
+        add_module(ChaosDetector::Stacker::ModInfo.new(mod_name: mod_name, mod_path: mod_path, mod_type: mod_type))
+      end
+
+      def hash
+        [fn_name, fn_path].hash
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def ==(other)
+        ChaosDetector::Stacker::FnInfo.match?(self, other)
+      end
+
+      def domain_name
+        @domain_name
+      end
+
+      def to_s
+        ChaosUtils.decorate_tuple([domain_name, fn_name, super, short_path], clamp: :bracket)
+      end
+
+      def to_info
+        FnInfo.new(fn_name: fn_name, fn_line: fn_line, fn_path: fn_path)
+      end
+
+      def title
+        fn_name
+      end
+
+      def subtitle
+        '(%s)%s' % [domain_name, short_path]
+      end
+
+      def short_path
+        ChaosDetector::Utils::StrUtil.humanize_module(@fn_path, sep_token: '/')
+      end
+
+      class << self
+        attr_reader :root_node
+        def root_node(force_new: false)
+          @root_node = new(is_root: true) if force_new || @root_node.nil?
+          @root_node
+        end
+
+        def match?(obj1, obj2)
+          raise 'Domains differ, but fn_info is the same.  Weird.' if \
+            obj1.fn_name == obj2.fn_name \
+            && obj1.fn_path == obj2.fn_path \
+            && obj1.domain_name != other.domain_name
+
+          fn_path == other.fn_path &&
+            (fn_name == other.fn_name || line_match?(other.fn_line, fn_line))
+        end
+
+        def line_match?(l1, l2)
+          return false if l1.nil? || l2.nil?
+
+          (l2 - l1).between?(0, 1)
+        end
+      end
+    end
+  end
+end

data/lib/chaos_detector/chaos_graphs/module_node.rb

@@ -0,0 +1,86 @@
+require 'chaos_detector/stacker/mod_info'
+require 'chaos_detector/graph_theory/node'
+require 'chaos_detector/utils/str_util'
+require 'chaos_detector/chaos_utils'
+
+module ChaosDetector
+  module ChaosGraphs
+    # Consider putting action/event in this class and naming it accordingly
+    class ModuleNode < ChaosDetector::GraphTheory::Node
+      attr_reader :mod_type # :unknown, :module, :class
+      attr_reader :mod_path # :unknown, :module, :class
+      attr_reader :domain_name
+
+      alias mod_name name
+
+      def initialize(mod_name: nil, mod_path: nil, is_root: false, node_origin: nil, domain_name: nil, mod_type: nil, reduction: nil)
+        super(name: mod_name, root: is_root, node_origin: node_origin, reduction: reduction)
+        @domain_name = domain_name&.to_s
+        @mod_path = mod_path
+        @mod_type = mod_type
+      end
+
+      def hash
+        [mod_name, mod_type, mod_path].hash
+        # [mod_name, mod_type, domain_name].hash
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def ==(other)
+        # TODO? Checking domain name vs path name due to mixins/metacoding:
+        mod_name == other.mod_name &&
+          mod_type == other.mod_type &&
+          mod_path == other.mod_path
+      end
+
+      def title
+        mod_name
+      end
+
+      def subtitle
+        '%s[%s]' % [short_mod_type, domain_name]
+      end
+      
+      def graph_props
+        props = super
+        if reduction
+          props.merge!(
+            cardinality_functions: reduction.reduction_count
+          )
+        end
+        super.merge(props)
+      end
+
+      def short_mod_type
+        mod_type && "(#{mod_type[0]})"
+      end
+      
+      def short_path
+        ChaosDetector::Utils::StrUtil.humanize_module(@mod_path, sep_token: '/')
+      end
+
+      def to_info
+        ChaosDetector::Stacker::ModInfo.new(mod_name: mod_name, mod_path: mod_path, mod_type: mod_type)
+      end
+
+      def to_k
+        ChaosDetector::Utils::StrUtil.snakeize([domain_name, mod_name, @mod_type, @mod_path].compact.map(&:to_s))
+      end
+
+      def to_s
+        [super, domain_name, @mod_type, short_path].join(', ')
+      end
+
+      class << self
+        attr_reader :root_node
+        def root_node(force_new: false)
+          @root_node = new(is_root: true) if force_new || @root_node.nil?
+          @root_node
+        end
+      end
+    end
+  end
+end

data/lib/chaos_detector/chaos_utils.rb

@@ -0,0 +1,57 @@
+require 'chaos_detector/utils/core_util'
+require 'chaos_detector/utils/fs_util'
+require 'chaos_detector/utils/str_util'
+require 'chaos_detector/utils/lerp_util'
+require 'chaos_detector/utils/log_util'
+
+module ChaosUtils
+  class << self
+    def delerp(val, min:, max:)
+      ChaosDetector::Utils::LerpUtil.delerp(val, min: min, max: max)
+    end
+
+    def lerp(pct, min:, max:)
+      ChaosDetector::Utils::LerpUtil.lerp(val, min: min, max: max)
+    end
+
+    def log_msg(msg, **args)
+      ChaosDetector::Utils::LogUtil.log(msg, **args)
+    end
+
+    def decorate(text, **args)
+      ChaosDetector::Utils::StrUtil.decorate(text, **args)
+    end
+
+    def decorate_pair(src, dest, **args)
+      ChaosDetector::Utils::StrUtil.decorate_pair(src, dest, **args)
+    end
+
+    def decorate_tuple(tuple, **args)
+      ChaosDetector::Utils::StrUtil.decorate_tuple(tuple, **args)
+    end
+
+    def assert(expected_result=true, msg=nil, &block)
+      ChaosDetector::Utils::CoreUtil.assert(expected_result, msg, &block)
+    end
+
+    def aught?(obj)
+      ChaosDetector::Utils::CoreUtil.aught?(obj)
+    end
+
+    def naught?(obj)
+      ChaosDetector::Utils::CoreUtil.naught?(obj)
+    end
+
+    def rel_path(dir_path, from_path:)
+      ChaosDetector::Utils::FSUtil.rel_path(dir_path, from_path: from_path)
+    end
+
+    def squish(str)
+      ChaosDetector::Utils::StrUtil.squish(str)
+    end
+
+    def with(obj)
+      ChaosDetector::Utils::CoreUtil.with(obj) {yield obj}
+    end
+  end
+end

data/lib/chaos_detector/graph_theory/appraiser.rb

@@ -0,0 +1,162 @@
+require 'matrix'
+require 'chaos_detector/chaos_utils'
+require_relative 'node_metrics'
+
+module ChaosDetector
+  module GraphTheory
+    class Appraiser
+      attr_reader :cyclomatic_complexity
+      attr_reader :adjacency_matrix
+
+      def initialize(graph)
+        @graph = graph
+        @adjacency_matrix = nil
+        @cyclomatic_complexity = nil
+        @nodes_appraised = {}
+      end
+
+      def appraise(update_nodes:true)
+        log('Appraising nodes.')
+        @nodes_appraised = appraise_nodes!(update_nodes: update_nodes)
+        
+        # TODO: Store adjacency (to each other node) as a node metric?
+        @adjacency_matrix = build_adjacency_matrix(@graph.nodes)
+
+        # log('Measuring cyclomatic complexity.')
+        # measure_cyclomatic_complexity
+
+        log("Performed appraisal: %s" % to_s)
+      end
+
+      def metrics_for(node:)
+        raise ArgumentError, 'Node is required' if node.nil?
+        raise ArgumentError, ('Node [%s] has no metrics' % node) if !@nodes_appraised&.include?(node)
+        log('has no metrics', object: node) if !@nodes_appraised&.include?(node)
+        @nodes_appraised[node]
+      end
+
+      def to_s
+        format('N: %d, E: %d', @graph.nodes.length, @graph.edges.length)
+      end
+
+      def report
+        buffy = [to_s]
+
+        # buffy << "Circular References #{@circular_paths.length} / #{@circular_paths.uniq.length}"
+        # buffy.concat(@circular_paths.map do |p|
+        #   '  ' + p.map(&:title).join(' -> ')
+        # end)
+
+        # Gather nodes:
+        buffy << 'Nodes:'
+        buffy.concat(@nodes_appraised.map { |n, m| "  (#{n.title})[#{n.subtitle}]: #{m}" })
+
+        buffy.join("\n")
+      end
+
+      # Returns Hash<Node, NodeMetrics>
+      #   update_nodes: Updates all nodes' :graph_props to appraisal metrics hash:
+      def appraise_nodes!(update_nodes: true)
+        node_metrics = @graph.nodes.map do |node|
+          metrics = appraise_node(node)
+          [node, metrics]
+        end.to_h
+
+        if update_nodes
+          node_metrics.each do |node, metrics|
+            node.graph_props.merge!(metrics.to_h)
+          end
+        end
+
+        node_metrics
+      end
+
+      def build_adjacency_matrix(nodes)
+        matrix_dim = nodes.size
+        # nodes = @graph.nodes
+        Matrix.build(matrix_dim) do |row, col|
+          node_src = nodes[row]
+          node_dep = nodes[col]
+          # puts "Adjacency found for #{node_src}, #{node_dep}: #{edge&.reduction}  / #{edge&.reduction&.reduction_sum.to_i}"          
+          # puts "Adjacency found for #{row}:#{col} -> #{node_src}, #{node_dep}: #{adjacency?(node_src, node_dep)}"          
+          adjacency?(node_src, node_dep)
+        end
+      end
+
+    private
+
+      # For each node, measure fan-in(Ca) and fan-out(Ce)
+      def appraise_node(node)
+        circular_routes, terminal_routes = appraise_node_routes(node)
+        ChaosDetector::GraphTheory::NodeMetrics.new(
+          node,
+          afference: @graph.edges.count { |e| e.dep_node == node },
+          efference: @graph.edges.count { |e| e.src_node == node },
+          circular_routes: circular_routes,
+          terminal_routes: terminal_routes
+        )
+      end
+
+      def log(msg, **opts)
+        ChaosUtils.log_msg(msg, subject: 'Appraiser', **opts)
+      end
+
+      def fan_out_edges(node)
+        @graph.edges.find_all { |e| e.src_node == node }
+      end
+
+      def fan_out_nodes(node)
+        @graph.edges.find_all { |e| e.src_node == node }.map(&:dep_node)
+      end
+
+      def fan_in_nodes(node)
+        @graph.edges.find_all { |e| e.dep_node == node }.map(&:src_node)
+      end
+
+      def appraise_node_routes(_node)
+        # Traverse starting at each node to see if
+        # and how many ways we come back to ourselves
+        terminal_routes = []
+        circular_routes = []
+
+        [terminal_routes, circular_routes]
+      end
+
+      def adjacency?(node_src, node_dest)
+        edge = @graph.edges.find{|e| e.src_node == node_src && e.dep_node == node_dest }
+        edge&.reduction&.reduction_sum.to_i
+      end
+
+      #  Coupling: Each node couplet (Example for 100 nodes, we'd have 100 * 99 potential couplets)
+      #  Capture how many other nodes depend upon both nodes in couplet [directly, indirectly]
+      #  Capture how many other nodes from other domains depend upon both [directly, indirectly]
+      # TODO??  
+      def node_matrix
+        node_matrix = Matrix.build(@graph.nodes.length) do |row, col|
+        end
+        node_matrix
+      end
+
+      def measure_cyclomatic_complexity
+        @circular_paths = []
+        @full_paths = []
+        traverse_nodes([@graph.root_node])
+        @path_count_uniq = @circular_paths.uniq.count + @full_paths.uniq.count
+        @cyclomatic_complexity = @graph.edges.count - @graph.nodes.count + (2 * @path_count_uniq)
+      end
+
+      # @return positive integer indicating distance in number of vertices
+      # from node_src to node_dep.  If multiple routes, calculate shortest:
+      def node_distance(node_src, node_dep); end
+
+      def normalize(ary, property, norm_property)
+        vector = Vector.elements(ary.map { |obj| obj.send(property)})
+        vector = vector.normalize
+        ary.each_with_index do |obj, i|
+          obj.send("#{norm_property}=", vector[i])
+        end
+        ary
+      end
+    end
+  end
+end