hashira 0.7.0 → 0.9.0

data/lib/hashira/smells/census.rb

@@ -6,18 +6,23 @@ class Hashira::Smells::Census
   def initialize(project, trees)
     @project = project
     @trees = trees
-    @ownership = Hashira::Smells::Ownership.new(trees.values)
   end
 
-  attr_reader :ownership
+  def ownership = @_ownership ||= Hashira::Smells::Ownership.new(@trees.values)
 
-  def types = @trees.flat_map { |path, tree| harvest(@project.relative(path), tree) }
+  def types = @_types ||= placed(@trees.flat_map { |path, tree| harvest(@project.relative(path), tree) })
 
   private
 
+  def placed(found) = settled(found, Hashira::Smells::Lineage.new(found))
+
+  def settled(found, lineage) = found.map { it.with(assigned: lineage.assigned(it)) }
+
+  def roots = @_roots ||= Hashira::Analysis::TypeWalk.roots(@trees)
+
   def harvest(file, tree)
     found = []
-    Hashira::Analysis::TypeWalk.each(tree) { |node, full| found << context(file, node, full.join("::")) }
+    Hashira::Analysis::TypeWalk.each(tree, roots:) { |node, full| found << context(file, node, full.join("::")) }
     found
   end
 
@@ -28,8 +33,8 @@ class Hashira::Smells::Census
   def kind(node) = node.is_a?(Prism::ModuleNode) ? :module : :class
 
   def defs(name, node, file)
-    Hashira::Smells::Visibility.new(node).entries.map do |def_node, section|
-      Hashira::Smells::MethodContext.new(owner: name, node: def_node, file:, section:, ownership: @ownership)
+    Hashira::Smells::Visibility.new(node).entries.map do |definition, section|
+      Hashira::Smells::MethodContext.new(owner: name, node: definition, file:, section:, ownership:)
     end
   end
 end

data/lib/hashira/smells/check.rb

@@ -1,10 +1,6 @@
 # frozen_string_literal: true
 
 class Hashira::Smells::Check
-  def self.kind = name.split("::").last.gsub(/(?<=[a-z])(?=[A-Z])/, "_").downcase
-
-  def self.judge? = false
-
   def initialize(subject)
     @subject = subject
   end
@@ -18,7 +14,7 @@ class Hashira::Smells::Check
 
   attr_reader :subject
 
-  def kind = self.class.kind
+  def kind = Hashira::Smells::Kind.new(self.class).to_s
 
   def label = subject.subject
 

data/lib/hashira/smells/contexts.rb

@@ -9,12 +9,12 @@ module Hashira
 
       module_function
 
-      def names(def_node) = parts(def_node).flat_map { expand(it) }
+      def names(definition) = parts(definition).flat_map { expand(it) }
 
-      def arguments(def_node) = parts(def_node).grep_v(Prism::BlockParameterNode).flat_map { expand(it) }
+      def arguments(definition) = parts(definition).grep_v(Prism::BlockParameterNode).flat_map { expand(it) }
 
-      def parts(def_node)
-        node = def_node.parameters
+      def parts(definition)
+        node = definition.parameters
         return [] unless node
         node.requireds + node.optionals + node.posts + node.keywords +
           [node.rest, node.keyword_rest, node.block].compact
@@ -51,7 +51,9 @@ module Hashira
       end
 
     TypeContext =
-      Data.define(:name, :node, :kind, :file, :defs) do
+      Data.define(:name, :node, :kind, :file, :defs, :assigned) do
+        def initialize(assigned: nil, **rest) = super
+
         def line = node.location.start_line
 
         def subject = name

data/lib/hashira/smells/control_parameter.rb

@@ -5,7 +5,7 @@ class Hashira::Smells::ControlParameter < Hashira::Smells::Check
 
   def smelly? = culprits.any?
 
-  def culprits = @culprits ||= subject.parameters.filter_map { |name| culprit(name) }
+  def culprits = @_culprits ||= subject.parameters.filter_map { |name| culprit(name) }
 
   def culprit(name)
     lines = spots(name).uniq

data/lib/hashira/smells/data_clump.rb

@@ -5,15 +5,13 @@ class Hashira::Smells::DataClump < Hashira::Smells::Check
 
   MIN_SIZE = 2
 
