Feature Request: Separate scopes for finding definitions and finding usages

[jayqui-omada]

Hi there, thanks for this very useful gem!

I've been trying to use leftovers to find unused code within a specific part of my Rails application (app/models), but I've run into a limitation with how the file paths are configured.

The Problem

Currently, the include_paths and exclude_paths configurations define the scope for two distinct operations simultaneously:

1. Discovering definitions (methods, constants, etc.) that should be checked.
2. Scanning for usages (calls) of those definitions.

This makes it impossible to check for unused definitions in a narrow scope (e.g., just my models) while searching for usages across a much wider scope (e.g., the entire application).

Use Case

My goal is to identify and remove unused methods and constants that are defined exclusively within a certain directory (e.g. app/models).

To do this, leftovers needs to scan my entire project for usages (in controllers, workers, views, etc.). However, when I configure leftovers to do a full-project scan, the report includes unused items from every part of the codebase, which is overwhelming.

Conversely, if I try to limit the scope like this:

# .leftovers.yml
include_paths:
  - 'app/models/**/*.rb'

leftovers will incorrectly flag a model method as "unused" if (for example) its only call site is in a controller, because the controller files are not part of the include_paths scope where leftovers is looking for usages.

Proposed Solution

It would be incredibly helpful to be able to configure these two scopes separately. I propose introducing a new configuration key, perhaps definition_paths.

This new key would tell leftovers: "Only report unused items that are defined in these files."

The existing include_paths and exclude_paths would then be used to define the (much larger) scope for where to find usages of those definitions.

A configuration for my use case might look like this:

# .leftovers.yml

# Only report unused code that is DEFINED in these files.
definition_paths:
  - 'app/models/**/*.rb'

# But look for USAGES of that code across the entire project.
include_paths:
  - '**/*.rb'

exclude_paths:
  - node_modules/**/*
  - vendor/**/*

This would provide a much more powerful and targeted way to use leftovers on large, mature codebases where a full-project analysis can be too noisy to start with.

Thanks for your consideration

[robotdana]

interesting idea

i believe the way to do this right now is add this to your .leftovers.yml

keep:
  - path: '!app/models/**/*.rb'

this (should) mean that any method or constant or etc defined in any file that isn't in app/models (using .gitignore format) counts as being used.

(you could also reduce the scope any other way, e.g. 'only report on the methods that start with a, b, c with keep: { matches: '[^a-c].*' })

alternatively

leftovers | grep -e ^app/models

---

I don't really want to add any more overlapping ideas to the config, though if that keep/path config snippet works for you let me know and i'll add it to the readme.

(the reason exclude_paths and include_paths are separate is so we don't have to even open their directories/files, that isn't needed here because we have to read them to find the calls anyway)

[jayqui]

Finally got around to trying this. Unfortunately, it doesn't work as expected.

what I did

I created a leftovers.yml that contained only

keep:
  - path: '!app/models/**/*.rb'

and then ran leftovers --write-todo

the result

I got a leftovers-todo.yml that had lots of stuff I wouldn't have expected. Under

keep:
  # Not directly called at all:

I see lots of classes and variables that are defined outside of app/models/, including app/lib/, spec/support/, and more.