leftovers 0.1.0

data/Configuration.md

@@ -0,0 +1,427 @@
+# Configuration
+
+The configuration is read from `.leftovers.yml` in your project root.
+Its presence is optional and all of these settings are optional:
+
+see the [built in config files](https://github.com/robotdana/leftovers/tree/master/lib/config) for examples.
+
+- [`include_paths:`](#include_paths)
+- [`exclude_paths:`](#exclude_paths)
+- [`test_paths:`](#test_paths)
+- [`gems:`](#gems)
+- [`rules:`](#rules)
+  - [`names:`](#names)
+    - [`has_prefix](#has_prefix-has_suffix)
+    - [`has_suffix](#has_prefix-has_suffix)
+    - [`matches](#matches)
+  - [`paths:`](#paths)
+  - [`skip:`](#skip)
+  - [`calls:`](#calls-defines), [`defines:`](#calls-defines)
+    - [`arguments:`](#arguments), [`keys:`](#keys-), [`itself:`](#itself-true)
+    - [`transforms:`](#transforms), [`linked_transforms:`](#linked_transforms)
+        - `original:`, `add_prefix:`, `add_suffix:`, `delete_prefix:`, `delete_suffix:`, `replace_with:`
+        - `delete_before:`, `delete_after:`, `downcase:`, `upcase:`, `capitalize:`, `swapcase:`
+        - `pluralize`, `singularize`, `camelize`, `underscore`, `demodulize`, `deconstantize`
+    - [`if:`](#if-unless), [`unless:`](#if-unless)
+      - [`has_argument:`](#has_argument)
+        - `keyword:`
+          - [`has_prefix:`](#has_prefix-has_suffix)
+          - [`has_suffix:`](#has_prefix-has_suffix)
+          - [`matches:`](#matches)
+        - `value:`
+          - [`has_prefix:`](#has_prefix-has_suffix)
+          - [`has_suffix:`](#has_prefix-has_suffix)
+          - [`matches:`](#matches)
+          - `type:`
+
+
+## `include_paths:`
+
+List filenames/paths in the gitignore format of files to be checked using a [gitignore-esque format](https://github.com/robotdana/fast_ignore#using-an-includes-list).
+
+```yml
+include_paths:
+  - '*.rb'
+  - '*.rake'
+  - Gemfile
+```
+
+Also it will check files with no extension that have `ruby` in the shebang/hashbang, e.g. `#!/usr/bin/env ruby` or `#!/usr/bin/ruby` etc
+
+## `exclude_paths:`
+
+List filenames/paths that match the above that you might want to exclude, using the gitignore format.
+By default it will also read your project's .gitignore file and ignore anything there.
+
+```yml
+exclude_paths:
+  - /some/long/irrelevant/generated/file
+```
+
+## `test_paths:`
+
+list filenames/paths of test directories that will be used to determine if a method/etc is only tested but not otherwise used.
+Also in the gitignore format
+
+```yml
+test_paths:
+  - /test/
+  - /spec/
+```
+
+## `gems:`
+
+By default Leftovers will look at your Gemfile.lock file to find all gem dependencies
+
+If you don't use bundler, or don't have a Gemfile.lock for some reason, you can still take advantage of the built in handling for certain gems
+```yml
+gems:
+  - rspec
+  - rails
+```
+
+## `rules:`
+
+This is the most complex part of configuration, and is a list of methods that define/call other methods/classes/etc.
+Each must have a list of `names:`. and can optionally be limited to a list of `paths:`.
+
+This rule can either `skip:` these names, or describe method/class `calls:` and definitions (`defines:`).
+
+### `names:`
+**required**
+
+_alias `name:`_
+
+list methods/classnames/etc that this rule applies to.
+
+```yml
+rules:
+  - names:
+      - initialize
+      - ClassName
+    skip: true
+  - name: respond_to_missing?
+    skip: true
+```
+
+#### `has_prefix:`, `has_suffix:`
+
+To match names other than exact strings, you can use has_suffix or has_prefix or both if you're feeling fancy.
+
+```yml
+rules:
+  - names:
+      - has_suffix: Helper # will match Helper, LinkHelper FormHelper, etc
+      - has_prefix: be_ # will match be_equal, be_invalid, etc
+      - { has_prefix: is_, has_suffix: '?' } # will match is_invalid?, is_equal? etc
+    skip: true
+```
+
+
+#### `matches:`
+
+if `has_suffix:` and `has_prefix:` isn't enough, you can use `matches:` to supply a regexp.
+This string is automatically converted into a ruby regexp and must match the whole method/constant name.
+```yml
+rules:
+  - names:
+      - matches: 'column_\d+' # will match column_1, column_2, column_99, but not column_left etc
+    skip: true
+```
+
+### `paths:`
+_alias `path:`_
+
+An optional list of paths that limits what paths this method rule can apply to, defined using a .gitignore-esque format
+
+```yml
+rules:
+  - name:
+      - has_suffix: Helper
+    path: /app/helpers
+    skip: true
+```
+
+### `skip:`
+
+Skip methods that are called on your behalf by code outside your project, or called dynamically using send with variables.
+
+You can also skip method calls and definitions in place using [magic comments](https://github.com/robotdana/leftovers/tree/master/README.md#magic-comments).
+
+```yml
+rules:
+  - name: initialize
+    skip: true
+```
+```ruby
+def initialize
+end
+```
+
+will not report that you didn't directly use the initialize method
+
+### `calls:`, `defines:`
+_aliases `call:`, `define:`_
+Describe implicitly called and defined methods using these keys. they're structured the same way:
+
+It must have at least one of `argument:`, `itself: true`, or `keys: '*'` which points to the implied method definition/call.
+This value must be a literal string, symbol, or array of strings or symbols.
+
+#### `arguments:`
+_alias `argument:`_
+
+the position or keyword of the value or values being implicitly called/defined.
+it can be a single argument or a list.
+
+This value must be itself a literal String, Symbol, or Array or Hash whose values are Strings and Symbols or more nested Arrays and Hashes.
+Variables and other method calls returning values will be ignored.
+
+`*` means all positional arguments values. `**` means all keyword arguments values.
+Positional arguments start at 1.
+
+```yml
+rules:
+  # `send(:my_method, arg)` is equivalent to `my_method(arg)`
+  - name: send
+    calls:
+      argument: 1
+```
+```ruby
+  user.send(:my_private_method, true)
+```
+will count as a call to `my_private_method`.
+
+```yml
+  - name: attr_reader
+    defines:
+      arguments: '*'
+```
+```ruby
+attr_reader :my_attr, :my_other_attr
+```
+will count as a definition of `my_attr` and `my_other_attr` and will need to be used elsewhere or they'll be reported as leftovers.
+
+```yml
+rules:
+  - name: validate
+    calls:
+      - arguments: ['*', if, unless]
+```
+```ruby
+validate :does_not_match_existing_record, if: :new_record?
+```
+will count as a call to `does_not_match_existing_record`, and `new_record?`
+
+##### Constant assignment.
+
+In addition to method call arguments, this can be used for constant assignment, as often constant assignment plus class_eval/instance_eval/define_method is used to dry up similar methods.
+```yml
+rules:
+  - name: METHOD_NAMES
+    defines:
+      - arguments: 1
+        add_suffix: _attributes
+    calls:
+      - arguments: 1
+```
+```ruby
+METHOD_NAMES = %w{user account}.freeze
+METHOD_NAMES.each do |method_name|
+  class_eval <<~RUBY, __FILE__, __LINE__ + 1
+    def #{method}_attributes
+      self.#{method}
+    end
+  end
+end
+```
+counts as a definition of `user_attributes` and `account_attributes` and calls to `user` and `account`
+
+use `arguments: '**'`, and or `keys: true` for assigning hashes
+```yml
+rules:
+  - name: METHOD_NAMES
+    defines:
+      - keys: '*'
+        add_prefix: setup_
+    calls:
+      - arguments: '**'
+        add_prefix: build_
+```
+```ruby
+METHOD_NAMES = { user: :login, account: :profile }
+METHOD_NAMES.each do |method_name|
+  class_eval <<~RUBY, __FILE__, __LINE__ + 1
+    def setup_#{method}
+      build_#{method}
+    end
+  end
+end
+```
+Would count as defining `setup_user`, and `setup_account` and calling `build_login` and `build_profile`
+
+#### `itself: true`
+
+Will supply the method/constant name itself as the thing to be transformed.
+The original method/constant name will continue to be defined as normal
+```yml
+- name:
+      has_prefix: be_
+    calls:
+      itself: true
+      delete_prefix: be_
+      add_suffix: '?'
+```
+```ruby
+expect(value).to be_empty
+```
+will count `be_empty` as a call to `empty?`
+
+#### `keys: '*'`
+When the keyword argument **keywords** are the thing being called.
+
+```yml
+rules:
+  - name: validates
+      calls:
+        - arguments: '*'
+        - keys: '*'
+          add_suffix: Validator
+          activesupport: camelize
+```
+```ruby
+validates :first_name, :surname, presence: true
+```
+will count calls for `validates`, `first_name`, `surname`, and `PresenceValidator`
+
+#### `transforms:`
+
+Sometimes the method being called is modified from the literal argument, sometimes that's just appending an `=` and sometimes it's more complex:
+
+```yml
+- name: attribute
+    defines:
+      - argument: 1
+        transforms:
+          - original # no transformation
+          - add_suffix: '?'
+          - add_suffix: '='
+```
+```ruby
+attribute :first_name
+```
+will count as a definition of `first_name`, `first_name=` and `first_name?`
+
+If there is just one transform for the arguments you can remove the `transforms:` keyword and move everything up a level.
+
+```yml
+- name: attr_writer
+  defines:
+    - argument: '*'
+      add_suffix: '='
+```
+```ruby
+attr_writer :first_name, :surname
+```
+will count as the definition of `first_name=`, and `surname=`
+
+| transform | examples | effect |
+| --- | --- | --- |
+|original| `original`, `original: true` | no change. useful when grouped with other transforms |
+|add_prefix| `add_prefix: be_`, `add_prefix: { from_argument: 'to', joiner: '_' }` | adds the prefix string. possibly from another attribute (used for rails' delegate). |
+|add_suffix| `add_suffix: '?'`, `add_suffix: Validator` | adds the suffix string. possibly from another attribute. |
+|delete_prefix| `delete_prefix: be_` | removes the prefix string. |
+|delete_suffix| `delete_suffix: _html` | removes the suffix string. |
+|delete_before| `delete_before: '#'` | removes everything up to and including the string. used for rails' routes. |
+|delete_after| `delete_after: '#'` | removes everything after to and including the string. used for rails' routes. |
+|replace_with| `replace_with: html` | replaces the original string, perhaps because it dynamically calls it |
+|downcase| `downcase`, `downcase: true` | calls ruby's `String#downcase` |
+|upcase| `upcase`, `upcase: true` | calls ruby's `String#upcase` |
+|capitalize| `capitalize`, `capitalize: true` | calls ruby's `String#capitalize` |
+|swapcase| `swapcase`, `swapcase: true` | calls ruby's `String#swapcase` |
+|pluralize| `pluralize`, `pluralize: true` | calls activesupport's `String#pluralize` extension. Will try to load config/initializers/inflections.rb |
+|singularize| `singularize`, `singularize: true` | calls activesupport's `String#singularize` extension. Will try to load config/initializers/inflections.rb |
+|camelize| `camelize`, `camelize: true`, `camelcase`, `camelcase: true` | calls activesupport's `String#camelize` extension. Will try to load config/initializers/inflections.rb |
+|underscore| `underscore`, `underscore: true` | calls activesupport's `String#underscore` extension. |
+|demodulize| `demodulize`, `demodulize: true` | calls activesupport's `String#demodulize` extension. |
+|deconstantize| `deconstantize`, `deconstantize: true` | calls activesupport's `String#deconstantize` extension. |
+|titleize| `titleize`, `titleize: true`, `titlecase`, `titlecase: true` | calls activesupport's `String#titleize` extension. |
+|parameterize| `parameterize`, `parameterize: true` | calls activesupport's `String#parameterize` extension. |
+
+#### `linked_transforms:`
+
+This is identical to `transforms:` except that a call to one of the defined methods counts as a call to them all.
+
+```yml
+- name: attribute
+    defines:
+      - argument: 1
+        linked_transforms:
+          - original # no transformation
+          - add_suffix: '?'
+          - add_suffix: '='
+```
+```ruby
+attribute :first_name
+
+def initialize
+  self.first_name = 'dana'
+end
+```
+will count as a definition of `first_name`, `first_name=` and `first_name?`, and because of `linked_transforms` the call to `first_name=` also counts as a call to `first_name?` and `first_name`
+
+#### `if:`, `unless:`
+
+Sometimes what to do depends on other arguments than the ones looked at:
+e.g. rails' `delegate` method has a `prefix:` argument of its own that is used when defining methods:
+
+`if:` and `unless:` work the same way and can be given a list or single value of conditions. For a list, all conditions must be met.
+
+```yml
+rules:
+  - name: field
+    calls:
+      - argument: 1
+        unless:
+          has_argument: method
+      - argument: method
+```
+```ruby
+field :first_name
+field :family_name, method: :surname
+```
+would count calls to `first_name`, and `surname`, but not `family_name`
+
+##### `has_argument:`
+
+has_argument can be given a keyword or list of keywords. or a list of patterns like name.
+or to check either the exact value or type of value it can be given `keyword:` and `value:` which also match the patterns like `name:`.
+instead of an exact value `value:` can be given a type or list of type.
+
+This all comes together to give the most complex rule, rails delegate method.
+```yml
+rules:
+  - name: delegate
+    defines:
+      - argument: '*'
+        if:
+          has_argument:
+            keyword: prefix
+            value: true # if the value of the prefix keyword argument is literal true value
+        add_prefix:
+          from_argument: to # use the value of the "to" keyword as the prefix
+          joiner: '_' # joining with _ to the original string
+      - argument: '*'
+        if: # if the method call has a prefix keyword argument that is not a literal true value
+          has_argument:
+            keyword: prefix
+            value:
+              type: [String, Symbol]
+        add_prefix:
+          from_argument: prefix # use the value of the "prefix" keyword as the prefix
+          joiner: '_' # joining with _ to the original string
+    calls:
+      - argument: to # consider the to argument called.
+      - argument: '*'
+        if:
+          has_argument: prefix # if there is a prefix, consider the original method called.
+```

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in leftovers.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Dana Sherson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,172 @@
+# Leftovers
+[![travis](https://travis-ci.org/robotdana/leftovers.svg?branch=master)](https://travis-ci.org/robotdana/leftovers)
+
+Find unused `methods`, `Classes`, `CONSTANTS`, `@instance_variables`, `@@class_variables`, and `$global_variables` in your ruby projects.
+
+## Why?
+
+Code that never gets executed is code that you shouldn't need to maintain.
+
+- Leftovers from refactoring
+- Partially removed features
+- Typos and THIS NEVER WOULD HAVE WORKED code
+- Code that you only keep around because there are tests of it.
+
+Leftovers will use static analysis to find these bits of code for you.
+
+It's aware of how some gems call methods for you, including (still somewhat incomplete) support for rails.
+
+## Features
+
+- Fully configurable handling of methods that call other methods with literal arguments, and constant assignment
+- magic comments
+- designed to be run as a CI step
+- optimised for speed
+- built in config for some gems. (please make PRs with more gems)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'leftovers'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install leftovers
+
+## Usage
+
+Run `leftovers` in your terminal in the root of your project.
+This will output progress as it collects the calls/references and definitions in your project.
+Then it will output any defined methods (or classes etc) which are not called.
+
+```
+$ leftovers
+checked 25 files, collected 2473 calls, 262 definitions
+Only directly called in tests:
+lib/hello_world.rb:10:6 tested_unused_method def tested_unused_method
+lib/hello_world.rb:18:6 another_tested_unused_method def another_tested_unused_method
+Not directly called at all:
+lib/hello_world.rb:6:6 generated_method= attr_accessor :generated_method
+lib/hello_world.rb:6:6 generated_method attr_accessor :generated_method
+```
+
+## Magic comments
+
+### `# leftovers:keep`
+To mark a method definition as not unused, add the comment `# leftovers:keep` on the same line as the definition
+
+```ruby
+class MyClass
+  def my_method # leftovers:keep
+    true
+  end
+end
+```
+This would report `MyClass` is unused, but not my_method
+To do this for all definitions of this name, add the name with `skip: true` in the configuration file.
+
+### `# leftovers:test`
+
+To mark a definition from a non-test dir, as intentionally only used by tests, use `leftovers:test`
+```ruby
+# app/my_class.rb
+class MyClass
+  def my_method # leftovers:test
+    true
+  end
+end
+```
+```ruby
+# spec/my_class_spec.rb
+describe MyClass do
+  it { expect(subject.my_method).to be true }
+end
+```
+
+This would consider `my_method` to be used, even though it is only called by tests.
+
+### `# leftovers:call`
+To mark a dynamic call that doesn't use literal values, use `leftovers:call` with the method name listed
+```ruby
+method = [:puts, :warn].sample
+send(method, 'text') # leftovers:call puts, warn
+```
+
+This would consider `puts` and `warn` to both have been called
+
+## Configuration
+
+The configuration is read from `.leftovers.yml` in your project root.
+Its presence is optional and all of these settings are optional:
+
+see the [complete config documentation](https://github.com/robotdana/leftovers/tree/master/Configuration.md) for details.
+see the [built in config files](https://github.com/robotdana/leftovers/tree/master/lib/config) for examples.
+
+- [`include_paths:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#include_paths)
+- [`exclude_paths:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#exclude_paths)
+- [`test_paths:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#test_paths)
+- [`gems:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#gems)
+- [`rules:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#rules)
+  - [`names:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#names)
+    - [`has_prefix:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#has_prefix-has_suffix)
+    - [`has_suffix:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#has_prefix-has_suffix)
+    - [`matches:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#matches)
+  - [`paths:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#paths)
+  - [`skip:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#skip)
+  - [`calls:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#calls-defines), [`defines:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#calls-defines)
+    - [`arguments:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#arguments), [`keys:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#keys-), [`itself:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#itself-true)
+    - [`transforms:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#transforms), [`linked_transforms:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#linked_transforms)
+        - `original:`, `add_prefix:`, `add_suffix:`, `delete_prefix:`, `delete_suffix:`, `replace_with:`
+        - `delete_before:`, `delete_after:`, `downcase:`, `upcase:`, `capitalize:`, `swapcase:`
+        - `pluralize`, `singularize`, `camelize`, `underscore`, `demodulize`, `deconstantize`
+    - [`if:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#if-unless), [`unless:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#if-unless)
+      - [`has_argument:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#has_argument)
+        - `keyword:`
+          - [`has_prefix:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#has_prefix-has_suffix)
+          - [`has_suffix:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#has_prefix-has_suffix)
+          - [`matches:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#matches)
+        - `value:`
+          - [`has_prefix:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#has_prefix-has_suffix)
+          - [`has_suffix:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#has_prefix-has_suffix)
+          - [`matches:`](https://github.com/robotdana/leftovers/tree/master/Configuration.md#matches)
+          - `type:`
+
+## Limitations
+
+- Leftovers will report methods/constants you define that are called outside your code (perhaps by gems) as unused
+
+  Add these names to the `rules:` list with `skip: true` in the `.leftovers.yml` or add an inline comment with `# leftovers:allow my_method_name`
+- Leftovers doesn't execute your code so isn't aware of dynamic calls to `send` (e.g. `send(variable_method_name)`). (it is aware of static calls (e.g. `send(:my_method_name)`), so using send to bypass method privacy is "fine")
+
+  Add the method/pattern to the `rules:` list with `skip: true` in the `.leftovers.yml`, or add an inline comment with the list of possibilities `# leftovers:call my_method_1, my_method_2`.
+- Leftovers compares by name only, so multiple methods with the same name will count as used even if only one is.
+- haml & erb line and column numbers will be wrong as the files have to be precompiled before checking.
+
+## Other tools
+
+- [rubocop](https://github.com/rubocop-hq/rubocop) has a cop that will alert for unused local variables and method arguments, and a cop that will report unreachable code.
+- [coverband](https://github.com/danmayer/coverband) will report which methods are _actually_ called by your _actual_ production code
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/robotdana/leftovers.
+
+I especially encourage issues and improvements to the default config, whether expanding the existing config/*.yml (rails.yml is particularly incomplete) or adding new gems.
+The file should be named `[rubygems name].yml` and its structure is identical to the [project config](#configuration)
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+require 'spellr/rake_task'
+require_relative 'lib/leftovers/rake_task'
+
+# RuboCop::RakeTask.new
+RSpec::Core::RakeTask.new(:spec)
+Spellr::RakeTask.generate_task
+Leftovers::RakeTask.generate_task(:leftovers, '--no-progress')
+
+# rubocop is misbehaving currently
+task default: %i{spec spellr leftovers}

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'leftovers'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/leftovers

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/leftovers/cli'
+
+Leftovers::CLI.new(argv: ARGV, stdout: $stdout, stderr: $stderr)