-  def self.judge? = true
-
   private
 
   def smelly? = clumps.any?
 
-  def candidates = @candidates ||= subject.owned.map { [it, it.arguments.sort] }
+  def candidates = @_candidates ||= subject.owned.map { [it, it.arguments.sort] }
 
-  def clumps = @clumps ||= shared.map { |clump| [clump, holders(clump)] }
+  def clumps = @_clumps ||= shared.map { |clump| [clump, holders(clump)] }
 
   def shared = candidates.combination(MAX_COPIES + 1).filter_map { |group| clump(group) }.uniq
 

data/lib/hashira/smells/duplicate_method_call.rb

@@ -5,27 +5,47 @@ require "prism"
 class Hashira::Smells::DuplicateMethodCall < Hashira::Smells::Check
   LIMIT = 1
 
+  MINTS = %i[new dup clone allocate rand srand].freeze
+
+  SOURCES = %w[SecureRandom Random].freeze
+
+  LITERALS = [
+    Prism::StringNode, Prism::SymbolNode, Prism::ArrayNode, Prism::HashNode,
+    Prism::IntegerNode, Prism::FloatNode, Prism::RegularExpressionNode
+  ].freeze
+
   private
 
   def smelly? = repeats.any?
 
-  def calls = @calls ||= Hashira::Smells::Scope.inside(subject.node).grep(Prism::CallNode)
+  def calls
+    @_calls ||= Hashira::Smells::Scope.inside(subject.node).grep(Prism::CallNode).reject { minted?(it) }
+  end
+
+  def minted?(node) = mints?(node.name) || spawns?(node.receiver)
+
+  def mints?(name) = MINTS.include?(name)
+
+  def spawns?(receiver) = LITERALS.include?(receiver.class) || SOURCES.include?(receiver&.slice)
 
   def plain?(node)
     !node.receiver && !node.arguments && !node.block.is_a?(Prism::BlockArgumentNode)
   end
 
   def repeats
-    @repeats ||= usual.reject { |_handle, nodes| whole.value?(nodes) }.merge(whole)
+    @_repeats ||= together(usual.reject { |_handle, nodes| whole.value?(nodes) }.merge(whole))
   end
 
+  def together(groups) = groups.select { |_handle, nodes| branches.together?(nodes) }
+
+  def branches = @_branches ||= Hashira::Smells::Branches.new(subject.node)
+
   def usual
-    calls.reject { plain?(it) || it.name == :new }
-      .group_by { handle(it) }.select { |_handle, group| group.size > LIMIT }
+    calls.reject { plain?(it) }.group_by { handle(it) }.select { |_handle, group| group.size > LIMIT }
   end
 
   def whole
-    @whole ||=
+    @_whole ||=
       calls.select { it.block.is_a?(Prism::BlockNode) }
         .group_by { it.slice.gsub(/\s+/, " ") }.select { |_handle, group| group.size > LIMIT }
   end

data/lib/hashira/smells/feature_envy.rb

@@ -7,11 +7,11 @@ class Hashira::Smells::FeatureEnvy < Hashira::Smells::Check
     !subject.singleton? && !subject.mixin? && refs.ego.positive? && envied.any?
   end
 
-  def refs = @refs ||= Hashira::Smells::Refs.new(subject.node)
+  def refs = @_refs ||= Hashira::Smells::Refs.new(subject.node)
 
-  def envied = @envied ||= refs.envious.reject { foreign.dismiss?(it) }
+  def envied = @_envied ||= refs.envious.reject { foreign.dismiss?(it) }
 
-  def foreign = @foreign ||= Hashira::Smells::Foreign.new(subject, subject.ownership)
+  def foreign = @_foreign ||= Hashira::Smells::Foreign.new(subject, subject.ownership)
 
   def detail = { site:, names: envied }
 

data/lib/hashira/smells/foreign.rb

@@ -18,9 +18,7 @@ class Hashira::Smells::Foreign
   ].freeze
 
   def initialize(subject, ownership)
-    node = subject.node
-    @body = Hashira::Smells::Scope.inside(node)
-    @tail = tail(node)
+    @subject = subject
     @ownership = ownership
   end
 
@@ -35,12 +33,16 @@ class Hashira::Smells::Foreign
 
   private
 
+  def body = @_body ||= Hashira::Smells::Scope.inside(@subject.node)
+
+  def tail = @_tail ||= Hashira::Analysis::Syntax.statements(@subject.node).compact.last
+
   def convert?
-    @tail.is_a?(Prism::CallNode) && @tail.name == :new &&
-      Hashira::Analysis::Syntax.segments(@tail.receiver).any? && stateless?
+    tail.is_a?(Prism::CallNode) && tail.name == :new &&
+      Hashira::Analysis::Syntax.segments(tail.receiver).any? && stateless?
   end
 
-  def stateless? = @body.none? { STATE.include?(it.class) }
+  def stateless? = body.none? { STATE.include?(it.class) }
 
   def fenced?(name)
     tested = tests { it == name }
@@ -48,7 +50,7 @@ class Hashira::Smells::Foreign
   end
 
   def wire?(name)
-    calls = @body.grep(Prism::CallNode).select { |call| local?(call.receiver) { it == name } }
+    calls = body.grep(Prism::CallNode).select { |call| local?(call.receiver) { it == name } }
     calls.any? && calls.all? { keyed?(it) } && reassignments(name).none?
   end
 
@@ -75,11 +77,11 @@ class Hashira::Smells::Foreign
   def reassignments(name) = among(Prism::LocalVariableOperatorWriteNode, name)
 
   def among(kind, name)
-    @body.grep(kind).select { it.name == name }
+    body.grep(kind).select { it.name == name }
   end
 
   def snares(name)
-    @body.grep(Prism::RescueNode).select { it.reference&.name == name }
+    body.grep(Prism::RescueNode).select { it.reference&.name == name }
   end
 
   def alien?(exceptions)
@@ -107,15 +109,15 @@ class Hashira::Smells::Foreign
   end
 
   def probes(&)
-    @body.grep(Prism::CallNode).select { TYPE_TESTS.include?(it.name) && local?(it.receiver, &) }.filter_map { key(it) }
+    body.grep(Prism::CallNode).select { TYPE_TESTS.include?(it.name) && local?(it.receiver, &) }.filter_map { key(it) }
   end
 
   def arms(&)
-    @body.grep(Prism::CaseNode).select { local?(it.predicate, &) }.flat_map(&:conditions).flat_map(&:conditions)
+    body.grep(Prism::CaseNode).select { local?(it.predicate, &) }.flat_map(&:conditions).flat_map(&:conditions)
   end
 
   def lookups(&)
-    @body.grep(Prism::CallNode).select { it.name == :[] && sorts?(key(it), &) }.flat_map { @ownership.keys(Hashira::Analysis::Syntax.segments(it.receiver)) }
+    body.grep(Prism::CallNode).select { it.name == :[] && sorts?(key(it), &) }.flat_map { @ownership.keys(Hashira::Analysis::Syntax.segments(it.receiver)) }
   end
 
   def sorts?(argument, &)
@@ -126,6 +128,4 @@ class Hashira::Smells::Foreign
   def local?(node, &) = node.is_a?(Prism::LocalVariableReadNode) && yield(node.name)
 
   def key(call) = call.arguments&.arguments&.first
-
-  def tail(def_node) = Hashira::Analysis::Syntax.statements(def_node).compact.last
 end

data/lib/hashira/smells/instance_variable_assumption.rb

@@ -3,12 +3,6 @@
 require "prism"
 
 class Hashira::Smells::InstanceVariableAssumption < Hashira::Smells::Check
-  SETTERS = [
-    Prism::InstanceVariableWriteNode, Prism::InstanceVariableOrWriteNode,
-    Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableOperatorWriteNode,
-    Prism::InstanceVariableTargetNode
-  ].freeze
-
   MAYBES = [
     Prism::LocalVariableOrWriteNode, Prism::InstanceVariableOrWriteNode,
     Prism::ClassVariableOrWriteNode, Prism::GlobalVariableOrWriteNode,
@@ -26,21 +20,17 @@ class Hashira::Smells::InstanceVariableAssumption < Hashira::Smells::Check
     end
   end
 
-  def self.judge? = true
-
   private
 
-  def smelly? = subject.kind == :class && assumed.any?
+  def smelly? = subject.kind == :class && assigned && assumed.any?
 
-  def assumed = @assumed ||= (read - prepared).uniq.sort
+  def assigned = subject.assigned
 
-  def read = subject.owned.flat_map { Harvest.reads(it.node) }
+  def assumed = @_assumed ||= (read - assigned).uniq.sort.reject { cache?(it) }
 
-  def prepared
-    starters.flat_map { Hashira::Smells::Scope.inside(it.node) }.select { SETTERS.include?(it.class) }.map(&:name)
-  end
+  def cache?(name) = name.start_with?("@_")
 
-  def starters = subject.owned.select { it.node.name == :initialize }
+  def read = subject.owned.flat_map { Harvest.reads(it.node) }
 
   def evidence = assumed.map(&:to_s)
 end

data/lib/hashira/smells/kind.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Hashira::Smells::Kind
+  def initialize(check)
+    @check = check
+  end
+
+  def to_s = @check.name.split("::").last.gsub(/(?<=[a-z])(?=[A-Z])/, "_").downcase
+end

data/lib/hashira/smells/lineage.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Smells::Lineage
+  MIXINS = %i[include prepend].freeze
+
+  EXTENSIONS = %i[extend].freeze
+
+  WRITERS = %i[attr_writer attr_accessor].freeze
+
+  SETTERS = [
+    Prism::InstanceVariableWriteNode, Prism::InstanceVariableOrWriteNode,
+    Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableOperatorWriteNode,
+    Prism::InstanceVariableTargetNode
+  ].freeze
+
+  def initialize(types)
+    @types = types
+  end
+
+  def assigned(context) = kin(context)&.flat_map { writes(it) }&.uniq
+
+  private
+
+  def index = @_index ||= @types.group_by(&:name)
+
+  def kin(context) = walk([context.name], [])&.flat_map { index.fetch(it) }
+
+  def walk(queue, known)
+    return known if queue.empty?
+    name, *rest = queue
+    return walk(rest, known) if known.include?(name)
+    onward(rest, known + [name], parents(index.fetch(name)))
+  end
+
+  def onward(queue, known, found)
+    walk(queue + found, known) if found
+  end
+
+  def parents(kin)
+    found = kin.flat_map { pointed(it) }
+    found unless found.include?(nil) || kin.any? { opaque?(it) }
+  end
+
+  def opaque?(type) = extensions(type).any? { !resolve(type.name, Hashira::Analysis::Syntax.segments(it)) }
+
+  def extensions(type) = named(type, EXTENSIONS)
+
+  def pointed(type) = references(type).map { resolve(type.name, it) }
+
+  def references(type)
+    (named(type, MIXINS) + [parent(type)].compact).map { Hashira::Analysis::Syntax.segments(it) }
+  end
+
+  def parent(type) = (type.node.superclass if type.kind == :class)
+
+  def resolve(owner, segments) = candidates(owner, segments).find { index.key?(it) }
+
+  def candidates(owner, segments)
+    segments.empty? ? [] : scopes(owner).map { (it + segments).join("::") }
+  end
+
+  def scopes(owner)
+    parts = owner.split("::")
+    parts.size.downto(0).map { parts.first(it) }
+  end
+
+  def writes(type)
+    definitions(type).flat_map { setters(it) } + attributes(type)
+  end
+
+  def definitions(type) = sweep(type).grep(Prism::DefNode).reject(&:receiver)
+
+  def setters(node) = Hashira::Smells::Scope.sweep(node).select { SETTERS.include?(it.class) }.map(&:name)
+
+  def attributes(type)
+    named(type, WRITERS).select { it.is_a?(Prism::SymbolNode) || it.is_a?(Prism::StringNode) }.map { :"@#{it.unescaped}" }
+  end
+
+  def named(type, names) = passed(calls(type).select { names.include?(it.name) })
+
+  def passed(calls) = calls.flat_map { it.arguments.arguments }
+
+  def calls(type) = sweep(type).grep(Prism::CallNode).reject(&:receiver).select(&:arguments)
+
+  def sweep(type) = swept.fetch(type.node) { store(it) }
+
+  def store(node) = swept[node] = Hashira::Smells::Scope.sweep(node)
+
+  def swept = @_swept ||= {}.compare_by_identity
+end

data/lib/hashira/smells/manual_dispatch.rb

@@ -8,7 +8,7 @@ class Hashira::Smells::ManualDispatch < Hashira::Smells::Check
   def smelly? = sightings.any?
 
   def sightings
-    @sightings ||= Hashira::Smells::Scope.inside(subject.node)
+    @_sightings ||= Hashira::Smells::Scope.inside(subject.node)
       .select { it.is_a?(Prism::CallNode) && it.name == :respond_to? }
   end
 

data/lib/hashira/smells/module_initialize.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 class Hashira::Smells::ModuleInitialize < Hashira::Smells::Check
-  def self.judge? = true
-
   private
 
   def smelly? = subject.kind == :module && flagged

data/lib/hashira/smells/nil_check.rb

@@ -9,7 +9,7 @@ class Hashira::Smells::NilCheck < Hashira::Smells::Check
 
   def smelly? = checks.any?
 
-  def checks = @checks ||= Hashira::Smells::Scope.inside(subject.node).select { check?(it) }
+  def checks = @_checks ||= Hashira::Smells::Scope.inside(subject.node).select { check?(it) }
 
   def check?(node)
     case node

data/lib/hashira/smells/ownership.rb

@@ -2,17 +2,29 @@
 
 class Hashira::Smells::Ownership
   def initialize(trees)
-    @suffixes = Set.new
-    @tables = {}
-    trees.each { survey(it) }
+    @trees = trees
   end
 
-  def owned?(segments) = @suffixes.include?(segments.join("::"))
+  def owned?(segments)
+    surveyed
+    @_suffixes.include?(segments.join("::"))
+  end
 
-  def keys(segments) = @tables.fetch(segments.join("::"), [])
+  def keys(segments)
+    surveyed
+    @_tables.fetch(segments.join("::"), [])
+  end
 
   private
 
+  def surveyed
+    return if @_surveyed
+    @_surveyed = true
+    @_suffixes = Set.new
+    @_tables = {}
+    @trees.each { survey(it) }
+  end
+
   def survey(tree)
     Hashira::Analysis::TypeWalk.each(tree) do |node, full|
       absorb(full)
@@ -27,14 +39,14 @@ class Hashira::Smells::Ownership
   end
 
   def absorb(path)
-    @suffixes.merge(suffixes(path))
+    @_suffixes.merge(suffixes(path))
   end
 
   def chart(path, value)
     return unless value.is_a?(Prism::HashNode)
     keys = value.elements.map { spine(it) }
     return if keys.empty? || keys.any?(&:nil?)
-    suffixes(path).each { @tables[it] = keys }
+    suffixes(path).each { @_tables[it] = keys }
   end
 
   def thaw(value)

data/lib/hashira/smells/param_check.rb

@@ -22,13 +22,13 @@ class Hashira::Smells::ParamCheck
   private
 
   def nested
-    @nested ||= Hashira::Smells::Conditions.nested(branches).map { self.class.new(it, @name) }
+    @_nested ||= Hashira::Smells::Conditions.nested(branches).map { self.class.new(it, @name) }
   end
 
   def branches = Hashira::Smells::Conditions.branches(@node)
 
   def predicate
-    @predicate ||= spread(Hashira::Smells::Conditions.condition(@node))
+    @_predicate ||= spread(Hashira::Smells::Conditions.condition(@node))
   end
 
   def spread(condition) = condition ? Hashira::Analysis::NodeWalk.collect(condition) : []

data/lib/hashira/smells/refs.rb

@@ -10,23 +10,29 @@ class Hashira::Smells::Refs
     Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableTargetNode
   ].freeze
 
