hashira 0.3.0 → 0.5.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hashira
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Giacomo GK
@@ -26,22 +26,8 @@ files:
 - README.md
 - exe/hashira
 - lib/hashira.rb
-- lib/hashira/analysis/census.rb
-- lib/hashira/analysis/constant_registry.rb
-- lib/hashira/analysis/cycle_findings.rb
-- lib/hashira/analysis/cycle_search.rb
-- lib/hashira/analysis/definitions.rb
-- lib/hashira/analysis/edge.rb
-- lib/hashira/analysis/edge_map.rb
 - lib/hashira/analysis/finding.rb
-- lib/hashira/analysis/graph.rb
-- lib/hashira/analysis/metric.rb
-- lib/hashira/analysis/namespace_prefix.rb
 - lib/hashira/analysis/node_walk.rb
-- lib/hashira/analysis/references.rb
-- lib/hashira/analysis/rule.rb
-- lib/hashira/analysis/sdp_check.rb
-- lib/hashira/analysis/sdp_violation_findings.rb
 - lib/hashira/analysis/syntax.rb
 - lib/hashira/analysis/type_walk.rb
 - lib/hashira/churn.rb
@@ -55,13 +41,14 @@ files:
 - lib/hashira/ci/ratchet.rb
 - lib/hashira/ci/ratchet_report.rb
 - lib/hashira/cli.rb
+- lib/hashira/cli/arguments.rb
 - lib/hashira/cli/command_line.rb
 - lib/hashira/cli/fail_on.rb
 - lib/hashira/cli/options.rb
+- lib/hashira/cli/package_by.rb
 - lib/hashira/cli/run.rb
 - lib/hashira/cli/skip.rb
 - lib/hashira/cli/usage.rb
-- lib/hashira/complexity/analyzer.rb
 - lib/hashira/complexity/boolean_run.rb
 - lib/hashira/complexity/cognitive_score.rb
 - lib/hashira/complexity/if_chain.rb
@@ -69,17 +56,50 @@ files:
 - lib/hashira/complexity/method_score.rb
 - lib/hashira/complexity/rescue_scan.rb
 - lib/hashira/complexity/rollup.rb
+- lib/hashira/complexity/scores.rb
+- lib/hashira/coupling/audiences.rb
+- lib/hashira/coupling/catalog.rb
+- lib/hashira/coupling/census.rb
+- lib/hashira/coupling/constant_registry.rb
+- lib/hashira/coupling/cycle_findings.rb
+- lib/hashira/coupling/cycle_search.rb
+- lib/hashira/coupling/cycles.rb
+- lib/hashira/coupling/definition.rb
+- lib/hashira/coupling/definitions.rb
+- lib/hashira/coupling/edge.rb
+- lib/hashira/coupling/edge_map.rb
+- lib/hashira/coupling/folder_placement.rb
+- lib/hashira/coupling/folding.rb
+- lib/hashira/coupling/graph.rb
+- lib/hashira/coupling/metric.rb
+- lib/hashira/coupling/mixed_audience_findings.rb
+- lib/hashira/coupling/namespace_placement.rb
+- lib/hashira/coupling/namespace_prefix.rb
+- lib/hashira/coupling/naming.rb
+- lib/hashira/coupling/no_folding.rb
+- lib/hashira/coupling/placement.rb
+- lib/hashira/coupling/references.rb
+- lib/hashira/coupling/report.rb
+- lib/hashira/coupling/roll_call.rb
+- lib/hashira/coupling/roll_call_findings.rb
+- lib/hashira/coupling/roster.rb
+- lib/hashira/coupling/rule.rb
+- lib/hashira/coupling/scope.rb
+- lib/hashira/coupling/sdp_check.rb
+- lib/hashira/coupling/sdp_violation_findings.rb
+- lib/hashira/coupling/wide_edge_findings.rb
+- lib/hashira/coupling/words.rb
 - lib/hashira/diagram/dot.rb
 - lib/hashira/diagram/mermaid.rb
-- lib/hashira/diagram/renderer.rb
-- lib/hashira/duplication/analyzer.rb
+- lib/hashira/diagram/source.rb
+- lib/hashira/duplication/clones.rb
 - lib/hashira/duplication/cluster.rb
