hashira 0.8.0 → 0.10.0

data/lib/hashira/coupling/{mixed_audience_findings.rb → mixed_audience.rb}

@@ -2,7 +2,7 @@
 
 require_relative "rule"
 
-class Hashira::Coupling::MixedAudienceFindings < Hashira::Coupling::Rule
+class Hashira::Coupling::MixedAudience < Hashira::Coupling::Rule
   KIND = "mixed_audience"
 
   def list

data/lib/hashira/coupling/report.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_relative "cycle_findings"
-require_relative "mixed_audience_findings"
-require_relative "roll_call_findings"
+require_relative "cycle"
+require_relative "mixed_audience"
+require_relative "echo"
 require_relative "rule"
-require_relative "sdp_violation_findings"
-require_relative "wide_edge_findings"
+require_relative "imbalance"
+require_relative "wide_edge"
 
 class Hashira::Coupling::Report
   RULES = Hashira::Coupling::Rule.subclasses.sort_by(&:name).freeze

data/lib/hashira/coupling/{wide_edge_findings.rb → wide_edge.rb}

@@ -2,7 +2,7 @@
 
 require_relative "rule"
 
-class Hashira::Coupling::WideEdgeFindings < Hashira::Coupling::Rule
+class Hashira::Coupling::WideEdge < Hashira::Coupling::Rule
   KIND = "wide_edge"
 
   WIDTH = 5

data/lib/hashira/duplication/clusters.rb

@@ -19,7 +19,7 @@ class Hashira::Duplication::Clusters
 
   private
 
-  def fragments = @_fragments ||= @all.select { |fragment| fragment.mass >= PREFILTER }
+  def fragments = @_fragments ||= @all.select { |fragment| fragment.mass >= PREFILTER }.reject(&:schema?)
 
   def sets = @_sets ||= Hashira::Duplication::UnionFind.new
 

data/lib/hashira/duplication/fragment.rb

@@ -1,10 +1,17 @@
 # frozen_string_literal: true
 
 require "digest"
+require "prism"
 
 class Hashira::Duplication::Fragment
   DIGEST_LENGTH = 12
 
+  SCHEMA = %i[
+    class_node module_node statements_node arguments_node assoc_node
+    array_node hash_node keyword_hash_node constant_read_node constant_path_node
+    symbol_node string_node integer_node float_node true_node false_node nil_node
+  ].freeze
+
   def initialize(file, roots)
     @file = file
     @roots = roots
@@ -20,6 +27,8 @@ class Hashira::Duplication::Fragment
 
   def mass = types.size
 
+  def schema? = nodes.all? { directive?(it) }
+
   def line = @roots.first.location.start_line
 
   def finish = @roots.last.location.end_line
@@ -35,4 +44,13 @@ class Hashira::Duplication::Fragment
   def touches?(others) = others.any? { overlaps?(it) }
 
   def nodes = @_nodes ||= @roots.flat_map { Hashira::Analysis::NodeWalk.collect(it) }
+
+  private
+
+  def directive?(node)
+    return SCHEMA.include?(node.type) unless node.is_a?(Prism::CallNode)
+    !node.receiver && !node.block && literals?(node.arguments)
+  end
+
+  def literals?(arguments) = Hashira::Duplication::Literal.new(arguments).literals?
 end

data/lib/hashira/duplication/literal.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Duplication::Literal
+  TYPES = [
+    Prism::ArrayNode, Prism::AssocNode, Prism::FalseNode, Prism::FloatNode,
+    Prism::HashNode, Prism::IntegerNode, Prism::KeywordHashNode, Prism::NilNode,
+    Prism::StringNode, Prism::SymbolNode, Prism::TrueNode
+  ].freeze
+
+  def initialize(node)
+    @node = node
+  end
+
+  def literal? = TYPES.include?(@node.class) && parts.all?(&:literal?)
+
+  def literals? = parts.all?(&:literal?)
+
+  private
+
+  def parts = children.map { Hashira::Duplication::Literal.new(it) }
+
+  def children = Array(@node&.compact_child_nodes)
+end

data/lib/hashira/duplication/variance.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "prism"
+
 class Hashira::Duplication::Variance
   LITERALS = %i[integer_node float_node string_node symbol_node].freeze
   VALUED = %i[integer_node float_node].freeze
@@ -27,7 +29,11 @@ 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) && !inner?(left) }
+
+  def inner?(node) = nested.any? { it.equal?(node) }
+
+  def nested = @_nested ||= @canonical.nodes.grep(Prism::ConstantPathNode).filter_map(&:parent)
 
   def differing = pairs.select { |pair| varies?(*pair) }.map(&:first)
 

data/lib/hashira/pipeline.rb

@@ -22,6 +22,11 @@ class Hashira::Pipeline
 
   attr_reader :project
 
+  def verify
+    boundaries.interpreted
+    self
+  end
+
   def unparsed = parsed.unparsed
 
   def graph = coupling.graph
@@ -30,7 +35,7 @@ class Hashira::Pipeline
 
   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, boundaries)
 
   def hotspots
     @_hotspots ||= Hashira::Hotspots::Rollup.new(complexity, duplication, churn) if complexity || duplication
@@ -52,6 +57,8 @@ class Hashira::Pipeline
 
   def parsed = @_parsed ||= Hashira::Trees.new(@project)
 
+  def boundaries = @_boundaries ||= Hashira::Boundaries.new(@project.boundaries, parsed.all)
+
   def coupling
     @_coupling ||= Hashira::Coupling::Report.new(@project, parsed.all, packaging: settle(@packaging))
   end

data/lib/hashira/project.rb

@@ -3,10 +3,13 @@
 class Hashira::Project
   ROOT_PACKAGE = "(root)"
 
-  def initialize(requested)
+  def initialize(requested, boundaries: [])
     @requested = requested
+    @boundaries = boundaries
   end
 
+  attr_reader :boundaries
+
   def directories = @_directories ||= resolved
 
   def rails? = directories.any? { config?(File.expand_path(it)) }

data/lib/hashira/report/smell_phrases.rb

@@ -14,7 +14,7 @@ module Hashira::Report::Phrases
       "Introduce a parameter object."
   end
 
-  def on_duplicate_method_call(finding)
+  def on_repeated_call(finding)
     "#{finding.package} repeats identical calls (#{finding.detail[:site]}). " \
       "Name the result in a local variable."
   end
@@ -32,9 +32,9 @@ module Hashira::Report::Phrases
       "The behavior may belong on #{names.first}."
   end
 
-  def on_instance_variable_assumption(finding)
-    "#{finding.package} reads instance variables never set in initialize (#{finding.detail[:site]}). " \
-      "Assign them in initialize, or pass the data explicitly."
+  def on_assumed_state(finding)
+    "#{finding.package} reads instance variables nothing in the class assigns (#{finding.detail[:site]}). " \
+      "Assign them where the object is built, or pass the data explicitly."
   end
 
   def on_manual_dispatch(finding)
@@ -56,7 +56,7 @@ module Hashira::Report::Phrases
     tally(finding, "branches on the same test %d times", "Replace the scattered checks with polymorphism.")
   end
 
-  def on_too_many_instance_variables(finding)
+  def on_state_sprawl(finding)
     tally(finding, "holds %d instance variables", "Split the class, or gather related fields into value objects.")
   end
 

data/lib/hashira/smells/{instance_variable_assumption.rb → assumed_state.rb}

@@ -2,13 +2,7 @@
 
 require "prism"
 