-  def initialize(def_node)
-    @tallies = {}
-    Hashira::Smells::Scope.inside(def_node).each { record(it) }
+  def initialize(definition)
+    @node = definition
   end
 
   def ego = lines(:self).size
 
-  def lines(name) = @tallies.fetch(name, [])
+  def lines(name) = tallies.fetch(name, [])
 
   def envious
-    peak = @tallies.values.map(&:size).max
-    names = @tallies.filter_map { |name, sightings| name if sightings.size == peak }
+    peak = tallies.values.map(&:size).max
+    names = tallies.filter_map { |name, sightings| name if sightings.size == peak }
     names.include?(:self) ? [] : names
   end
 
   private
 
+  def tallies
+    return @_tallies if @_tallies
+    @_tallies = {}
+    Hashira::Smells::Scope.inside(@node).each { record(it) }
+    @_tallies
+  end
+
   def record(node)
     return note(:self, node) if selfish?(node)
     case node
@@ -49,5 +55,5 @@ class Hashira::Smells::Refs
     end
   end
 
-  def note(name, node) = (@tallies[name] ||= []) << node.location.start_line
+  def note(name, node) = (@_tallies[name] ||= []) << node.location.start_line
 end

data/lib/hashira/smells/repeated_conditional.rb

@@ -5,14 +5,12 @@ require "prism"
 class Hashira::Smells::RepeatedConditional < Hashira::Smells::Check
   LIMIT = 2
 
