hashira 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e51a640b2b2db8106e09f6679c9cd8687b834f8132db254b71ab6eb0c53c75c
-  data.tar.gz: 3fc2559e8d15081d4d201dcd24496939ceff92ce6c21fe33248af4871e03755c
+  metadata.gz: b806d4d5704515b3371235d38cdd4e60a0c37b98194c91922d57a8f5c448ffab
+  data.tar.gz: 774766f13fa3b820557cb613e9d9b0c7ffcca2d220c30611562d1467a21f142b
 SHA512:
-  metadata.gz: 7c676c8b8764ad0ebab7384a0cd72984efd979853842f3a51c28bb8e079815088f4d3e0fc1569442d4d46371d3cbb700364730cab85f176726c0b40acc6e45ba
-  data.tar.gz: ea97955b88d6b57c52f980662eec0c0fb690dabac64d47734bf7ad3e94efbb4c18ced3483e8f8afb65833b807aaff248f4bcd37995875a24ea1031c244dc7ccc
+  metadata.gz: 8bd5fc6feb807c1255adec14ee18405842a7125dbb4d661c777f85454a831f357484090d90ef39cdc2e1d854df037f61147ede6ef1dfa1854b945bfbb27cd686
+  data.tar.gz: c853f3b158e0a1e501aeb48333c793eb92fcf0e51c9dabbdd538e643889dfd36141c1bfacfcd8bbebc03934cb0ec96690508cd7747cea99fb4b3e081b1aca4b9

data/CHANGELOG.md

@@ -5,6 +5,49 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.0] - 2026-07-26
+
+### Changed
+
+- Package boundaries are found at any depth. Directory detection descends
+  single-folder wrapper chains (`lib` → `lib/gem` → `lib/gem/core`), so
+  `hashira`, `hashira lib`, and `hashira lib/gem/core` land on the same
+  boundaries; descent stops at loose code files. Constant resolution now
+  strips the inferred shared namespace *prefix* (majority per level across
+  packages) instead of a single root module, so analyzing a nested subtree
+  resolves cross-package references instead of silently reporting no edges.
+- With several directories, same-named subfolders no longer merge into one
+  package: a contested name is qualified by its directory (`app/models` vs
+  `lib/models`); unique names stay short.
+- Constant resolution is path-based. Each definition registers its full
+  constant path and its suffixes as shorthand; a sighting resolves by longest
+  match, and a name claimed by several packages resolves to nothing rather
+  than to the last one parsed. A namespace mirrored across layers
+  (`Admin::Account` in `app/models/admin`, `Admin::AccountsController` in
+  `app/controllers/admin`) now attributes each reference to the right side —
+  a model reaching into its controller layer shows up as an edge (and a
+  cycle) instead of vanishing as a self-reference — and a bare reference to
+  a name declared in exactly one package (`Skill.all`) now counts.
+
+### Fixed
+
+- Duplication: a listing interrupted by a statement of another shape is no
+  longer windowed as a clone. The rule applied only when an entire sibling run
+  was homogeneous, so one trailing `module` after a block of requires — or a
+  `banner =` before a run of `o.on` calls — put the whole list back in scope.
+  Listings are now the maximal same-shape stretches within a run, and they are
+  opaque: no window reaches into one, so a list row never lends its mass to the
+  statements beside it. Two files ending a require block with `module Foo` no
+  longer match on the tail of the block, and a genuine clone next to a list is
+  weighed on its own size rather than the list's.
+- Duplication: a near-miss neighbour no longer buries the exact clone pair
+  inside its cluster. Exact matches and near misses are unioned into one
+  cluster, which is then judged as a whole — so a single fuzzy member raised the
+  mass floor from 16 to 40 and took the exact pair down with it, and adding a
+  third, sloppier copy of a duplicated method made the finding disappear. A
+  cluster that misses the raised floor now falls back to its identically shaped
+  core and is weighed again on the floor that evidence earns.
+
 ## [0.2.0] - 2026-07-25
 
 ### Added
@@ -70,5 +113,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Output formats: text, JSON, Graphviz dot, Mermaid (`--format`, `--json`).
 - `--help` and `--version`.
 
+[0.3.0]: https://github.com/giacope/hashira/releases/tag/v0.3.0
 [0.2.0]: https://github.com/giacope/hashira/releases/tag/v0.2.0
 [0.1.0]: https://github.com/giacope/hashira/releases/tag/v0.1.0

data/README.md

@@ -65,7 +65,9 @@ Requires Ruby 3.4 or newer.
 
 ## Getting started
 
-Point hashira at your code, or run it with no arguments to auto-detect `lib/<gem>`:
+Point hashira at your code, or run it with no arguments to auto-detect `lib/<gem>`.
+Single-folder wrapper chains are descended automatically, so `hashira`,
+`hashira lib`, and `hashira lib/gem/core` land on the same package boundaries:
 
 ```sh
 hashira                        # auto-detects lib/<gem>
@@ -264,9 +266,14 @@ letter repeated — it tells you nothing about what to open first.
 **Coupling.** A dependency edge A→B exists when a file in package A references a
 constant declared by package B. Declarations are read from the AST; strings and
 comments are invisible. A type counts toward TC only if it defines a method
-directly in its body; pure namespace wrappers don't count. The root namespace is
-inferred (the most common outermost constant), so `App::Alpha` and `Alpha` resolve
-to the same package. Each edge carries a **weight**: the number of constant
+directly in its body; pure namespace wrappers don't count. The namespace prefix
+shared by the packages is inferred (`App`, or `App::Core` when analyzing a nested
+subtree), so `App::Alpha` and `Alpha` resolve to the same package. Resolution is
+by longest constant path, so a namespace mirrored across packages
+(`Admin::Account` in models, `Admin::AccountsController` in controllers) sends
+each reference to the right side; a bare name declared in exactly one package
+resolves there, and a name several packages claim resolves to nothing rather
+than to a guess. Each edge carries a **weight**: the number of constant
 references backing it. A root-level file `x.rb` folds into package `x` when a
 sibling folder `x/` exists; everything else at the top level lands in `(root)`.
 

data/lib/hashira/analysis/census.rb

@@ -6,33 +6,33 @@ module Hashira
       def initialize(project, trees)
         @definitions = Definitions.new(project, trees)
         @type_count = Hash.new(0)
-        @declaring_package = {}
-        @root_namespace = RootNamespace.infer(@definitions)
+        @registry = ConstantRegistry.new
+        @namespace_prefix = NamespacePrefix.infer(@definitions)
         take
       end
 
-      attr_reader :type_count, :declaring_package, :root_namespace
+      attr_reader :type_count, :namespace_prefix
+
+      def declaring_package = @registry.declaring_package
 
       def packages = (@type_count.keys | @definitions.packages)
 
-      def resolve(segments)
-        outer, inner = segments.first(2)
-        @declaring_package[outer == root_namespace ? inner : outer]
-      end
+      def resolve(segments) = @registry.package_for(after_prefix(segments))
 
       private
 
       def take
         @definitions.each do |node, full, package|
-          register(full, package)
+          @registry.register(after_prefix(full), package)
           @type_count[package] += 1 unless Syntax.direct_definitions(node).empty?
         end
       end
 
-      def register(full, package)
-        outer, inner = full.first(2)
-        name = outer == root_namespace ? inner : outer
-        @declaring_package[name] = package if name
+      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

data/lib/hashira/analysis/constant_registry.rb

@@ -0,0 +1,40 @@
+# 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/namespace_prefix.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Analysis
+    module NamespacePrefix
+      module_function
+
+      def infer(definitions)
+        build(deepest_definition_per_package(definitions))
+      end
+
+      def build(fulls, prefix = [])
+        depth = prefix.length
+        wrapper = shared_wrapper(fulls, depth)
+        return prefix unless wrapper
+
+        build(fulls.select { it[depth] == wrapper }, prefix + [wrapper])
+      end
+
+      def deepest_definition_per_package(definitions)
+        definitions.map { |_node, full, package| [package, full] }
+                   .sort_by { |_package, full| full.length }
+                   .to_h.values
+      end
+
+      def shared_wrapper(fulls, depth)
+        wrapper, count = fulls.filter_map { it[depth] if it[depth + 1] }.tally.max_by { |_wrapper, tally| tally }
+        wrapper if wrapper && count > fulls.size / 2
+      end
+    end
+  end
+end

data/lib/hashira/duplication/cluster.rb

@@ -12,6 +12,8 @@ module Hashira
         sites.reject { |site| site.equal?(chosen) }
       end
 
+      def exact_sites = sites.select { it.types == canonical.types }
+
       def mass = canonical.mass
 
       def size = sites.size

data/lib/hashira/duplication/clusterer.rb

@@ -24,7 +24,13 @@ module Hashira
 
       def chain(group) = group.each_cons(2) { |left, right| @sets.union(left, right) }
 
-      def sized = built.select { |cluster| cluster.mass >= floor(cluster) }
+      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 }
 

data/lib/hashira/duplication/sequence.rb

@@ -12,21 +12,23 @@ module Hashira
         @statements = statements
       end
 
-      def fragments
-        return [] if listing?
-
-        lengths.flat_map { |length| slide(length) }
-      end
+      def fragments = segments.flat_map { windows(it) }
 
       private
 
-      def listing? = @statements.size >= LIST_RUN && shapes.uniq.size == 1
+      def segments = runs.chunk { listing?(it) }.filter_map { |listed, group| group.flatten(1) unless listed }
+
+      def listing?(run) = run.size >= LIST_RUN
+
+      def runs = shaped.slice_when { |left, right| left.last != right.last }.map { it.map(&:first) }
+
+      def shaped = @statements.map { [it, fragment([it]).types] }
 
-      def shapes = @statements.map { fragment([it]).types }
+      def windows(segment) = lengths(segment).flat_map { |length| slide(segment, length) }
 
-      def lengths = MIN_STATEMENTS..[@statements.size, MAX_STATEMENTS].min
+      def lengths(segment) = MIN_STATEMENTS..[segment.size, MAX_STATEMENTS].min
 
-      def slide(length) = (0..(@statements.size - length)).map { fragment(@statements[it, length]) }
+      def slide(segment, length) = (0..(segment.size - length)).map { fragment(segment[it, length]) }
 
       def fragment(roots) = Fragment.new(@file, roots)
     end

data/lib/hashira/project.rb

@@ -5,17 +5,30 @@ module Hashira
     ROOT_PACKAGE = "(root)"
 
     def self.detect(directories)
-      directories.empty? ? new(default_directories) : new(directories)
+      targets = directories.empty? ? default_directories : directories
+      new(targets.map { descend(it.delete_suffix("/")) })
     end
 
     def self.default_directories
-      subdirectories = Dir["lib/*/"].map { File.basename(it) }
-      raise Error, "no lib/ directory here — pass the source directory explicitly" if subdirectories.empty?
+      raise Error, "no lib/ directory here — pass the source directory explicitly" if Dir["lib/*/"].empty?
 
-      subdirectories.size == 1 ? ["lib/#{subdirectories.first}"] : ["lib"]
+      ["lib"]
     end
     private_class_method :default_directories
 
+    def self.descend(directory)
+      child = only_subdirectory(directory)
+      return directory unless child && Dir["#{child}/*/"].any? && (Dir["#{directory}/*.rb"] - ["#{child}.rb"]).empty?
+
+      descend(child)
+    end
+
+    def self.only_subdirectory(directory)
+      subdirectories = Dir["#{directory}/*/"]
+      subdirectories.size == 1 ? subdirectories.first.delete_suffix("/") : nil
+    end
+    private_class_method :descend, :only_subdirectory
+
     def initialize(directories)
       missing = directories.reject { Dir.exist?(it) }
       raise Error, "no such directory: #{missing.join(", ")}" unless missing.empty?
@@ -29,7 +42,9 @@ module Hashira
 
     def package_for(path)
       first, rest = relative(path).delete_suffix(".rb").split("/", 2)
-      rest || folder?(path, first) ? first : ROOT_PACKAGE
+      return ROOT_PACKAGE unless rest || folder?(path, first)
+
+      contested.include?(first) ? "#{directory_of(path)}/#{first}" : first
     end
 
     def relative(path) = path.delete_prefix("#{directory_of(path)}/")
@@ -42,6 +57,11 @@ module Hashira
 
     def folder?(path, name) = Dir.exist?("#{directory_of(path)}/#{name}")
 
+    def contested
+      @contested ||= @directories.flat_map { |directory| Dir["#{directory}/*/"].map { File.basename(it) } }
+                                 .tally.filter_map { |name, count| name if count > 1 }
+    end
+
     def directory_of(path)
       @directories.find { path.start_with?("#{it}/") } ||
         raise(Error, "#{path} is outside the analyzed directories")

data/lib/hashira/version.rb

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

data/lib/hashira.rb

@@ -9,7 +9,8 @@ require_relative "hashira/analysis/node_walk"
 require_relative "hashira/analysis/type_walk"
 require_relative "hashira/analysis/references"
 require_relative "hashira/analysis/definitions"
-require_relative "hashira/analysis/root_namespace"
+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"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hashira
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Giacomo GK
@@ -27,6 +27,7 @@ files:
 - 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
@@ -35,9 +36,9 @@ files:
 - 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/root_namespace.rb
 - lib/hashira/analysis/rule.rb
 - lib/hashira/analysis/sdp_check.rb
 - lib/hashira/analysis/sdp_violation_findings.rb

data/lib/hashira/analysis/root_namespace.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Hashira
-  module Analysis
-    module RootNamespace
-      module_function
-
-      def infer(definitions)
-        definitions.map { |_node, full, _package| full.first }
-                   .tally.max_by { |_name, count| count }&.first
-      end
-    end
-  end
-end