-- lib/hashira/duplication/clusterer.rb
+- lib/hashira/duplication/clusters.rb
 - lib/hashira/duplication/delta.rb
 - lib/hashira/duplication/duplication_finding.rb
-- lib/hashira/duplication/extractor.rb
 - lib/hashira/duplication/fragment.rb
 - lib/hashira/duplication/grouping.rb
+- lib/hashira/duplication/harvest.rb
 - lib/hashira/duplication/index.rb
 - lib/hashira/duplication/maximal.rb
 - lib/hashira/duplication/near_miss.rb
@@ -99,8 +119,30 @@ files:
 - lib/hashira/report/hotspot_table.rb
 - lib/hashira/report/json.rb
 - lib/hashira/report/metrics_table.rb
+- lib/hashira/report/phrases.rb
+- lib/hashira/report/smell_phrases.rb
 - lib/hashira/report/text.rb
 - lib/hashira/report/view.rb
+- lib/hashira/smells/census.rb
+- lib/hashira/smells/check.rb
+- lib/hashira/smells/conditions.rb
+- lib/hashira/smells/contexts.rb
+- lib/hashira/smells/control_parameter.rb
+- lib/hashira/smells/data_clump.rb
+- lib/hashira/smells/duplicate_method_call.rb
+- lib/hashira/smells/feature_envy.rb
+- lib/hashira/smells/instance_variable_assumption.rb
+- lib/hashira/smells/manual_dispatch.rb
+- lib/hashira/smells/module_initialize.rb
+- lib/hashira/smells/nil_check.rb
+- lib/hashira/smells/param_check.rb
+- lib/hashira/smells/refs.rb
+- lib/hashira/smells/repeated_conditional.rb
+- lib/hashira/smells/report.rb
+- lib/hashira/smells/scope.rb
+- lib/hashira/smells/too_many_instance_variables.rb
+- lib/hashira/smells/utility_function.rb
+- lib/hashira/smells/visibility.rb
 - lib/hashira/version.rb
 homepage: https://github.com/giacope/hashira
 licenses:

data/lib/hashira/analysis/census.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Hashira
-  module Analysis
-    class Census
-      def initialize(project, trees)
-        @definitions = Definitions.new(project, trees)
-        @type_count = Hash.new(0)
-        @registry = ConstantRegistry.new
-        @namespace_prefix = NamespacePrefix.infer(@definitions)
-        take
-      end
-
-      attr_reader :type_count, :namespace_prefix
-
-      def declaring_package = @registry.declaring_package
-
-      def packages = (@type_count.keys | @definitions.packages)
-
-      def resolve(segments) = @registry.package_for(after_prefix(segments))
-
-      private
-
-      def take
-        @definitions.each do |node, full, package|
-          @registry.register(after_prefix(full), package)
-          @type_count[package] += 1 unless Syntax.direct_definitions(node).empty?
-        end
-      end
-
-      def after_prefix(segments)
-        return [] if @namespace_prefix.first(segments.length) == segments
-
-        depth = @namespace_prefix.length.downto(0).find { segments.first(it) == @namespace_prefix.last(it) }
-        segments.drop(depth)
-      end
-    end
-  end
-end

data/lib/hashira/analysis/constant_registry.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Hashira
-  module Analysis
-    class ConstantRegistry
-      AMBIGUOUS = Object.new.freeze
-
-      def initialize
-        @declaring_package = {}
-        @shorthand = {}
-      end
-
-      attr_reader :declaring_package
-
-      def register(path, package)
-        return if path.empty?
-
-        claim(@declaring_package, path, package)
-        (1...path.length).each { claim(@shorthand, path.drop(it), package) }
-      end
-
-      def package_for(path)
-        found = path.length.downto(1).filter_map { claimed(path.first(it)) }.first
-        found unless found == AMBIGUOUS
-      end
-
-      private
-
-      def claim(claims, path, package)
-        key = path.join("::")
-        claims[key] = claims.fetch(key, package) == package ? package : AMBIGUOUS
-      end
-
-      def claimed(path)
-        key = path.join("::")
-        @declaring_package[key] || @shorthand[key]
-      end
-    end
-  end
-end