-  def self.judge? = true
-
   private
 
   def smelly? = subject.kind == :class && repeats.any?
 
   def repeats
-    @repeats ||= predicates.group_by(&:slice).except("block_given?").select { |_test, nodes| nodes.size > LIMIT }
+    @_repeats ||= predicates.group_by(&:slice).except("block_given?").select { |_test, nodes| nodes.size > LIMIT }
   end
 
   def predicates = Hashira::Smells::Scope.sweep(subject.node).filter_map { predicate(it) }

data/lib/hashira/smells/report.rb

@@ -8,6 +8,7 @@ require_relative "duplicate_method_call"
 require_relative "feature_envy"
 require_relative "foreign"
 require_relative "instance_variable_assumption"
+require_relative "kind"
 require_relative "manual_dispatch"
 require_relative "module_initialize"
 require_relative "nil_check"
@@ -19,22 +20,30 @@ require_relative "utility_function"
 class Hashira::Smells::Report
   CHECKS = Hashira::Smells::Check.subclasses.sort_by(&:name).freeze
 
-  JUDGES = CHECKS.select(&:judge?).freeze
+  JUDGES = [
+    Hashira::Smells::DataClump, Hashira::Smells::InstanceVariableAssumption,
+    Hashira::Smells::ModuleInitialize, Hashira::Smells::RepeatedConditional,
+    Hashira::Smells::TooManyInstanceVariables
+  ].freeze
 
-  PROBES = CHECKS.reject(&:judge?).freeze
+  PROBES = (CHECKS - JUDGES).freeze
 
   def initialize(project, trees)
-    @census = Hashira::Smells::Census.new(project, trees)
-    @types = @census.types
+    @project = project
+    @trees = trees
   end
 
-  def findings = @findings ||= sniff(@types, JUDGES) + sniff(methods, PROBES) + sprawl
+  def findings = @_findings ||= sniff(types, JUDGES) + sniff(methods, PROBES) + sprawl
 
   private
 
-  def methods = @types.flat_map(&:defs)
+  def census = @_census ||= Hashira::Smells::Census.new(@project, @trees)
 
-  def sprawl = Hashira::Smells::BoundarySprawl.new(methods, @census.ownership).findings
+  def types = @_types ||= census.types
+
+  def methods = types.flat_map(&:defs)
+
+  def sprawl = Hashira::Smells::BoundarySprawl.new(methods, census.ownership).findings
 
   def sniff(subjects, checks) = subjects.flat_map { |subject| verdicts(subject, checks) }
 

data/lib/hashira/smells/too_many_instance_variables.rb

@@ -10,14 +10,14 @@ class Hashira::Smells::TooManyInstanceVariables < Hashira::Smells::Check
     Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableTargetNode
   ].freeze
 
-  def self.judge? = true
-
   private
 
   def smelly? = subject.kind == :class && names.size > LIMIT
 
   def names
-    @names ||= Hashira::Smells::Scope.sweep(subject.node).select { COUNTED.include?(it.class) }.map(&:name).uniq.sort
+    @_names ||=
+      Hashira::Smells::Scope.sweep(subject.node).select { COUNTED.include?(it.class) }
+        .map(&:name).reject { it.start_with?("@_") }.uniq.sort
   end
 
   def detail = { site:, count: names.size }