hashira 0.7.0 → 0.8.0

data/lib/hashira/coupling/graph.rb

@@ -2,18 +2,18 @@
 
 class Hashira::Coupling::Graph
   def initialize(project, trees, census)
+    @project = project
     @census = census
     @trees = trees
-    @map = Hashira::Coupling::EdgeMap.new(census)
-    trees.each { |file, tree| @map.record(project.relative(file), file, tree) }
-    @cycles = Hashira::Coupling::Cycles.new(@map.dependencies, self)
   end
 
-  attr_reader :cycles, :trees
+  attr_reader :trees
+
+  def cycles = @_cycles ||= Hashira::Coupling::Cycles.new(map.dependencies, self)
 
   def charge(file) = @census.charge(file, [])
 
-  def packages = (@census.packages | @map.dependencies.keys)
+  def packages = (@census.packages | dependencies.keys)
 
   def packaging = @census.packaging
 
@@ -34,13 +34,13 @@ class Hashira::Coupling::Graph
     end
   end
 
-  def evidence(from, to) = @map.evidence[[from, to]]
+  def evidence(from, to) = map.evidence[[from, to]]
 
-  def usage(package) = incoming(package).to_h { [it, @map.usage[[it, package]]] }
+  def usage(package) = incoming(package).to_h { [it, map.usage[[it, package]]] }
 
   def constants(edge)
     from, to = edge.deconstruct
-    @map.usage[[from, to]].sort
+    map.usage[[from, to]].sort
   end
 
   def metric(package)
@@ -59,5 +59,12 @@ class Hashira::Coupling::Graph
 
   private
 
-  def dependencies = @map.dependencies
+  def map
+    @_map ||=
+      Hashira::Coupling::EdgeMap.new(@census).tap do |edges|
+        @trees.each { |file, tree| edges.record(@project.relative(file), file, tree) }
+      end
+  end
+
+  def dependencies = map.dependencies
 end

data/lib/hashira/coupling/metric.rb

@@ -13,7 +13,9 @@ module Hashira
 
         def order = [isolated? ? 1 : 0, instability]
 
-        def to_h = { tc: types, ca: afferent, ce: efferent, i: (instability unless isolated?) }
+        def to_h = counts.merge(i: (instability unless isolated?))
+
+        def counts = { tc: types, ca: afferent, ce: efferent }
 
         def cells = [types, afferent, efferent, isolated? ? "—" : format("%.2f", instability)]
       end

data/lib/hashira/coupling/naming.rb

@@ -2,13 +2,13 @@
 
 class Hashira::Coupling::Naming
   def initialize(definitions)
-    @segments = Hashira::Coupling::NamespacePrefix.infer(definitions)
+    @definitions = definitions
   end
 
-  attr_reader :segments
+  def segments = @_segments ||= Hashira::Coupling::NamespacePrefix.infer(@definitions)
 
   def strip(path)
-    return [] if @segments.first(path.length) == path
-    path.drop(@segments.length.downto(0).find { path.first(it) == @segments.last(it) })
+    return [] if segments.first(path.length) == path
+    path.drop(segments.length.downto(0).find { path.first(it) == segments.last(it) })
   end
 end

data/lib/hashira/coupling/references.rb

@@ -3,34 +3,34 @@
 require "prism"
 
 class Hashira::Coupling::References
-  def self.list(tree) = new.sightings(tree).map(&:first)
-
-  def self.sightings(tree, roots = nil) = new(roots).sightings(tree)
-
   def initialize(roots = nil)
     @roots = roots
-    @found = []
-    @scopes = [[]]
   end
 
+  def list(tree) = sightings(tree).map(&:first)
+
   def sightings(tree)
     collect(tree)
-    @found
+    found
   end
 
   private
 
-  def nesting = @scopes.last
+  def found = @_found ||= []
+
+  def scopes = @_scopes ||= [[]]
+
+  def nesting = scopes.last
 
   def collect(node, home = nesting)
     return unless node
