hashira 0.6.0 → 0.8.0

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/diagram/dot.rb

@@ -1,13 +1,16 @@
 # frozen_string_literal: true
 
 class Hashira::Diagram::Dot
-  def initialize(edges)
+  def initialize(edges, packages)
     @edges = edges
+    @packages = packages
   end
 
-  def source
-    "digraph hashira {\n  rankdir=LR;\n#{@edges.map do |from, to, weight|
-      %(  "#{from}" -> "#{to}" [label="#{weight}"];)
-    end.join("\n")}\n}"
-  end
+  def source = "digraph hashira {\n  rankdir=LR;\n#{lines.join("\n")}\n}"
+
+  private
+
+  def lines = @packages.map { %(  "#{it}";) } + @edges.map { |from, to, weight| link(from, to, weight) }
+
+  def link(from, to, weight) = %(  "#{from}" -> "#{to}" [label="#{weight}"];)
 end

data/lib/hashira/diagram/mermaid.rb

@@ -1,18 +1,21 @@
 # frozen_string_literal: true
 
 class Hashira::Diagram::Mermaid
-  def initialize(edges)
+  def initialize(edges, packages)
     @edges = edges
-    @nodes = {}
+    @packages = packages
+    @ids = {}
   end
 
-  def source
-    "graph LR\n#{@edges.map { |from, to, weight| "  #{node(from)} -->|#{weight}| #{node(to)}" }.join("\n")}"
-  end
+  def source = "graph LR\n#{lines.join("\n")}"
 
   private
 
-  def node(package)
-    @nodes[package] ||= "#{package.gsub(/\W/, "_")}[\"#{package}\"]"
-  end
+  def lines = @packages.map { "  #{declare(it)}" } + @edges.map { |from, to, weight| link(from, to, weight) }
+
+  def link(from, to, weight) = "  #{id(from)} -->|#{weight}| #{id(to)}"
+
+  def declare(package) = "#{id(package)}[#{package.to_json}]"
+
+  def id(package) = @ids[package] ||= "p#{@ids.size}"
 end

data/lib/hashira/diagram/source.rb

@@ -8,8 +8,11 @@ class Hashira::Diagram::Source
   end
 
   def print
-    edges = @graph.weighted
-    @io.puts((@format == :dot ? Hashira::Diagram::Dot.new(edges) : Hashira::Diagram::Mermaid.new(edges)).source)
+    @io.puts(drawing.new(@graph.weighted, @graph.packages.sort).source)
     0
   end
+
+  private
+
+  def drawing = @format == :dot ? Hashira::Diagram::Dot : Hashira::Diagram::Mermaid
 end

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,56 +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
-    @trees = project.files.to_h { [it, parse(it)] }
-    @coupling = Hashira::Coupling::Report.new(project, @trees, packaging: settle(packaging))
+    @packaging = packaging
+    @only = only
   end
 
   attr_reader :project
 
-  def graph = @coupling.graph
+  def unparsed = parsed.unparsed
 
-  def complexity
-    @complexity ||= Hashira::Complexity::Scores.new(@project, @trees) if enabled?(:complexity)
-  end
+  def graph = coupling.graph
 
-  def duplication
-    @duplication ||= Hashira::Duplication::Clones.new(@project, @trees, churn) if enabled?(:duplication)
-  end
+  def complexity = @_complexity ||= analyzed(:complexity, Hashira::Complexity::Scores)
 
-  def smells
-    @smells ||= Hashira::Smells::Report.new(@project, @trees) if enabled?(:smells)
-  end
+  def duplication = @_duplication ||= analyzed(:duplication, Hashira::Duplication::Clones, churn)
+
+  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
+  def churn = @_churn ||= Hashira::Churn.build(@project.directories.first)
 
   def enabled?(analyzer) = @enabled.include?(analyzer)
 
-  def findings = structural + listed(complexity) + listed(duplication) + listed(smells)
+  def analyzed(name, kind, *extra)
+    kind.new(@project, parsed.all, *extra) if enabled?(name)
+  end
+
+  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 : []
-
-  def parse(path)
-    Prism.parse_file(path).value
-  rescue SystemCallError => error
-    raise(Hashira::Error, "cannot read #{path} (#{error.message})")
-  end
 end