hashira 0.4.0 → 0.5.0

data/lib/hashira/smells/check.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Hashira::Smells::Check
+  def initialize(subject)
+    @subject = subject
+  end
+
+  def finding
+    return unless smelly?
+    Hashira::Analysis::Finding.new(kind:, package: label, detail:, evidence:)
+  end
+
+  private
+
+  attr_reader :subject
+
+  def kind = self.class.name.split("::").last.gsub(/(?<=[a-z])(?=[A-Z])/, "_").downcase
+
+  def label = subject.subject
+
+  def site = subject.site
+
+  def detail = { site: }
+
+  def spots(nodes) = "#{subject.file}:#{nodes.map { it.location.start_line }.uniq.join(", ")}"
+
+  def evidence = []
+
+  def tally(name, lines) = "#{name} (line#{"s" if lines.size > 1} #{lines.join(", ")})"
+end

data/lib/hashira/smells/conditions.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Hashira::Smells::Conditions
+  TESTED = [Prism::IfNode, Prism::UnlessNode, Prism::CaseNode, Prism::AndNode, Prism::OrNode].freeze
+
+  module_function
+
+  def tested?(node) = TESTED.include?(node.class)
+
+  def fence?(node) = Hashira::Smells::Scope::FENCES.include?(node.class)
+
+  def couple?(node) = node.is_a?(Prism::AndNode) || node.is_a?(Prism::OrNode)
+
+  def condition(node)
+    case node
+    when Prism::IfNode, Prism::UnlessNode, Prism::CaseNode then node.predicate
+    when Prism::AndNode, Prism::OrNode then node.left
+    end
+  end
+
+  def branches(node)
+    return fork(node) if node.is_a?(Prism::IfNode) || node.is_a?(Prism::UnlessNode)
+    return node.conditions + [node.consequent] if node.is_a?(Prism::CaseNode)
+    couple?(node) ? [node.right] : [node.body]
+  end
+
+  def fork(node)
+    [node.statements, node.is_a?(Prism::IfNode) ? node.subsequent : node.else_clause]
+  end
+
+  def nested(roots) = roots.compact.flat_map { seek(it) }
+
+  def seek(node)
+    return [node] if tested?(node)
+    fence?(node) ? [] : node.compact_child_nodes.flat_map { seek(it) }
+  end
+
+  def plain(node)
+    return [] if tested?(node) || fence?(node)
+    [node] + node.compact_child_nodes.flat_map { plain(it) }
+  end
+end

data/lib/hashira/smells/contexts.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Hashira
+  module Smells
+    module Parameters
+      NAMELESS = [Prism::ForwardingParameterNode, Prism::ImplicitRestNode, Prism::NoKeywordsParameterNode].freeze
+
+      module_function
+
+      def names(def_node) = parts(def_node).flat_map { expand(it) }
+
+      def arguments(def_node) = parts(def_node).grep_v(Prism::BlockParameterNode).flat_map { expand(it) }
+
+      def parts(def_node)
+        node = def_node.parameters
+        return [] unless node
+        node.requireds + node.optionals + node.posts + node.keywords +
+          [node.rest, node.keyword_rest, node.block].compact
+      end
+
+      def expand(part)
+        case part
+        when Prism::MultiTargetNode then pieces(part).flat_map { expand(it) }
+        when *NAMELESS then []
+        else [part.name].compact
+        end
+      end
+
+      def pieces(part) = part.lefts + Array(part.rest&.expression) + part.rights
+    end
+
+    MethodContext =
+      Data.define(:owner, :node, :file, :section) do
+        def subject = "#{owner}#{singleton? ? "." : "#"}#{node.name}"
+
+        def line = node.location.start_line
+
+        def singleton? = node.receiver.is_a?(Prism::Node) || section == :singleton
+
+        def mixin? = section == :module_function
+
+        def public? = section == :public && !singleton?
+
+        def parameters = Parameters.names(node)
+
+        def arguments = Parameters.arguments(node)
+
+        def site = "#{file}:#{line}"
+      end
+
+    TypeContext =
+      Data.define(:name, :node, :kind, :file, :defs) do
+        def line = node.location.start_line
+
+        def subject = name
+
+        def owned = defs.reject(&:singleton?)
+
+        def site = "#{file}:#{line}"
+      end
+  end
+end