-    return @found << sighting(node, home) if constant?(node)
+    return found << sighting(node, home) if constant?(node)
     return enter(node) if definition?(node)
     node.compact_child_nodes.each { collect(it, home) }
   end
 
   def sighting(node, home)
-    [syntax.segments(node), node.location.start_line, syntax.cbase?(node) ? nil : nesting, home]
+    [syntax.segments(node), node.location.start_line, syntax.rooted?(node) ? nil : nesting, home]
   end
 
   def syntax = Hashira::Analysis::Syntax
@@ -48,8 +48,8 @@ class Hashira::Coupling::References
   def anchor(node) = syntax.anchor(nesting, syntax.segments(node.constant_path), @roots)
 
   def inside(scope)
-    @scopes << scope
+    scopes << scope
     yield
-    @scopes.pop
+    scopes.pop
   end
 end

data/lib/hashira/coupling/report.rb

@@ -3,26 +3,24 @@
 require_relative "cycle_findings"
 require_relative "mixed_audience_findings"
 require_relative "roll_call_findings"
+require_relative "rule"
 require_relative "sdp_violation_findings"
 require_relative "wide_edge_findings"
 
 class Hashira::Coupling::Report
-  RULES = [
-    Hashira::Coupling::CycleFindings, Hashira::Coupling::SdpViolationFindings,
-    Hashira::Coupling::MixedAudienceFindings, Hashira::Coupling::WideEdgeFindings,
-    Hashira::Coupling::RollCallFindings
-  ].freeze
+  RULES = Hashira::Coupling::Rule.subclasses.sort_by(&:name).freeze
 
   def initialize(project, trees, packaging:)
     @project = project
-    @graph = Hashira::Coupling::Graph.new(project, trees, census(trees, packaging))
+    @trees = trees
+    @packaging = packaging
   end
 
-  attr_reader :graph
+  def graph = @_graph ||= Hashira::Coupling::Graph.new(@project, @trees, census)
 
-  def findings = RULES.flat_map { it.new(@project, @graph).list }
+  def findings = RULES.flat_map { it.new(@project, graph).list }
 
   private
 
-  def census(trees, packaging) = Hashira::Coupling::Census.new(@project, trees, packaging:)
+  def census = Hashira::Coupling::Census.new(@project, @trees, packaging: @packaging)
 end

data/lib/hashira/coupling/roll_call.rb

@@ -18,7 +18,7 @@ class Hashira::Coupling::RollCall
 
   private
 
-  def files = @files ||= @lists.keys.sort
+  def files = @_files ||= @lists.keys.sort
 
   def candidates
     files.combination(2).map { |one, two| @lists[one] & @lists[two] }.select { it.size >= MIN_WORDS }.uniq

data/lib/hashira/coupling/roll_call_findings.rb

@@ -12,7 +12,7 @@ class Hashira::Coupling::RollCallFindings < Hashira::Coupling::Rule
   def rolls = Hashira::Coupling::RollCall.new(lists, homes).rolls
 
   def sightings
-    @sightings ||=
+    @_sightings ||=
       graph.trees.filter_map do |file, tree|
         words = Hashira::Coupling::Words.list(tree)
         [project.relative(file), graph.charge(file), words] unless words.empty?

data/lib/hashira/coupling/roster.rb

@@ -2,28 +2,53 @@
 
 class Hashira::Coupling::Roster
   def initialize(placed)
-    @registry = Hashira::Coupling::ConstantRegistry.new
-    @types = Hash.new(0)
-    @typed = Set.new
-    counted = Set.new
-    placed.each { |definition, package| admit(definition, package, counted) }
+    @placed = placed
+  end
+
+  def registry
+    admitted
+    @_registry
   end
 
-  attr_reader :registry, :types
+  def types
+    admitted
+    @_types
+  end
 
-  def origins = @registry.origins
+  def origins = registry.origins
 
-  def type?(path) = @typed.include?(path)
+  def type?(path)
+    admitted
+    @_typed.include?(path)
+  end
 
