scope_hunter 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3dc71fdbbdac0fc521593f6ae2c3f3006fa9d6cab28432653c1f982bbd476541
-  data.tar.gz: b33a72d49edee3625dbb3d9955c8e6b7482ac4484df2ad41afe31f19524e9ada
+  metadata.gz: 5579aa3ad0e861d5285ca7f1e69f1dff179febb032f197f8f8745b0938366755
+  data.tar.gz: 30ad427605fbb0b7cda71b5d7baf926796978673c6a0014ee75d649148d6acff
 SHA512:
-  metadata.gz: 5de33a94ba2d2a9c23d4824a4e2434e7ee2a88c46501384dae555009058bf9a1184dca6c4647c5b9249c1d5fbc225d1cf23a85ea23c78ec4742c15ef595ffdf9
-  data.tar.gz: 84351ee02da5511979933a75af93a63f8631b8343002e9dfdc9b3d311d8afb2ecc31bcf69bb840039044604dcbeb4f7632dc19add22a9a2cc8ddeb1f1aea9bbb
+  metadata.gz: 17426f0b9ddd3c1bfc6b92e30cbcdb5f5ad14c948d2735b8de805aa18c29f7843acf493dd676eaa65420a48ea3a16cad894ecd3fd8e4ca289e7d21db6143b6c9
+  data.tar.gz: 74b3c4d7846ab8c1826c01ce9a081d1e2be9cf090c7b37bccbb62f46e9e1d1a775605900511449d01fde5f7d9720c41b5aa0a131160a76d4ceb36e7c7f027bd3

data/CHANGELOG.md

@@ -1,5 +1,55 @@
 ## [Unreleased]
 
+## [0.1.4] - 2026-03-27
+
+### Fixed
+- Gemspec shipped with empty `config/` glob — default config was never included in the
+  installed gem; corrected to `lib/config/*.yml`
+- Bare `rescue` replaced with `rescue NoMethodError` / `rescue StandardError` so unexpected
+  exceptions are no longer silently swallowed
+- Removed `SuggestPartialMatches` config key from `default.yml` — it was never implemented
+
+### Changed
+- Indentation normalised to 2-space throughout `canonicalizer.rb` and `scope_index.rb`
+- Added cop-level test for `rewhere` query matching an existing scope
+
+## [0.1.3] - 2026-03-27
+
+### Added
+- Cross-file scope detection: scopes defined in `app/models/` are indexed and matched
+  against queries anywhere in the codebase (controllers, services, jobs, etc.)
+- `where.not()` support: queries using `where.not(...)` are matched against scopes
+  that use the same pattern
+- `IgnoreModels` configuration option to exclude specific models from detection and indexing
+- `ModelPaths` configuration option to control which files are scanned for scope definitions
+- Parameterized scope matching: scopes with lambda parameters (e.g. `->(role) { where(role: role) }`)
+  are matched against queries with literal values using the same key structure
+- Dynamic value guard: queries with runtime values (`method calls`, `variables`) are never flagged
+
+### Fixed
+- `normalize_hash` raised `NoMethodError` when a scope lambda used a dynamic value as the
+  entire where argument (e.g. `where(:__dynamic__)`)
+
+### Changed
+- Test suite expanded from 3 to 110+ examples with branch coverage tracking (94.5% line, 93.46% branch)
+
+## [0.1.2] - 2025-11-01
+
+### Changed
+- Bumped version
+
+## [0.1.1] - 2025-10-20
+
+### Added
+- LintRoller plugin integration for enhanced linting compatibility
+- Default lint roller plugin metadata in gemspec
+- YAML configuration files
+
 ## [0.1.0] - 2025-10-14
 
+### Added
 - Initial release
+- `ScopeHunter/UseExistingScope` cop detects ActiveRecord queries matching named scopes
+- Autocorrect support: replaces matched query with `Model.scope_name`
+- Trailing method chain preservation during autocorrect
+- Signature normalization: hash key order, `rewhere` treated as `where`

data/README.md

@@ -1,43 +1,303 @@
-# ScopeHunter
+# Scope Hunter
 
