hashira 0.3.0 → 0.5.0

data/lib/hashira/smells/instance_variable_assumption.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+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,
+    Prism::ConstantOrWriteNode, Prism::ConstantPathOrWriteNode,
+    Prism::CallOrWriteNode, Prism::IndexOrWriteNode
+  ].freeze
+
+  module Harvest
+    module_function
+
+    def reads(node)
+      return [] if MAYBES.include?(node.class)
+      below = node.compact_child_nodes.flat_map { reads(it) }
+      node.is_a?(Prism::InstanceVariableReadNode) ? below + [node.name] : below
+    end
+  end
+
+  private
+
+  def smelly? = subject.kind == :class && assumed.any?
+
+  def assumed = @assumed ||= (read - prepared).uniq.sort
+
+  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/manual_dispatch.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Smells::ManualDispatch < Hashira::Smells::Check
+  private
+
+  def smelly? = sightings.any?
+
+  def sightings
+    @sightings ||= Hashira::Smells::Scope.inside(subject.node)
+      .select { it.is_a?(Prism::CallNode) && it.name == :respond_to? }
+  end
+
+  def detail = { site: spots(sightings) }
+end

data/lib/hashira/smells/module_initialize.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Hashira::Smells::ModuleInitialize < Hashira::Smells::Check
+  private
+
+  def smelly? = subject.kind == :module && flagged
+
+  def flagged = subject.owned.any? { it.node.name == :initialize }
+end

data/lib/hashira/smells/nil_check.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Smells::NilCheck < Hashira::Smells::Check
+  EQUALITY = %i[== ===].freeze
+
+  private
+
+  def smelly? = checks.any?
+
+  def checks = @checks ||= Hashira::Smells::Scope.inside(subject.node).select { check?(it) }
+
+  def check?(node)
+    case node
+    when Prism::CallNode then query?(node)
+    when Prism::WhenNode then node.conditions.any?(Prism::NilNode)
+    else false
+    end
+  end
+
+  def query?(node)
+    name = node.name
+    name == :nil? || (EQUALITY.include?(name) && equated?(node))
+  end
+
+  def equated?(node) = sides(node).any?(Prism::NilNode)
+
+  def sides(node) = [node.receiver] + (node.arguments&.arguments || [])
+
+  def detail = { site: spots(checks) }
+end

data/lib/hashira/smells/param_check.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Smells::ParamCheck
+  COMPARISONS = %i[== != =~].freeze
+
+  def initialize(node, name)
+    @node = node
+    @name = name
+  end
+
+  def matches
+    return [] if legitimate?
+    nested.flat_map(&:matches) + tested
+  end
+
+  def legitimate?
+    absolved? || working? || nested.any?(&:legitimate?)
+  end
+
+  private
+
+  def nested
+    @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))
+  end
+
+  def spread(condition) = condition ? Hashira::Analysis::NodeWalk.collect(condition) : []
+
+  def tested = reads(predicate)
+
+  def working?
+    reads(branches.compact.flat_map { Hashira::Smells::Conditions.plain(it) }).any?
+  end
+
+  def absolved?
+    predicate.grep(Prism::CallNode).any? { absolves?(it) }
+  end
+
+  def absolves?(call)
+    !COMPARISONS.include?(call.name) && reads(Hashira::Analysis::NodeWalk.collect(call)).any?
+  end
+
+  def reads(nodes) = nodes.grep(Prism::LocalVariableReadNode).select { it.name == @name }
+end

data/lib/hashira/smells/refs.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Smells::Refs
+  SELVES = [
+    Prism::SelfNode, Prism::SuperNode, Prism::ForwardingSuperNode,
+    Prism::InstanceVariableReadNode, Prism::InstanceVariableWriteNode,
+    Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableAndWriteNode,
+    Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableTargetNode
+  ].freeze
+
+  def initialize(def_node)
+    @tallies = {}
+    Hashira::Smells::Scope.inside(def_node).each { record(it) }
+  end
+
+  def ego = lines(:self).size
+
+  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 }
+    names.include?(:self) ? [] : names
+  end
+
+  private
+
+  def record(node)
+    return note(:self, node) if selfish?(node)
+    case node
+    when Prism::CallNode then named(node)
+    when Prism::LocalVariableOperatorWriteNode then note(node.name, node)
+    end
+  end
+
+  def selfish?(node)
+    SELVES.include?(node.class) || implicit?(node)
+  end
+
+  def implicit?(node) = node.is_a?(Prism::CallNode) && !node.receiver
+
+  def named(node)
+    case (receiver = node.receiver)
+    when Prism::SelfNode then note(:self, node)
+    when Prism::LocalVariableReadNode, Prism::LocalVariableWriteNode
+      note(receiver.name, node) unless node.name == :new
+    end
+  end
+
+  def note(name, node) = (@tallies[name] ||= []) << node.location.start_line
+end

data/lib/hashira/smells/repeated_conditional.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Smells::RepeatedConditional < Hashira::Smells::Check
+  LIMIT = 2
+
+  private
+
+  def smelly? = subject.kind == :class && repeats.any?
+
+  def repeats
+    @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) }
+
+  def predicate(node)
+    node.predicate if node.is_a?(Prism::IfNode) || node.is_a?(Prism::UnlessNode) || node.is_a?(Prism::CaseNode)
+  end
+
+  def detail = { site:, count: repeats.values.map(&:size).max }
+
+  def evidence = repeats.map { |test, nodes| row(test, nodes) }
+
+  def row(test, nodes)
+    "#{test} × #{nodes.size} (lines #{nodes.map { |node| node.location.start_line }.join(", ")})"
+  end
+end

data/lib/hashira/smells/report.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class Hashira::Smells::Report
+  def initialize(project, trees)
+    @types = Hashira::Smells::Census.new(project, trees).types
+  end
+
+  def findings = @findings ||= sniff(@types, judges) + sniff(@types.flat_map(&:defs), probes)
+
+  private
+
+  def sniff(subjects, checks) = subjects.flat_map { |subject| verdicts(subject, checks) }
+
+  def verdicts(subject, checks) = checks.filter_map { |check| check.new(subject).finding }
+
+  def judges
+    [
+      Hashira::Smells::DataClump, Hashira::Smells::InstanceVariableAssumption,
+      Hashira::Smells::ModuleInitialize, Hashira::Smells::RepeatedConditional,
+      Hashira::Smells::TooManyInstanceVariables
+    ]
+  end
+
+  def probes
+    [
+      Hashira::Smells::ControlParameter, Hashira::Smells::DuplicateMethodCall,
+      Hashira::Smells::FeatureEnvy, Hashira::Smells::ManualDispatch,
+      Hashira::Smells::NilCheck, Hashira::Smells::UtilityFunction
+    ]
+  end
+end

data/lib/hashira/smells/scope.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Hashira::Smells::Scope
+  TYPES = [Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode].freeze
+
+  FENCES = (TYPES + [Prism::DefNode]).freeze
+
+  module_function
+
+  def inside(node) = below(node, FENCES)
+
+  def sweep(node) = below(node, TYPES)
+
+  def below(root, fences)
+    found = []
+    visit(root, fences) { found << it }
+    found
+  end
+
+  def visit(root, fences, &)
+    root.compact_child_nodes.each do |child|
+      next if fences.include?(child.class)
+      yield(child)
+      visit(child, fences, &)
+    end
+  end
+end

data/lib/hashira/smells/too_many_instance_variables.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Smells::TooManyInstanceVariables < Hashira::Smells::Check
+  LIMIT = 4
+
+  COUNTED = [
+    Prism::InstanceVariableWriteNode, Prism::InstanceVariableAndWriteNode,
+    Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableTargetNode
+  ].freeze
+
+  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
+  end
+
+  def detail = { site:, count: names.size }
+
+  def evidence = names.map(&:to_s)
+end

data/lib/hashira/smells/utility_function.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Smells::UtilityFunction < Hashira::Smells::Check
+  private
+
+  def smelly? = subject.public? && calls? && refs.ego.zero?
+
+  def refs = Hashira::Smells::Refs.new(subject.node)
+
+  def calls? = Hashira::Smells::Scope.inside(subject.node).any?(Prism::CallNode)
+end

data/lib/hashira/smells/visibility.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Smells::Visibility
+  MARKERS = %i[public private protected module_function].freeze
+
+  def initialize(type_node)
+    @section = :public
+    @overrides = {}
+    @found = []
+    scan(statements(type_node))
+  end
+
+  def entries = @found.map { |node, section| [node, @overrides.fetch(node.name, section)] }
+
+  private
+
+  def statements(node)
+    body = node.body
+    body.is_a?(Prism::StatementsNode) ? body.body : []
+  end
+
+  def scan(nodes) = nodes.each { classify(it) }
+
+  def classify(node)
+    case node
+    when Prism::DefNode then @found << [node, @section]
+    when Prism::CallNode then heed(node)
+    else descend(node)
+    end
+  end
+
+  def descend(node)
+    case node
+    when Prism::SingletonClassNode then shadow(node)
+    when Prism::ClassNode, Prism::ModuleNode, Prism::ConstantWriteNode then nil
+    else scan(node.compact_child_nodes)
+    end
+  end
+
+  def heed(node)
+    bare?(node) ? switch(node.name, node.arguments) : scan(node.compact_child_nodes)
+  end
+
+  def bare?(node) = MARKERS.include?(node.name) && !node.receiver
+
+  def switch(name, arguments)
+    arguments ? tag(name, arguments.arguments) : (@section = name)
+  end
+
+  def tag(section, arguments) = arguments.each { note(it, section) }
+
+  def note(argument, section)
+    case argument
+    when Prism::DefNode then @found << [argument, section]
+    when Prism::SymbolNode then @overrides[argument.unescaped.to_sym] = section
+    end
+  end
+
+  def shadow(node)
+    statements(node).each { @found << [it, :singleton] if it.is_a?(Prism::DefNode) }
+  end
+end