-  def packages = @types.keys | @registry.packages
+  def packages = types.keys | registry.packages
 
   private
 
+  def admitted
+    return if @_admitted
+    @_admitted = true
+    blank
+    fill
+  end
+
+  def blank
+    @_registry = Hashira::Coupling::ConstantRegistry.new
+    @_types = Hash.new(0)
+    @_typed = Set.new
+  end
+
+  def fill
+    counted = Set.new
+    @placed.each { |definition, package| admit(definition, package, counted) }
+  end
+
   def admit(definition, package, counted)
     return unless package
     path = definition.path
-    @registry.register(path, package)
-    @typed << path if definition.type?
-    @types[package] += 1 if definition.counted? && counted.add?(path)
+    @_registry.register(path, package)
+    @_typed << path if definition.type?
+    @_types[package] += 1 if definition.counted? && counted.add?(path)
   end
 end

data/lib/hashira/coupling/rule.rb

@@ -10,7 +10,7 @@ class Hashira::Coupling::Rule
 
   attr_reader :project, :graph
 
-  def metrics = @metrics ||= graph.metrics
+  def metrics = @_metrics ||= graph.metrics
 
   def finding(**attributes)
     Hashira::Analysis::Finding.new(kind: self.class::KIND, cycle: nil, **attributes)

data/lib/hashira/coupling/sdp_violation_findings.rb

@@ -5,6 +5,8 @@ require_relative "rule"
 class Hashira::Coupling::SdpViolationFindings < Hashira::Coupling::Rule
   KIND = "sdp_violation"
 
+  Imbalance = Data.define(:from, :to, :from_instability, :to_instability)
+
   def list
     ranked.map { |from, to| violation(from, to) }
   end
@@ -18,7 +20,7 @@ class Hashira::Coupling::SdpViolationFindings < Hashira::Coupling::Rule
   end
 
   def detail(from, to)
-    { from:, to:, from_instability: instability(from), to_instability: instability(to) }
+    Imbalance.new(from:, to:, from_instability: instability(from), to_instability: instability(to))
   end
 
   def instability(package) = metrics[package].instability

data/lib/hashira/duplication/clones.rb

@@ -7,7 +7,7 @@ class Hashira::Duplication::Clones
     @churn = churn
   end
 
-  def clusters = @clusters ||= Hashira::Duplication::Clusters.new(fragments).sorted
+  def clusters = @_clusters ||= Hashira::Duplication::Clusters.new(fragments).sorted
 
   def findings = clusters.map { |cluster| Hashira::Duplication::DuplicationFinding.new(cluster, @churn).to_finding }
 

data/lib/hashira/duplication/clusters.rb

@@ -7,20 +7,23 @@ class Hashira::Duplication::Clusters
   PAIR = 2
   PENALTY_PER_RECURRENCE = 2
 
-  def initialize(fragments)
-    @fragments = fragments.select { |fragment| fragment.mass >= PREFILTER }
-    @sets = Hashira::Duplication::UnionFind.new
+  def initialize(all)
+    @all = all
   end
 
   def sorted
-    @fragments.group_by(&:types).each_value { |group| chain(group) }
-    Hashira::Duplication::NearMiss.new(@fragments).pairs.each { |left, right| @sets.union(left, right) }
+    fragments.group_by(&:types).each_value { |group| chain(group) }
+    Hashira::Duplication::NearMiss.new(fragments).pairs.each { |left, right| sets.union(left, right) }
     Hashira::Duplication::Maximal.new(sized).reduced.sort_by { -it.mass }
   end
 
   private
 
-  def chain(group) = group.each_cons(2) { |left, right| @sets.union(left, right) }
+  def fragments = @_fragments ||= @all.select { |fragment| fragment.mass >= PREFILTER }
+
+  def sets = @_sets ||= Hashira::Duplication::UnionFind.new
+
+  def chain(group) = group.each_cons(2) { |left, right| sets.union(left, right) }
 
   def sized = built.filter_map { admitted(it) }
 
@@ -30,7 +33,7 @@ class Hashira::Duplication::Clusters
 
   def core(cluster) = Hashira::Duplication::Grouping.new(cluster.identical).cluster
 
-  def built = @sets.clusters.filter_map { |group| Hashira::Duplication::Grouping.new(group).cluster }
+  def built = sets.clusters.filter_map { |group| Hashira::Duplication::Grouping.new(group).cluster }
 
   def floor(cluster) = base(cluster) + penalty(cluster)
 

data/lib/hashira/duplication/delta.rb

@@ -11,10 +11,7 @@ class Hashira::Duplication::Delta
   end
 
   def to_h
-    {
-      mass: @cluster.mass, sites: @cluster.size, kind:,
-      locations: @cluster.sites.sort_by(&:rank).map(&:range)
-    }
+    { mass: @cluster.mass, sites: @cluster.size, kind: }.merge(locations: @cluster.sites.sort_by(&:rank).map(&:range))
   end
 
   private

data/lib/hashira/duplication/duplication_finding.rb

@@ -3,6 +3,8 @@
 class Hashira::Duplication::DuplicationFinding
   KIND = "duplication"
 
+  Overlap = Data.define(:size, :mass, :kind, :hot)
+
   def initialize(cluster, churn)
     @cluster = cluster
     @churn = churn
@@ -16,10 +18,10 @@ class Hashira::Duplication::DuplicationFinding
   private
 
   def detail
-    {
+    Overlap.new(
       size: @cluster.size, mass: @cluster.mass,
       kind: Hashira::Duplication::Delta.new(@cluster).kind, hot: @churn.hot?(@cluster.sites)
-    }
+    )
   end
 
   def evidence = @cluster.sites.sort_by(&:rank).map(&:range)

data/lib/hashira/duplication/fragment.rb

@@ -12,7 +12,7 @@ class Hashira::Duplication::Fragment
 
   attr_reader :file
 
-  def types = @types ||= nodes.map(&:type)
+  def types = @_types ||= nodes.map(&:type)
 
   def digest = Digest::SHA256.hexdigest(shape).slice(0, DIGEST_LENGTH)
 
@@ -34,5 +34,5 @@ class Hashira::Duplication::Fragment
 
   def touches?(others) = others.any? { overlaps?(it) }
 
-  def nodes = @nodes ||= @roots.flat_map { Hashira::Analysis::NodeWalk.collect(it) }
+  def nodes = @_nodes ||= @roots.flat_map { Hashira::Analysis::NodeWalk.collect(it) }
 end

data/lib/hashira/duplication/harvest.rb

@@ -7,19 +7,21 @@ class Hashira::Duplication::Harvest
 
   def initialize(project, trees)
     @project = project
-    @fragments = trees.flat_map { |path, tree| scan(@project.relative(path), tree) }
+    @trees = trees
   end
 
-  attr_reader :fragments
+  def fragments = @_fragments ||= @trees.flat_map { |path, tree| scan(@project.relative(path), tree) }
 
   private
 
-  def scan(rel, tree)
+  def scan(relative, tree)
     nodes = Hashira::Analysis::NodeWalk.collect(tree)
-    windows(rel, nodes) + wholes(nodes).map { Hashira::Duplication::Fragment.new(rel, [it]) }
+    windows(relative, nodes) + wholes(nodes).map { Hashira::Duplication::Fragment.new(relative, [it]) }
   end
 
-  def windows(rel, nodes) = runs(nodes).flat_map { Hashira::Duplication::Sequence.new(rel, it).fragments }
+  def windows(relative, nodes)
+    runs(nodes).flat_map { Hashira::Duplication::Sequence.new(relative, it).fragments }
+  end
 
   def runs(nodes) = nodes.filter_map { it.body if it.is_a?(Prism::StatementsNode) }
 

data/lib/hashira/duplication/index.rb

@@ -6,13 +6,14 @@ class Hashira::Duplication::Index
 
   def initialize(fragments)
     @fragments = fragments
-    @frequency = frequencies(fragments)
   end
 
   def buckets = grouped.values.select { |bucket| bucket.size.between?(2, MAX_BUCKET) }
 
   private
 
+  def frequency = @_frequency ||= frequencies(@fragments)
+
   def frequencies(fragments)
     fragments.each_with_object(Hash.new(0)) { |fragment, counts| tally(counts, fragment) }
   end
@@ -27,5 +28,5 @@ class Hashira::Duplication::Index
 
   def file(index, fragment) = rarest(fragment).each { |type| index[type] << fragment }
 
-  def rarest(fragment) = fragment.types.uniq.min_by(RARE) { @frequency[it] }
+  def rarest(fragment) = fragment.types.uniq.min_by(RARE) { frequency[it] }
 end

data/lib/hashira/duplication/similarity.rb

@@ -8,7 +8,7 @@ class Hashira::Duplication::Similarity
 
   def ratio
     return 0.0 if @left.empty? || @right.empty?
-    normalized(lcs)
+    normalized(subsequence)
   end
 
   def meets?(threshold) = ceiling >= threshold && ratio >= threshold
@@ -29,7 +29,7 @@ class Hashira::Duplication::Similarity
     true
   end
 
-  def lcs = @left.reduce(blank) { |prev, token| advance(prev, token) }.last
+  def subsequence = @left.reduce(blank) { |prev, token| advance(prev, token) }.last
 
   def blank = Array.new(@right.size + 1, 0)
 

data/lib/hashira/duplication/variance.rb

@@ -27,7 +27,7 @@ class Hashira::Duplication::Variance
 
   def pairs = @canonical.nodes.zip(@other.nodes)
 
-  def named = @named ||= pairs.select { |left, _| NAMED.include?(left.type) }
+  def named = @_named ||= pairs.select { |left, _| NAMED.include?(left.type) }
 
   def differing = pairs.select { |pair| varies?(*pair) }.map(&:first)
 

data/lib/hashira/error.rb

@@ -1,7 +1,4 @@
 # frozen_string_literal: true
 
 class Hashira::Error < StandardError
-  def self.unknown(flag, value, choices)
-    new("unknown #{flag} #{value.inspect} (use: #{choices.join(", ")})")
-  end
 end

data/lib/hashira/focus.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Hashira::Focus
+  SITE = /\A(?<path>[^\s:]+\.rb):/
+
+  def initialize(project, paths)
+    @project = project
+    @paths = paths
+  end
+
+  def narrowing? = !@paths.empty?
+
+  def narrow(findings)
+    return findings unless narrowing?
+    findings.select { named?(it) }
+  end
+
+  private
+
+  def wanted = @_wanted ||= @paths.select { covered?(it) }.map { @project.relative(it) }
+
+  def covered?(path) = @project.directories.any? { path.start_with?("#{it}/") }
+
+  def named?(finding) = sites(finding).any? { wanted.include?(it) }
+
+  def sites(finding) = quotes(finding).filter_map { SITE.match(it)&.[](:path) }
+
+  def quotes(finding) = [finding.package, finding.detail.to_h[:site], *finding.evidence].compact
+end

data/lib/hashira/git_log.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Hashira::GitLog
+  LOG = %w[log --no-renames --name-only --format=].freeze
+
+  def initialize(directory)
+    @directory = directory
+  end
+
+  def counts = output.split("\n").map(&:strip).reject(&:empty?).tally
+
+  private
+
+  def output
+    IO.popen(["git", "-C", @directory, *LOG], err: File::NULL, &:read)
+  rescue SystemCallError
+    ""
+  end
+end

data/lib/hashira/hotspots/file_cost.rb

@@ -12,7 +12,7 @@ module Hashira
 
         def heat = [churn, CHURN_FLOOR].max
 
-        def to_h = { file:, cognitive:, duplication:, churn:, cost:, rank: }
+        def to_h = super.merge(cost:, rank:)
 
         def cells = [file, cognitive, duplication, churn, rank]
       end

data/lib/hashira/hotspots/rollup.rb

@@ -23,9 +23,9 @@ class Hashira::Hotspots::Rollup
 
   def clusters = @duplication ? @duplication.clusters : []
 
-  def cognitive = @cognitive ||= bucketed(scores.map { [it.file, it.cognitive] })
+  def cognitive = @_cognitive ||= bucketed(scores.map { [it.file, it.cognitive] })
 
-  def duplicated = @duplicated ||= bucketed(clusters.flat_map(&:masses))
+  def duplicated = @_duplicated ||= bucketed(clusters.flat_map(&:masses))
 
   def bucketed(charges) = charges.each_with_object(Hash.new(0)) { |(file, cost), total| total[file] += cost }
 end

data/lib/hashira/pipeline.rb

@@ -10,50 +10,58 @@ class Hashira::Pipeline
   STRUCTURAL = Hashira::Coupling::Report::RULES.map { it::KIND }.freeze
 
   SMELLS = (
-    Hashira::Smells::Report::CHECKS.map(&:kind) + [Hashira::Smells::BoundarySprawl::KIND]
+    Hashira::Smells::Report::CHECKS.map { Hashira::Smells::Kind.new(it).to_s } + [Hashira::Smells::BoundarySprawl::KIND]
   ).sort.freeze
 
-  def initialize(project, enabled: ANALYZERS, packaging: :auto)
+  def initialize(project, enabled: ANALYZERS, packaging: :auto, only: [])
     @project = project
     @enabled = enabled
-    @parsed = Hashira::Trees.new(project)
-    @coupling = Hashira::Coupling::Report.new(project, @parsed.all, packaging: settle(packaging))
+    @packaging = packaging
+    @only = only
   end
 
   attr_reader :project
 
-  def unparsed = @parsed.unparsed
+  def unparsed = parsed.unparsed
 
-  def graph = @coupling.graph
+  def graph = coupling.graph
 
-  def complexity = @complexity ||= analyzed(:complexity, Hashira::Complexity::Scores)
+  def complexity = @_complexity ||= analyzed(:complexity, Hashira::Complexity::Scores)
 
-  def duplication = @duplication ||= analyzed(:duplication, Hashira::Duplication::Clones, churn)
+  def duplication = @_duplication ||= analyzed(:duplication, Hashira::Duplication::Clones, churn)
 
-  def smells = @smells ||= analyzed(:smells, Hashira::Smells::Report)
+  def smells = @_smells ||= analyzed(:smells, Hashira::Smells::Report)
 
   def hotspots
-    @hotspots ||= Hashira::Hotspots::Rollup.new(complexity, duplication, churn) if complexity || duplication
+    @_hotspots ||= Hashira::Hotspots::Rollup.new(complexity, duplication, churn) if complexity || duplication
   end
 
-  def churn = @churn ||= Hashira::Churn.scan(@project.directories.first)
+  def churn = @_churn ||= Hashira::Churn.build(@project.directories.first)
 
   def enabled?(analyzer) = @enabled.include?(analyzer)
 
   def analyzed(name, kind, *extra)
-    kind.new(@project, @parsed.all, *extra) if enabled?(name)
+    kind.new(@project, parsed.all, *extra) if enabled?(name)
   end
 
-  def findings = structural + listed(complexity) + listed(duplication) + listed(smells)
+  def findings = focus.narrow(structural + listed(complexity) + listed(duplication) + listed(smells))
+
+  def focus = @_focus ||= Hashira::Focus.new(@project, @only)
 
   private
 
+  def parsed = @_parsed ||= Hashira::Trees.new(@project)
+
+  def coupling
+    @_coupling ||= Hashira::Coupling::Report.new(@project, parsed.all, packaging: settle(@packaging))
+  end
+
   def settle(packaging)
     return packaging unless packaging == :auto
     @project.rails? ? :namespace : :folder
   end
 
-  def structural = enabled?(:coupling) ? @coupling.findings : []
+  def structural = enabled?(:coupling) ? coupling.findings : []
 
   def listed(analyzer) = analyzer ? analyzer.findings : []
 end