-TODO: Delete this and the text below, and describe your gem
+[![Ruby Version](https://img.shields.io/badge/ruby-%3E%3D%203.2.0-red.svg)](https://www.ruby-lang.org/)
+[![RuboCop](https://img.shields.io/badge/rubocop-%3E%3D%201.60-blue.svg)](https://rubocop.org/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE.txt)
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/scope_hunter`. To experiment with that code, run `bin/console` for an interactive prompt.
+> A RuboCop extension that catches duplicate ActiveRecord queries and replaces them with the named scope you already wrote.
 
-## Installation
+---
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+## The Problem
 
-Install the gem and add to the application's Gemfile by executing:
+Rails lets you define reusable query logic as named scopes:
+
+```ruby
+class User < ApplicationRecord
+  scope :active, -> { where(status: :active) }
+end
+```
+
+But over time, the same query gets copy-pasted elsewhere without anyone realising the scope already exists:
+
+```ruby
+# In a controller
+User.where(status: :active)          # duplicates User.active
+
+# In a service object
+User.where(status: :active).order(:name)  # also duplicates it
+```
+
+Scope Hunter finds these duplicates automatically and fixes them with `rubocop -A`.
+
+---
+
+## Quick Start
+
+**1. Add to your Gemfile:**
+
+```ruby
+gem 'scope_hunter'
+```
+
+**2. Add to `.rubocop.yml`:**
+
+```yaml
+require:
+  - scope_hunter
+
+ScopeHunter/UseExistingScope:
+  Enabled: true
+```
+
+**3. Run RuboCop:**
 
 ```bash
-bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+bundle exec rubocop
+```
+
+That's it. Scope Hunter will scan your `app/models/` directory and flag any query that matches a named scope.
+
+---
+
+## What It Looks Like
+
+Given this model:
+
+```ruby
+class User < ApplicationRecord
+  scope :active,    -> { where(status: :active) }
+  scope :with_posts, -> { joins(:posts) }
+  scope :recent,    -> { order(created_at: :desc) }
+end
+```
+
+Scope Hunter flags these:
+
+```
+app/controllers/users_controller.rb:5:5: C: ScopeHunter/UseExistingScope:
+  Query matches `User.active`. Use the scope instead.
+  User.where(status: :active)
+  ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+app/services/report.rb:12:5: C: ScopeHunter/UseExistingScope:
+  Query matches `User.with_posts`. Use the scope instead.
+  User.joins(:posts)
+  ^^^^^^^^^^^^^^^^^^
+```
+
+Running `rubocop -A` autocorrects them:
+
+```ruby
+# Before
+User.where(status: :active).order(:name).limit(10)
+
+# After — the matched part is replaced; the rest is kept
+User.active.order(:name).limit(10)
+```
+
+---
+
+## Features
+
+### Scope types detected
+
+| Scope pattern | Example |
+|---|---|
+| `where` / `rewhere` conditions | `scope :active, -> { where(status: :active) }` |
+| `where.not` conditions | `scope :inactive, -> { where.not(status: :active) }` |
+| `joins` | `scope :with_posts, -> { joins(:posts) }` |
+| `order` | `scope :recent, -> { order(created_at: :desc) }` |
+| Combined conditions | `scope :admin, -> { where(role: :admin).order(:name) }` |
+
+### Smart matching
+
+- **`rewhere` is treated as `where`** — `rewhere(status: :active)` matches the same scope as `where(status: :active)`
+- **Hash key order doesn't matter** — `where(a: 1, b: 2)` matches `where(b: 2, a: 1)`
+- **Parameterized scopes are matched by shape** — `scope :by_role, ->(r) { where(role: r) }` matches any `where(role: <value>)`
+- **Trailing methods are preserved** — `.order()`, `.limit()`, and anything after the matched query are kept intact
+- **Cross-file detection** — scopes defined in `app/models/` are detected even when the duplicate query is in a controller, service, or job
+- **Dynamic values are ignored** — `User.where(status: current_user.status)` is never flagged because the runtime value is unknown
+
+### Autocorrect
+
+The cop ships with conservative autocorrect. Running `rubocop -A` will replace the flagged query with the scope name, preserving any chained methods that come after.
+
+---
+
+## Configuration
+
+Add any of these to your `.rubocop.yml` under `ScopeHunter/UseExistingScope`:
+
+```yaml
+ScopeHunter/UseExistingScope:
+  Enabled: true
+
+  # Glob patterns for model files to scan for scope definitions.
+  # Defaults to app/models/**/*.rb
+  ModelPaths:
+    - "app/models/**/*.rb"
+    - "app/domain/**/*.rb"   # add extra paths as needed
+
+  # Models to skip entirely — useful for legacy or auto-generated models
+  # where scope reuse isn't practical.
+  IgnoreModels:
+    - LegacyReport
+    - AdminAuditLog
 ```
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+### `ModelPaths`
+
+Controls which files are scanned for scope definitions. By default, Scope Hunter reads everything under `app/models/`. If your project keeps models elsewhere, add those paths here.
+
+### `IgnoreModels`
+
+A list of model class names to exclude from both detection and indexing. Queries on these models are never flagged, and scopes inside them are never indexed.
+
+---
+
+## Detailed Examples
+
+### `where.not`
+
+```ruby
+scope :inactive, -> { where.not(status: :active) }
+
+# Flagged
+User.where.not(status: :active)
+
+# Autocorrected to
+User.inactive
+```
+
+### Parameterized scope
+
+The scope uses a lambda parameter — Scope Hunter matches by the key name, not the value.
+
+```ruby
+scope :by_role, ->(role) { where(role: role) }
+
+# Flagged — value :admin doesn't matter, the key `role:` matches
+User.where(role: :admin)
+
+# Autocorrected to
+User.by_role
+```
+
+### Dynamic values are safe
+
+```ruby
+scope :active, -> { where(status: :active) }
+
+# NOT flagged — runtime value is unknown, could be anything
+User.where(status: current_status)
+User.where(status: @status)
+User.where(status: params[:status])
+```
+
+### Cross-file detection
+
+Scopes in your models are indexed once per run. You can write the query anywhere in your app:
+
+```ruby
+# app/models/user.rb
+class User < ApplicationRecord
+  scope :active, -> { where(status: :active) }
+end
+
+# app/controllers/users_controller.rb
+class UsersController < ApplicationController
+  def index
+    # Flagged — Scope Hunter found the matching scope in user.rb
+    @users = User.where(status: :active)
+  end
+end
+```
+
+### Ignoring a model
+
+```yaml
+# .rubocop.yml
+ScopeHunter/UseExistingScope:
+  IgnoreModels:
+    - LegacyReport
+```
+
+```ruby
+# Not flagged — LegacyReport is in the ignore list
+LegacyReport.where(status: :active)
+```
+
+---
+
+## Running the cop
 
 ```bash
-gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+# Report all offenses
+bundle exec rubocop
+
+# Scan only your models directory
+bundle exec rubocop app/models/
+
+# Run only this cop
+bundle exec rubocop --only ScopeHunter/UseExistingScope
+
+# Autocorrect all offenses
+bundle exec rubocop -A
+
+# Autocorrect only this cop
+bundle exec rubocop --only ScopeHunter/UseExistingScope -A
 ```
 
-## Usage
+---
+
+## How It Works (for the curious)
 
-TODO: Write usage instructions here
+1. **Index** — Before checking any file, Scope Hunter reads every file matched by `ModelPaths` and builds an in-memory index of all named scopes, keyed by a normalized signature.
+2. **Normalize** — Each scope's query chain is reduced to a canonical form: `M=User|W={status:?}|J=[]|O=[]`. Values are replaced with `?` so the shape is matched, not the literal value.
+3. **Detect** — For every ActiveRecord query found in the file being checked, the same normalization is applied and the result is looked up in the index.
+4. **Flag** — If a match is found, an offense is reported. Queries with dynamic values are skipped before this step.
+5. **Autocorrect** — The matched portion of the query is replaced with `Model.scope_name`; any trailing method chain is appended unchanged.
+
+---
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+```bash
+# Install dependencies
+bundle install
+
+# Run tests
+bundle exec rspec
+
+# Run tests with coverage report
+bundle exec rspec --format documentation
+
+# Install the gem locally
+bundle exec rake install
+```
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+### Releasing a new version
+
+1. Update `lib/scope_hunter/version.rb`
+2. Run `bundle exec rake release`
+
+This creates a git tag, pushes the commit and tag, and publishes the gem to [rubygems.org](https://rubygems.org).
+
+---
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/scope_hunter. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/scope_hunter/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome at [github.com/Ajithxolo/scope_hunter](https://github.com/Ajithxolo/scope_hunter).
 
-## License
+1. Fork the repository
+2. Create a feature branch: `git checkout -b my-feature`
+3. Add tests for your change (we target 90%+ coverage)
+4. Make your change and confirm tests pass: `bundle exec rspec`
+5. Push and open a pull request
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+---
 
-## Code of Conduct
+## License
 
-Everyone interacting in the ScopeHunter project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/scope_hunter/blob/master/CODE_OF_CONDUCT.md).
+MIT — see [LICENSE.txt](LICENSE.txt).

data/lib/config/default.yml

@@ -1,4 +1,6 @@
 ScopeHunter/UseExistingScope:
   Enabled: true
   Autocorrect: conservative
-  SuggestPartialMatches: true
+  ModelPaths:
+    - "app/models/**/*.rb"
+  IgnoreModels: []

data/lib/rubocop/cop/scope_hunter/use_existing_scope.rb

@@ -13,17 +13,54 @@ module RuboCop
 
         MSG = 'Query matches `%<model>s.%<scope>s`. Use the scope instead.'
 
+        # Class-level project index shared across all cop instances within a run.
+        # Accumulated from configured model files plus each file as it is processed.
+        @project_index = nil
+        @model_files_scanned = false
+
+        class << self
+          attr_reader :project_index
+
+          # Resets cross-file state. Call before each RSpec example to prevent pollution.
+          def reset_project_index!
+            @project_index = nil
+            @model_files_scanned = false
+          end
+
+          def ensure_project_index!
+            @project_index ||= ::ScopeHunter::ScopeIndex.new
+          end
+
+          def model_files_scanned?
+            @model_files_scanned
+          end
+
+          def mark_model_files_scanned!
+            @model_files_scanned = true
+          end
+        end
+
         def on_new_investigation
-          @index = ::ScopeHunter::ScopeIndex.new
+          self.class.ensure_project_index!
+
+          unless self.class.model_files_scanned?
+            self.class.mark_model_files_scanned!
+            scan_model_files
+          end
+
           index_scopes(processed_source.ast)
         end
 
         def on_send(node)
           chain = ::ScopeHunter::ASTUtils.relation_chain(node)
           return unless chain
+          return if dynamic_where_values?(chain)
+
+          model_name = chain.first[:recv]
+          return if ignored_model?(model_name)
 
           sig = ::ScopeHunter::Canonicalizer.signature(chain)
-          match = @index.find(sig)
+          match = self.class.project_index&.find(sig)
           return unless match
 
           add_offense(node, message: format(MSG, model: match.model, scope: match.name)) do |corrector|
@@ -34,18 +71,59 @@ module RuboCop
 
         private
 
+        def scan_model_files
+          model_file_paths.each do |path|
+            next if current_file?(path)
+
+            src = ::RuboCop::ProcessedSource.new(File.read(path), RUBY_VERSION.to_f, path)
+            index_scopes(src.ast)
+          rescue StandardError
+            next
+          end
+        end
+
+        def model_file_paths
+          patterns = cop_config.fetch("ModelPaths", ["app/models/**/*.rb"])
+          Array(patterns).flat_map { |p| Dir.glob(p) }
+        end
+
+        def ignored_model?(model_name)
+          Array(cop_config.fetch("IgnoreModels", [])).include?(model_name)
+        end
+
+        # Returns true when any where/rewhere/where_not step in the chain contains a
+        # dynamic value (method call, variable, etc.). Matching against a scope in
+        # that case would be a false positive because the runtime value is unknown
+        # and may not correspond to what the scope filters for.
+        def dynamic_where_values?(chain)
+          chain.any? do |step|
+            next false unless %i[where rewhere where_not].include?(step[:msg])
+
+            step[:args].any? do |arg|
+              arg == :__dynamic__ ||
+                (arg.is_a?(Hash) && arg.any? { |_, v| v == :__dynamic__ })
+            end
+          end
+        end
+
+        def current_file?(path)
+          return false unless processed_source.path
+          File.expand_path(path) == File.expand_path(processed_source.path)
+        end
+
         def index_scopes(ast)
           return unless ast
-          # Find `scope :name, -> { ... }`
+
           ast.each_node(:send) do |send|
             next unless send.method_name == :scope
+
             name_node = send.arguments[0]
             next unless name_node&.sym_type?
 
             model = enclosing_class_name(send)
             next unless model
+            next if ignored_model?(model)
 
-            # The body is the lambda argument (second argument)
             lambda_body = send.arguments[1]
             next unless lambda_body&.block_type?
 
@@ -53,7 +131,7 @@ module RuboCop
             next unless chain
 
             sig = ::ScopeHunter::Canonicalizer.signature(chain, model: model)
-            @index.add(model:, name: name_node.value, signature: sig)
+            self.class.project_index.add(model:, name: name_node.value, signature: sig)
           end
         end
 
@@ -63,25 +141,24 @@ module RuboCop
           klass.identifier.const_name
         end
 
-        # Conservative autocorrect: replace the first AR part with Model.scope, keep trailing chain
         def replacement_for(node, match)
           trailing = trailing_after_first_ar(node)
-          ([ "#{match.model}.#{match.name}" ] + trailing).join
-        rescue
+          (["#{match.model}.#{match.name}"] + trailing).join
+        rescue StandardError
           nil
         end
 
         def trailing_after_first_ar(node)
           out = []
           cur = node
-          # Gather segments like `.order(...).limit(5)` in reverse
           while cur&.send_type?
             seg = "." + cur.method_name.to_s
             seg << "(#{cur.arguments.map(&:source).join(", ")})" unless cur.arguments.empty?
             out.unshift(seg)
-            cur = cur.receiver
+            # where.not(...) counts as a single logical step — skip both nodes.
+            cur = ::ScopeHunter::ASTUtils.where_not_node?(cur) ? cur.receiver.receiver : cur.receiver
           end
-          out.drop(1) # drop the first AR call; replaced by scope
+          out.drop(1)
         end
       end
     end

data/lib/scope_hunter/ast_utils.rb

@@ -9,6 +9,7 @@ module ScopeHunter
     AR_METHODS = %i[where rewhere joins order limit offset select distinct group having references includes preload].freeze
 
     # Returns array of steps: [{recv: "User", msg: :where, args: [{status: :active}]}, ...]
+    # Handles the compound `where.not(...)` pattern as a single :where_not step.
     def relation_chain(node, require_model: true)
       return nil unless node&.send_type?
 
@@ -21,7 +22,17 @@ module ScopeHunter
         recv = cur.receiver
         args = cur.arguments
 
-        if AR_METHODS.include?(msg) || model_const?(recv)
+        if where_not_node?(cur)
+          # `recv` is the bare `.where` call; its receiver is the model (or nil in scope body)
+          model_recv = recv.receiver
+          chain.unshift({
+            recv: model_recv&.const_type? ? const_name(model_recv) : nil,
+            msg:  :where_not,
+            args: unwrap_args(args)
+          })
+          seen_ar = true
+          cur = model_recv
+        elsif AR_METHODS.include?(msg) || model_const?(recv)
           chain.unshift({
             recv: recv&.const_type? ? const_name(recv) : nil,
             msg:  msg,
@@ -39,13 +50,20 @@ module ScopeHunter
       chain
     end
 
+    def where_not_node?(node)
+      node.method_name == :not &&
+        node.receiver&.send_type? &&
+        node.receiver.method_name == :where &&
+        node.receiver.arguments.empty?
+    end
+
     def model_const?(node)
       node&.const_type?
     end
 
     def const_name(node)
       node.const_name
-    rescue
+    rescue NoMethodError
       nil
     end
 
@@ -67,7 +85,8 @@ module ScopeHunter
       when node.true_type? then true
       when node.false_type? then false
       when node.const_type? then node.const_name.to_sym
-      else :__dynamic__
+      else :__dynamic__ # lvar, ivar, send, etc. — normalized to ? by Canonicalizer,
+                        # enabling parameterized scope matching
       end
     end
   end

data/lib/scope_hunter/canonicalizer.rb

@@ -1,56 +1,59 @@
 # frozen_string_literal: true
 
 module ScopeHunter
-    module Canonicalizer
-      extend self
-  
-      # chain: array of {recv:, msg:, args:}
-      # output: stable signature string
-      def signature(chain, model: nil)
-        state = { model: model, where: {}, joins: [], order: [] }
-  
-        chain.each do |step|
-          state[:model] ||= step[:recv] if step[:recv].is_a?(String)
-  
-          case step[:msg]
-          when :where, :rewhere
-            h = normalize_hash(step[:args].first)
-            state[:where].merge!(h)
-          when :joins
-            state[:joins] |= normalize_list(step[:args])
-            state[:joins].sort!
-          when :order
-            state[:order] += normalize_order(step[:args])
-          end
+  module Canonicalizer
+    extend self
+
+    # chain: array of {recv:, msg:, args:}
+    # output: stable signature string
+    def signature(chain, model: nil)
+      state = { model: model, where: {}, where_not: {}, joins: [], order: [] }
+
+      chain.each do |step|
+        state[:model] ||= step[:recv] if step[:recv].is_a?(String)
+
+        case step[:msg]
+        when :where, :rewhere
+          state[:where].merge!(normalize_hash(step[:args].first))
+        when :where_not
+          state[:where_not].merge!(normalize_hash(step[:args].first))
+        when :joins
+          state[:joins] |= normalize_list(step[:args])
+          state[:joins].sort!
+        when :order
+          state[:order] += normalize_order(step[:args])
         end
-  
-        w = state[:where].sort_by(&:first).map { |k,_| "#{k}:?" }.join(",")
-        j = state[:joins].join(",")
-        o = state[:order].map { |(c,d)| "(#{c},#{d || 'asc'})" }.join(",")
-  
-        "M=#{state[:model]}|W={#{w}}|J=[#{j}]|O=[#{o}]"
-      end
-  
-      def normalize_hash(obj)
-        h = (obj || {}).to_h
-        h.transform_keys { |k| k.to_s } .transform_values { |_| :"?" }
       end
-  
-      def normalize_list(args)
-        Array(args).flatten.compact.map(&:to_s)
-      end
-  
-      def normalize_order(args)
-        first = args.first
-        case first
-        when Hash
-          first.map { |k, v| [k.to_s, v&.to_s] }
-        when Symbol, String
-          [[first.to_s, "asc"]]
-        else
-          []
-        end
+
+      w  = state[:where].sort_by(&:first).map { |k, _| "#{k}:?" }.join(",")
+      wn = state[:where_not].sort_by(&:first).map { |k, _| "#{k}:?" }.join(",")
+      j  = state[:joins].join(",")
+      o  = state[:order].map { |(c, d)| "(#{c},#{d || "asc"})" }.join(",")
+
+      sig = "M=#{state[:model]}|W={#{w}}|J=[#{j}]|O=[#{o}]"
+      sig += "|WN={#{wn}}" unless wn.empty?
+      sig
+    end
+
+    def normalize_hash(obj)
+      h = obj.is_a?(Hash) ? obj : {}
+      h.transform_keys { |k| k.to_s }.transform_values { |_| :"?" }
+    end
+
+    def normalize_list(args)
+      Array(args).flatten.compact.map(&:to_s)
+    end
+
+    def normalize_order(args)
+      first = args.first
+      case first
+      when Hash
+        first.map { |k, v| [k.to_s, v&.to_s] }
+      when Symbol, String
+        [[first.to_s, "asc"]]
+      else
+        []
       end
     end
   end
-  
+end

data/lib/scope_hunter/scope_index.rb

@@ -1,20 +1,19 @@
 # frozen_string_literal: true
 
 module ScopeHunter
-    Scope = Struct.new(:model, :name, :signature, keyword_init: true)
-  
-    class ScopeIndex
-      def initialize
-        @by_signature = {}
-      end
-  
-      def add(model:, name:, signature:)
-        (@by_signature[signature] ||= []) << Scope.new(model:, name:, signature:)
-      end
-  
-      def find(signature)
-        Array(@by_signature[signature]).first
-      end
+  Scope = Struct.new(:model, :name, :signature, keyword_init: true)
+
+  class ScopeIndex
+    def initialize
+      @by_signature = {}
+    end
+
+    def add(model:, name:, signature:)
+      (@by_signature[signature] ||= []) << Scope.new(model:, name:, signature:)
+    end
+
+    def find(signature)
+      Array(@by_signature[signature]).first
     end
   end
-  
+end

data/lib/scope_hunter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ScopeHunter
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scope_hunter
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Ajith kumar
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-11-29 00:00:00.000000000 Z
+date: 2026-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop