hashira 0.4.0 → 0.5.1

data/lib/hashira/analysis/cycle_findings.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "rule"
-
-class Hashira::Analysis::CycleFindings < Hashira::Analysis::Rule
-  KIND = "cycle"
-
-  def list
-    loops.map { entry(it) }
-  end
-
-  private
-
-  def loops
-    cycles = graph.cycles
-    graph.packages.select { cycles.through?(it) }.sort.map { cycles.path(it) }.uniq { it[..-2].sort }
-  end
-
-  def entry(path)
-    package = path.first
-    finding(
-      package:, cycle: path, evidence: evidence(path),
-      message: message(package, path, graph.cycles.weakest(path))
-    )
-  end
-
-  def message(package, path, weak_edge)
-    from, to = weak_edge
-    weight = graph.weight(from, to)
-    "#{package} can reach itself: #{path.join(" -> ")} — any change may ripple back " \
-      "around. The lightest edge on this cycle is #{from} -> #{to} " \
-      "(#{weight} ref#{"s" unless weight == 1})."
-  end
-
-  def evidence(path)
-    path.each_cons(2).flat_map { |from, to| graph.evidence(from, to).to_a.first(2) }
-  end
-end

data/lib/hashira/analysis/references.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require "prism"
-
-module Hashira
-  module Analysis
-    module References
-      module_function
-
-      def list(tree)
-        sightings(tree).map(&:first)
-      end
-
-      def sightings(tree, roots = nil)
-        [].tap { collect(tree, [], it, roots) }
-      end
-
-      def collect(node, nesting, accumulator, roots, home = nesting)
-        return unless node
-        return accumulator << sighting(node, nesting, home) if constant?(node)
-        return enter(node, nesting, accumulator, roots) if definition?(node)
-        node.compact_child_nodes.each { collect(it, nesting, accumulator, roots, home) }
-      end
-
-      def sighting(node, nesting, home)
-        [Syntax.segments(node), node.location.start_line, Syntax.cbase?(node) ? nil : nesting, home]
-      end
-
-      def constant?(node) = node.is_a?(Prism::ConstantPathNode) || node.is_a?(Prism::ConstantReadNode)
-
-      def definition?(node) = node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
-
-      def enter(node, nesting, accumulator, roots)
-        opened = nesting + [Syntax.anchor(nesting, Syntax.segments(node.constant_path), roots)]
-        collect(node.superclass, nesting, accumulator, roots, opened) if node.is_a?(Prism::ClassNode)
-        collect(node.body, opened, accumulator, roots)
-      end
-    end
-  end
-end

data/lib/hashira/analysis/sdp_violation_findings.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "rule"
-
-class Hashira::Analysis::SdpViolationFindings < Hashira::Analysis::Rule
-  KIND = "sdp_violation"
-
-  def list
-    ranked.map { |from, to| violation(from, to) }
-  end
-
-  private
-
-  def ranked = graph.violations.sort_by { |from, to| instability(from) - instability(to) }
-
-  def violation(from, to)
-    finding(package: from, evidence: graph.evidence(from, to).to_a.first(5), message: message(from, to))
-  end
-
-  def message(from, to)
-    "#{from} (I=#{label(from)}) depends on the LESS stable #{to} " \
-      "(I=#{label(to)}) — churn in #{to} will force churn in #{from}. " \
-      "Invert the edge or extract the stable part of #{to} that #{from} needs."
-  end
-
-  def instability(package) = metrics[package].instability
-
-  def label(package) = format("%.2f", instability(package))
-end