data/lib/hashira/smells/control_parameter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Hashira::Smells::ControlParameter < Hashira::Smells::Check
+  private
+
+  def smelly? = culprits.any?
+
+  def culprits = @culprits ||= subject.parameters.filter_map { |name| culprit(name) }
+
+  def culprit(name)
+    lines = spots(name).uniq
+    [name, lines] unless lines.empty?
+  end
+
+  def spots(name)
+    Hashira::Smells::ParamCheck.new(subject.node, name).matches.map { it.location.start_line }
+  end
+
+  def detail = { site:, names: culprits.map { |name, _lines| name } }
+
+  def evidence = culprits.map { |name, lines| tally(name, lines) }
+end

data/lib/hashira/smells/data_clump.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Hashira::Smells::DataClump < Hashira::Smells::Check
+  MAX_COPIES = 2
+
+  MIN_SIZE = 2
+
+  private
+
+  def smelly? = clumps.any?
+
+  def candidates = @candidates ||= subject.owned.map { [it, it.arguments.sort] }
+
+  def clumps = @clumps ||= shared.map { |clump| [clump, holders(clump)] }
+
+  def shared = candidates.combination(MAX_COPIES + 1).filter_map { |group| clump(group) }.uniq
+
+  def clump(group)
+    names = group.map(&:last).inject(:&)
+    names if names.size >= MIN_SIZE
+  end
+
+  def holders(clump) = candidates.filter_map { |method, names| method if (clump - names).empty? }
+
+  def evidence = clumps.map { |clump, holders| row(clump, holders) }
+
+  def row(clump, holders)
+    "(#{clump.join(", ")}) → #{holders.size} methods: #{holders.map { |holder| holder.node.name }.join(", ")}"
+  end
+end

data/lib/hashira/smells/duplicate_method_call.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Smells::DuplicateMethodCall < Hashira::Smells::Check
+  LIMIT = 1
+
+  private
+
+  def smelly? = repeats.any?
+
+  def calls = @calls ||= Hashira::Smells::Scope.inside(subject.node).grep(Prism::CallNode)
+
+  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)
+  end
+
+  def usual
+    calls.reject { plain?(it) || it.name == :new }
+      .group_by { handle(it) }.select { |_handle, group| group.size > LIMIT }
+  end
+
+  def whole
+    @whole ||=
+      calls.select { it.block.is_a?(Prism::BlockNode) }
+        .group_by { it.slice.gsub(/\s+/, " ") }.select { |_handle, group| group.size > LIMIT }
+  end
+
+  def handle(node) = "#{title(node)}#{signature(node)}"
+
+  def title(node)
+    [node.receiver&.slice, node.name].compact.join(node.safe_navigation? ? "&." : ".")
+  end
+
+  def signature(node)
+    wrap(([node.arguments&.slice] + pass(node.block)).compact)
+  end
+
+  def pass(block) = block.is_a?(Prism::BlockArgumentNode) ? [block.slice] : []
+
+  def wrap(parts) = parts.empty? ? "" : "(#{parts.join(", ")})"
+
+  def evidence
+    repeats.map { |handle, nodes| "#{handle} × #{nodes.size} (#{stamp(lines(nodes))})" }
+  end
+
+  def lines(nodes) = nodes.map { it.location.start_line }.uniq
+
+  def stamp(lines) = "line#{"s" if lines.size > 1} #{lines.join(", ")}"
+end

data/lib/hashira/smells/feature_envy.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Hashira::Smells::FeatureEnvy < Hashira::Smells::Check
+  private
+
+  def smelly?
+    !subject.singleton? && !subject.mixin? && refs.ego.positive? && envied.any?
+  end
+
+  def refs = @refs ||= Hashira::Smells::Refs.new(subject.node)
+
+  def envied = @envied ||= refs.envious
+
+  def detail = { site:, names: envied }
+
+  def evidence = envied.map { |name| tally(name, refs.lines(name).uniq) }
+end

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.4.0"
+  VERSION = "0.5.0"
 end