-class Hashira::Smells::InstanceVariableAssumption < Hashira::Smells::Check
-  SETTERS = [
-    Prism::InstanceVariableWriteNode, Prism::InstanceVariableOrWriteNode,
-    Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableOperatorWriteNode,
-    Prism::InstanceVariableTargetNode
-  ].freeze
-
+class Hashira::Smells::AssumedState < Hashira::Smells::Check
   MAYBES = [
     Prism::LocalVariableOrWriteNode, Prism::InstanceVariableOrWriteNode,
     Prism::ClassVariableOrWriteNode, Prism::GlobalVariableOrWriteNode,
@@ -28,19 +22,15 @@ class Hashira::Smells::InstanceVariableAssumption < Hashira::Smells::Check
 
   private
 
-  def smelly? = subject.kind == :class && assumed.any?
+  def smelly? = subject.kind == :class && assigned && assumed.any?
+
+  def assigned = subject.assigned
 
-  def assumed = @_assumed ||= (read - prepared).uniq.sort.reject { cache?(it) }
+  def assumed = @_assumed ||= (read - assigned).uniq.sort.reject { cache?(it) }
 
   def cache?(name) = name.start_with?("@_")
 
   def read = subject.owned.flat_map { Harvest.reads(it.node) }
 
-  def prepared
-    starters.flat_map { Hashira::Smells::Scope.inside(it.node) }.select { SETTERS.include?(it.class) }.map(&:name)
-  end
-
-  def starters = subject.owned.select { it.node.name == :initialize }
-
   def evidence = assumed.map(&:to_s)
 end

data/lib/hashira/smells/boundary_sprawl.rb

@@ -9,13 +9,14 @@ class Hashira::Smells::BoundarySprawl
 
   SHOWN = 4
 
-  def initialize(subjects, ownership)
+  def initialize(subjects, ownership, interpreted = [])
     @subjects = subjects
     @ownership = ownership
+    @interpreted = interpreted
   end
 
   def findings
-    reaches.filter_map { |root, contexts| finding(root, contexts) }
+    reaches.except(*@interpreted).filter_map { |root, contexts| finding(root, contexts) }
   end
 
   private

data/lib/hashira/smells/branches.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Smells::Branches
+  def initialize(root)
+    @root = root
+  end
+
+  def together?(nodes) = nodes.combination(2).any? { |left, right| meet?(trail(left), trail(right)) }
+
+  private
+
+  def meet?(left, right) = shared(left, right).none? { parted?(*it) }
+
+  def shared(left, right) = left.zip(right).select(&:last)
+
+  def parted?(here, there) = here.first.equal?(there.first) && here.last != there.last
+
+  def trail(node) = trails.fetch(node)
+
+  def trails
+    return @_trails if @_trails
+    @_trails = {}.compare_by_identity
+    chart(@root, [])
+    @_trails
+  end
+
+  def chart(node, trail)
+    @_trails[node] = trail
+    node.compact_child_nodes.each { chart(it, trail + taken(node, it)) }
+  end
+
+  def taken(node, child)
+    return arm_for(node, child) if node.is_a?(Prism::BeginNode)
+    arm = arms(node).index { it.equal?(child) }
+    arm ? [[node, arm]] : []
+  end
+
+  def arm_for(node, child)
+    rescued = node.rescue_clause
+    return [] unless [node.statements, rescued, node.else_clause].any? { it.equal?(child) }
+    [[node, rescued.equal?(child) ? 1 : 0]]
+  end
+
+  def arms(node) = (clauses(node) || conditions(node)).compact
+
+  def clauses(node)
+    case node
+    when Prism::IfNode, Prism::RescueNode then [node.statements, node.subsequent]
+    when Prism::UnlessNode then [node.statements, node.else_clause]
+    when Prism::RescueModifierNode then [node.expression, node.rescue_expression]
+    end
+  end
+
+  def conditions(node)
+    case node
+    when Prism::CaseNode, Prism::CaseMatchNode then node.conditions + [node.else_clause]
+    else []
+    end
+  end
+end

data/lib/hashira/smells/census.rb

@@ -10,13 +10,19 @@ class Hashira::Smells::Census
 
   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
 

data/lib/hashira/smells/contexts.rb

@@ -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/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/{duplicate_method_call.rb → repeated_call.rb}

@@ -2,26 +2,46 @@
 
 require "prism"
 
-class Hashira::Smells::DuplicateMethodCall < Hashira::Smells::Check
+class Hashira::Smells::RepeatedCall < 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

data/lib/hashira/smells/report.rb

@@ -4,33 +4,34 @@ require_relative "boundary_sprawl"
 require_relative "check"
 require_relative "control_parameter"
 require_relative "data_clump"
-require_relative "duplicate_method_call"
+require_relative "repeated_call"
 require_relative "feature_envy"
 require_relative "foreign"
-require_relative "instance_variable_assumption"
+require_relative "assumed_state"
 require_relative "kind"
 require_relative "manual_dispatch"
 require_relative "module_initialize"
 require_relative "nil_check"
 require_relative "ownership"
 require_relative "repeated_conditional"
-require_relative "too_many_instance_variables"
+require_relative "state_sprawl"
 require_relative "utility_function"
 
 class Hashira::Smells::Report
   CHECKS = Hashira::Smells::Check.subclasses.sort_by(&:name).freeze
 
   JUDGES = [
-    Hashira::Smells::DataClump, Hashira::Smells::InstanceVariableAssumption,
+    Hashira::Smells::DataClump, Hashira::Smells::AssumedState,
     Hashira::Smells::ModuleInitialize, Hashira::Smells::RepeatedConditional,
-    Hashira::Smells::TooManyInstanceVariables
+    Hashira::Smells::StateSprawl
   ].freeze
 
   PROBES = (CHECKS - JUDGES).freeze
 
-  def initialize(project, trees)
+  def initialize(project, trees, boundaries = nil)
     @project = project
     @trees = trees
+    @boundaries = boundaries
   end
 
   def findings = @_findings ||= sniff(types, JUDGES) + sniff(methods, PROBES) + sprawl
@@ -43,7 +44,9 @@ class Hashira::Smells::Report
 
   def methods = types.flat_map(&:defs)
 
-  def sprawl = Hashira::Smells::BoundarySprawl.new(methods, census.ownership).findings
+  def sprawl = Hashira::Smells::BoundarySprawl.new(methods, census.ownership, interpreted).findings
+
+  def interpreted = @boundaries ? @boundaries.interpreted : []
 
   def sniff(subjects, checks) = subjects.flat_map { |subject| verdicts(subject, checks) }
 

data/lib/hashira/smells/{too_many_instance_variables.rb → state_sprawl.rb}

@@ -2,7 +2,7 @@
 
 require "prism"
 
-class Hashira::Smells::TooManyInstanceVariables < Hashira::Smells::Check
+class Hashira::Smells::StateSprawl < Hashira::Smells::Check
   LIMIT = 4
 
   COUNTED = [

data/lib/hashira/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hashira
-  VERSION = "0.8.0"
+  VERSION = "0.10.0"
 end