data/lib/hashira/version.rb

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

data/lib/hashira.rb

@@ -1,78 +1,149 @@
 # frozen_string_literal: true
 
-require_relative "hashira/version"
-require_relative "hashira/error"
-require_relative "hashira/project"
-require_relative "hashira/churn"
-require_relative "hashira/analysis/syntax"
+module Hashira
+  module Analysis
+  end
+
+  module CI
+  end
+
+  module Coupling
+  end
+
+  module Complexity
+  end
+
+  module Diagram
+  end
+
+  module Duplication
+  end
+
+  module Hotspots
+  end
+
+  module Report
+  end
+
+  module Smells
+  end
+end
+
+require_relative "hashira/analysis/finding"
 require_relative "hashira/analysis/node_walk"
+require_relative "hashira/analysis/syntax"
 require_relative "hashira/analysis/type_walk"
-require_relative "hashira/analysis/references"
-require_relative "hashira/analysis/definitions"
-require_relative "hashira/analysis/namespace_prefix"
-require_relative "hashira/analysis/constant_registry"
-require_relative "hashira/analysis/census"
-require_relative "hashira/analysis/edge"
-require_relative "hashira/analysis/edge_map"
-require_relative "hashira/analysis/metric"
-require_relative "hashira/analysis/sdp_check"
-require_relative "hashira/analysis/cycle_search"
-require_relative "hashira/analysis/graph"
-require_relative "hashira/analysis/finding"
-require_relative "hashira/analysis/rule"
-require_relative "hashira/analysis/cycle_findings"
-require_relative "hashira/analysis/sdp_violation_findings"
-require_relative "hashira/complexity/method_score"
-require_relative "hashira/complexity/rollup"
-require_relative "hashira/complexity/if_chain"
+require_relative "hashira/churn"
+require_relative "hashira/ci/accepted"
+require_relative "hashira/ci/baseline"
+require_relative "hashira/ci/diff"
+require_relative "hashira/ci/edge_diff_report"
+require_relative "hashira/ci/finding_diff_report"
+require_relative "hashira/ci/gate"
+require_relative "hashira/ci/improvement"
+require_relative "hashira/ci/ratchet"
+require_relative "hashira/ci/ratchet_report"
+require_relative "hashira/cli"
+require_relative "hashira/cli/arguments"
+require_relative "hashira/cli/command_line"
+require_relative "hashira/cli/fail_on"
+require_relative "hashira/cli/options"
+require_relative "hashira/cli/package_by"
+require_relative "hashira/cli/run"
+require_relative "hashira/cli/skip"
+require_relative "hashira/cli/usage"
 require_relative "hashira/complexity/boolean_run"
-require_relative "hashira/complexity/rescue_scan"
 require_relative "hashira/complexity/cognitive_score"
+require_relative "hashira/complexity/if_chain"
 require_relative "hashira/complexity/method_finding"
-require_relative "hashira/complexity/analyzer"
-require_relative "hashira/duplication/fragment"
-require_relative "hashira/duplication/sequence"
-require_relative "hashira/duplication/extractor"
-require_relative "hashira/duplication/similarity"
-require_relative "hashira/duplication/union_find"
+require_relative "hashira/complexity/method_score"
+require_relative "hashira/complexity/rescue_scan"
+require_relative "hashira/complexity/rollup"
+require_relative "hashira/complexity/scores"
+require_relative "hashira/coupling/audiences"
+require_relative "hashira/coupling/catalog"
+require_relative "hashira/coupling/census"
+require_relative "hashira/coupling/constant_registry"
+require_relative "hashira/coupling/cycle_findings"
+require_relative "hashira/coupling/cycle_search"
+require_relative "hashira/coupling/cycles"
+require_relative "hashira/coupling/definition"
+require_relative "hashira/coupling/definitions"
+require_relative "hashira/coupling/edge"
+require_relative "hashira/coupling/edge_map"
+require_relative "hashira/coupling/folder_placement"
+require_relative "hashira/coupling/folding"
+require_relative "hashira/coupling/graph"
+require_relative "hashira/coupling/metric"
+require_relative "hashira/coupling/mixed_audience_findings"
+require_relative "hashira/coupling/namespace_placement"
+require_relative "hashira/coupling/namespace_prefix"
+require_relative "hashira/coupling/naming"
+require_relative "hashira/coupling/no_folding"
+require_relative "hashira/coupling/placement"
+require_relative "hashira/coupling/references"
+require_relative "hashira/coupling/report"
+require_relative "hashira/coupling/roll_call"
+require_relative "hashira/coupling/roll_call_findings"
+require_relative "hashira/coupling/roster"
+require_relative "hashira/coupling/rule"
+require_relative "hashira/coupling/scope"
+require_relative "hashira/coupling/sdp_check"
+require_relative "hashira/coupling/sdp_violation_findings"
+require_relative "hashira/coupling/wide_edge_findings"
+require_relative "hashira/coupling/words"
+require_relative "hashira/diagram/dot"
+require_relative "hashira/diagram/mermaid"
+require_relative "hashira/diagram/source"
+require_relative "hashira/duplication/clones"
 require_relative "hashira/duplication/cluster"
+require_relative "hashira/duplication/clusters"
+require_relative "hashira/duplication/delta"
+require_relative "hashira/duplication/duplication_finding"
+require_relative "hashira/duplication/fragment"
 require_relative "hashira/duplication/grouping"
+require_relative "hashira/duplication/harvest"
 require_relative "hashira/duplication/index"
-require_relative "hashira/duplication/near_miss"
 require_relative "hashira/duplication/maximal"
-require_relative "hashira/duplication/clusterer"
+require_relative "hashira/duplication/near_miss"
+require_relative "hashira/duplication/sequence"
+require_relative "hashira/duplication/similarity"
+require_relative "hashira/duplication/union_find"
 require_relative "hashira/duplication/variance"
-require_relative "hashira/duplication/delta"
-require_relative "hashira/duplication/duplication_finding"
-require_relative "hashira/duplication/analyzer"
-require_relative "hashira/diagram/dot"
-require_relative "hashira/diagram/mermaid"
-require_relative "hashira/diagram/renderer"
-require_relative "hashira/ci/accepted"
-require_relative "hashira/ci/baseline"
-require_relative "hashira/ci/diff"
-require_relative "hashira/ci/improvement"
-require_relative "hashira/ci/edge_diff_report"
-require_relative "hashira/ci/finding_diff_report"
-require_relative "hashira/ci/ratchet_report"
-require_relative "hashira/ci/gate"
-require_relative "hashira/ci/ratchet"
+require_relative "hashira/error"
 require_relative "hashira/hotspots/file_cost"
 require_relative "hashira/hotspots/rollup"
-require_relative "hashira/report/view"
-require_relative "hashira/report/graph_payload"
-require_relative "hashira/report/finding_lines"
-require_relative "hashira/report/dependency_map"
-require_relative "hashira/report/metrics_table"
+require_relative "hashira/pipeline"
+require_relative "hashira/project"
 require_relative "hashira/report/complexity_table"
+require_relative "hashira/report/dependency_map"
+require_relative "hashira/report/finding_lines"
+require_relative "hashira/report/graph_payload"
 require_relative "hashira/report/hotspot_table"
 require_relative "hashira/report/json"
+require_relative "hashira/report/metrics_table"
+require_relative "hashira/report/phrases"
+require_relative "hashira/report/smell_phrases"
 require_relative "hashira/report/text"
-require_relative "hashira/pipeline"
-require_relative "hashira/cli"
-require_relative "hashira/cli/fail_on"
-require_relative "hashira/cli/skip"
-require_relative "hashira/cli/options"
-require_relative "hashira/cli/command_line"
-require_relative "hashira/cli/usage"
-require_relative "hashira/cli/run"
+require_relative "hashira/report/view"
+require_relative "hashira/smells/census"
+require_relative "hashira/smells/check"
+require_relative "hashira/smells/conditions"
+require_relative "hashira/smells/contexts"
+require_relative "hashira/smells/control_parameter"
+require_relative "hashira/smells/data_clump"
+require_relative "hashira/smells/duplicate_method_call"
+require_relative "hashira/smells/feature_envy"
+require_relative "hashira/smells/instance_variable_assumption"
+require_relative "hashira/smells/manual_dispatch"
+require_relative "hashira/smells/module_initialize"
+require_relative "hashira/smells/nil_check"
+require_relative "hashira/smells/param_check"
+require_relative "hashira/smells/refs"
+require_relative "hashira/smells/repeated_conditional"
+require_relative "hashira/smells/report"
+require_relative "hashira/smells/scope"
+require_relative "hashira/smells/too_many_instance_variables"
+require_relative "hashira/smells/utility_function"
+require_relative "hashira/smells/visibility"
+require_relative "hashira/version"