data/lib/hashira/analysis/cycle_findings.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Hashira
-  module Analysis
-    class CycleFindings < Rule
-      KIND = "cycle"
-
-      def list
-        graph.packages.select { graph.cyclic?(it) }.sort.map { cycle_finding(it) }
-      end
-
-      private
-
-      def cycle_finding(package)
-        path = graph.cycle_path(package)
-        finding(package:, cycle: path, evidence: evidence(path),
-                message: message(package, path, graph.weakest_edge(path)))
-      end
-
-      def message(package, path, weak_edge)
-        weak_from, weak_to = weak_edge
-        weight = graph.weight(weak_from, weak_to)
-        "#{package} can reach itself: #{path.join(" -> ")} — any change may ripple back " \
-          "around. The lightest edge on this cycle is #{weak_from} -> #{weak_to} " \
-          "(#{weight} ref#{"s" unless weight == 1})."
-      end
-
-      def evidence(path)
-        path.each_cons(2).flat_map { |from, to| graph.evidence_for(from, to).to_a.first(2) }
-      end
-    end
-  end
-end

data/lib/hashira/analysis/cycle_search.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Hashira
-  module Analysis
-    class CycleSearch
-      def initialize(dependencies, package)
-        @dependencies = dependencies
-        @package = package
-        @predecessor = {}
-        @queue = dependencies[package].to_a.each { @predecessor[it] = package }
-      end
-
-      def path
-        trace_back([@package]) if cycle?
-      end
-
-      private
-
-      def cycle?
-        while (node = @queue.shift)
-          return true if node == @package
-
-          visit(node)
-        end
-      end
-
-      def visit(node)
-        @dependencies[node].each do |neighbor|
-          next if @predecessor.key?(neighbor)
-
-          @predecessor[neighbor] = node
-          @queue << neighbor
-        end
-      end
-
-      def trace_back(path)
-        first = path.first
-        return path if first == @package && path.size > 1
-
-        trace_back(path.unshift(@predecessor[first]))
-      end
-    end
-  end
-end

data/lib/hashira/analysis/definitions.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Hashira
-  module Analysis
-    class Definitions
-      include Enumerable
-
-      def initialize(project, trees)
-        @project = project
-        @trees = trees
-      end
-
-      def each(&)
-        @trees.each { |file, tree| definitions_in(file, tree, &) }
-      end
-
-      def packages = @trees.keys.map { @project.package_for(it) }.uniq
-
-      private
-
-      def definitions_in(file, tree)
-        package = @project.package_for(file)
-        TypeWalk.each_definition(tree) { |node, full| yield node, full, package }
-      end
-    end
-  end
-end

data/lib/hashira/analysis/edge.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Hashira
-  module Analysis
-    Edge = Data.define(:from, :to) do
-      def to_s = "#{from} -> #{to}"
-    end
-  end
-end

data/lib/hashira/analysis/edge_map.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Hashira
-  module Analysis
-    class EdgeMap
-      def initialize(project, census)
-        @project = project
-        @census = census
-        @dependencies = empty_sets
-        @evidence = empty_sets
-      end
-
-      attr_reader :dependencies, :evidence
-
-      def record(file, tree)
-        from = @project.package_for(file)
-        source = @project.relative(file)
-        References.each_sighting(tree).each do |segments, line|
-          record_reference(from, source, segments, line)
-        end
-      end
-
-      private
-
-      def empty_sets = Hash.new { |hash, key| hash[key] = Set.new }
-
-      def record_reference(from, source, segments, line)
-        to = @census.resolve(segments)
-        return unless to && to != from
-
-        @dependencies[from] << to
-        @evidence[[from, to]] << "#{source}:#{line}: #{segments.join("::")}"
-      end
-    end
-  end
-end

data/lib/hashira/analysis/graph.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module Hashira
-  module Analysis
-    class Graph
-      def initialize(project, trees, census)
-        @census = census
-        @edge_map = EdgeMap.new(project, census)
-        trees.each { |file, tree| @edge_map.record(file, tree) }
-      end
-
-      def packages = @census.packages
-
-      def dependencies_of(package) = dependencies[package].to_a.sort
-
-      def dependents_of(package) = packages.select { dependencies[it].include?(package) }.sort
-
-      def edge_list
-        dependencies.sort.flat_map { |from, tos| tos.sort.map { Edge.new(from:, to: it) } }
-      end
-
-      def weighted_edges
-        edge_list.map do |edge|
-          from, to = edge.deconstruct
-          [from, to, weight(from, to)]
-        end
-      end
-
-      def evidence_for(from, to) = @edge_map.evidence[[from, to]]
-
-      def metric_for(package)
-        Metric.new(type_count: @census.type_count[package],
-                   afferent: dependents_of(package).size,
-                   efferent: dependencies[package].size)
-      end
-
-      def metrics = packages.to_h { [it, metric_for(it)] }
-
-      def sdp_violations = SdpCheck.new(dependencies, metrics).violations
-
-      def cyclic?(package) = !!cycle_path(package)
-
-      def weight(from, to) = evidence_for(from, to).size
-
-      def cycle_path(package) = CycleSearch.new(dependencies, package).path
-
-      def weakest_edge(path)
-        path.each_cons(2).min_by { |from, to| weight(from, to) }
-      end
-
-      private
-
-      def dependencies = @edge_map.dependencies
-    end
-  end
-end

data/lib/hashira/analysis/metric.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Hashira
-  module Analysis
-    Metric = Data.define(:type_count, :afferent, :efferent) do
-      def instability
-        total = efferent + afferent
-        total.zero? ? 0.0 : efferent.to_f / total
-      end
-
-      def to_h = { tc: type_count, ca: afferent, ce: efferent, i: instability }
-    end
-  end
-end

data/lib/hashira/analysis/references.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require "prism"
-
-module Hashira
-  module Analysis
-    module References
-      module_function
-
-      def list(tree)
-        each_sighting(tree).map(&:first)
-      end
-
-      def each_sighting(tree)
-        [].tap { collect(tree, it) }
-      end
-
-      def collect(node, accumulator)
-        return unless node
-        return accumulator << [Syntax.path_segments(node), node.location.start_line] if constant?(node)
-
-        branches(node).each { collect(it, accumulator) }
-      end
-
-      def constant?(node) = node.is_a?(Prism::ConstantPathNode) || node.is_a?(Prism::ConstantReadNode)
-
-      def branches(node)
-        definition?(node) ? definition_branches(node) : node.compact_child_nodes
-      end
-
-      def definition?(node) = node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
-
-      def definition_branches(node)
-        superclass = node.is_a?(Prism::ClassNode) ? node.superclass : nil
-        [superclass, node.body]
-      end
-    end
-  end
-end

data/lib/hashira/analysis/rule.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Hashira
-  module Analysis
-    class Rule
-      def initialize(project, graph)
-        @project = project
-        @graph = graph
-      end
-
-      private
-
-      attr_reader :project, :graph
-
-      def metrics = @metrics ||= graph.metrics
-
-      def finding(**attributes)
-        Finding.new(kind: self.class::KIND, cycle: nil, **attributes)
-      end
-    end
-  end
-end

data/lib/hashira/analysis/sdp_check.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Hashira
-  module Analysis
-    class SdpCheck
-      def initialize(dependencies, metrics)
-        @dependencies = dependencies
-        @metrics = metrics
-      end
-
-      def violations
-        @dependencies.flat_map do |from, tos|
-          tos.select { @metrics[it].instability > @metrics[from].instability }.map { [from, it] }
-        end
-      end
-    end
-  end
-end

data/lib/hashira/analysis/sdp_violation_findings.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Hashira
-  module Analysis
-    class SdpViolationFindings < Rule
-      KIND = "sdp_violation"
-
-      def list
-        graph.sdp_violations.sort_by { |from, to| instability(from) - instability(to) }
-                            .map { |from, to| violation_finding(from, to) }
-      end
-
-      private
-
-      def violation_finding(from, to)
-        finding(package: from, evidence: graph.evidence_for(from, to).to_a.first(5),
-                message: "#{from} (I=#{label(from)}) depends on the LESS stable #{to} " \
-                         "(I=#{label(to)}) — churn in #{to} will force churn in #{from}. " \
-                         "Invert the edge or extract the stable part of #{to} that #{from} needs.")
-      end
-
-      def instability(package) = metrics[package].instability
-
-      def label(package) = format("%.2f", instability(package))
-    end
-  end
-end

data/lib/hashira/complexity/analyzer.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Hashira
-  module Complexity
-    class Analyzer
-      THRESHOLD = 10
-
-      def initialize(project, trees)
-        @project = project
-        @scores = trees.flat_map { |path, tree| scores_for(path, tree) }
-      end
-
-      def methods = @scores.sort_by { -it.cognitive }
-
-      def classes = Rollup.new(@scores).classes.sort_by { -it.cognitive }
-
-      def findings = flagged.map { MethodFinding.new(it).to_finding }
-
-      private
-
-      def flagged = methods.select { it.cognitive >= THRESHOLD }
-
-      def scores_for(path, tree)
-        rel = @project.relative(path)
-        methods_in(tree).map { |full, node| build_score(rel, full, node) }
-      end
-
-      def methods_in(tree)
-        found = []
-        Analysis::TypeWalk.each_definition(tree) do |type_node, full|
-          Analysis::Syntax.direct_definitions(type_node).each { found << [full, it] }
-        end
-        found
-      end
-
-      def build_score(rel, full, node)
-        score = CognitiveScore.new(node)
-        MethodScore.new(subject: subject(full, node), file: rel, line: node.location.start_line,
-                        cognitive: score.total, calls: score.calls, increments: score.increments)
-      end
-
-      def subject(full, node) = "#{full.join("::")}#{node.receiver ? "." : "#"}#{node.name}"
-    end
-  end
-end

data/lib/hashira/diagram/renderer.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Hashira
-  module Diagram
-    class Renderer
-      def initialize(graph, format, io: $stdout)
-        @graph = graph
-        @format = format
-        @io = io
-      end
-
-      def display
-        edges = @graph.weighted_edges
-        renderer = @format == :dot ? Dot.new(edges) : Mermaid.new(edges)
-        @io.puts renderer.source
-        0
-      end
-    end
-  end
-end

data/lib/hashira/duplication/analyzer.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Hashira
-  module Duplication
-    class Analyzer
-      def initialize(project, trees, churn)
-        @project = project
-        @trees = trees
-        @churn = churn
-      end
-
-      def clusters = @clusters ||= Clusterer.new(fragments).clusters.sort_by { -it.mass }
-
-      def findings = clusters.map { |cluster| DuplicationFinding.new(cluster, @churn).to_finding }
-
-      private
-
-      def fragments = Extractor.new(@project, @trees).fragments
-    end
-  end
-end

data/lib/hashira/duplication/clusterer.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Hashira
-  module Duplication
-    class Clusterer
-      PREFILTER = 12
-      BASE_MASS = 16
-      NEAR_MASS = 40
-      PAIR = 2
-      PENALTY_PER_RECURRENCE = 2
-
-      def initialize(fragments)
-        @fragments = fragments.select { |fragment| fragment.mass >= PREFILTER }
-        @sets = UnionFind.new
-      end
-
-      def clusters
-        @fragments.group_by(&:types).each_value { |group| chain(group) }
-        NearMiss.new(@fragments).pairs.each { |left, right| @sets.union(left, right) }
-        Maximal.new(sized).reduced
-      end
-
-      private
-
-      def chain(group) = group.each_cons(2) { |left, right| @sets.union(left, right) }
-
-      def sized = built.filter_map { admitted(it) }
-
-      def admitted(cluster) = [cluster, exact_core(cluster)].compact.find { fits?(it) }
-
-      def fits?(cluster) = cluster.mass >= floor(cluster)
-
-      def exact_core(cluster) = Grouping.new(cluster.exact_sites).cluster
-
-      def built = @sets.clusters.filter_map { |group| Grouping.new(group).cluster }
-
-      def floor(cluster) = base(cluster) + idiom_penalty(cluster)
-
-      def base(cluster) = thin_evidence?(cluster) ? NEAR_MASS : BASE_MASS
-
-      def thin_evidence?(cluster) = !one_shape?(cluster) || cluster.shape_only?
-
-      def idiom_penalty(cluster) = recurrences(cluster) * PENALTY_PER_RECURRENCE
-
-      def recurrences(cluster) = [cluster.size - PAIR, 0].max
-
-      def one_shape?(cluster) = cluster.sites.map(&:types).uniq.size == 1
-    end
-  end
-end