reen 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c32624b91f88178dd9a68dc09229916804beffff846e04074e4f76a5eb299739
+  data.tar.gz: ef4cde36ed7202532276d761da152004dcb2f322814d7ed8d82c6de78ba4c920
+SHA512:
+  metadata.gz: e139aa0f8f927448c3e566a37868b5c29697e91b46f9fa3043d12dce53d015e64b1791474e36178d40b1b937b76032ab1fcce8caebfa5c45081a79251cee1c56
+  data.tar.gz: f9e20a1defcf449536eb2e8ca160ef7ee6eb26831527015df85cb2839b88cc97fb3ca2300ab27d00e388ea22af95c978c0d972932a80e2881638390f2c4b3c81

data/.claude/CLAUDE.md

@@ -0,0 +1,44 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Reen is a Ruby gem for mass renaming/deleting files through an interactive editor. It provides both a CLI (`reen`) and a programmatic API. Version 1.0.0, requires Ruby >= 3.0.
+
+## Common Commands
+
+```bash
+bundle exec rake              # Run tests + rubocop (default task)
+bundle exec rake spec         # Run all tests (minitest)
+bundle exec rake rubocop      # Lint only
+bundle exec rake respec       # Auto-rerun tests on file changes
+
+# Run a single test file
+bundle exec ruby -Ispec:lib spec/spec_changes.rb
+
+# Test fixtures
+bundle exec rake example:recreate  # Extract example.zip for tests
+bundle exec rake example:remove    # Clean up extracted fixtures
+```
+
+## Architecture
+
+**Flow:** `ReenCLI (bin/reen)` → `Reen::Reen` → `ChangesFile` (temp file + editor) → `Changes` → `Change` → `Action`
+
+- **`Reen::Reen`** (`lib/reen/reen.rb`) — Main orchestrator. Two-phase workflow: `request()` analyzes changes, `execute()` applies them. Constructor takes `editor:` (defaults to $VISUAL/$EDITOR) and `options:`.
+- **`Reen::Changes`** (`lib/reen/changes.rb`) — Collection of `Change` objects with filtering (`rename_requested`, `delete_requested`, `accepted`, `rejected`, `executed`, `failed`) and `execute_all`.
+- **`Reen::Change`** (`lib/reen/change.rb`) — Parses a single original→requested pair. Prefix `-` = delete, `--` = force delete. Maps change type to action handler via `ACTION_HANDLER` constant. Auto-rejects non-empty directory deletion (unless force).
+- **`Reen::ChangesFile`** (`lib/reen/changes_file.rb`) — Manages Tempfile for editor interaction, writes instructions header, parses edited result.
+- **Actions** (`lib/reen/actions/`) — Strategy pattern: `Rename`, `Delete`, `ForceDelete`, `DoNothing`. Each has `new(old, new)` and `call()` returning nil (success) or error string.
+
+## Test Setup
+
+- **Framework:** Minitest with describe/it blocks, minitest-rg for formatting, SimpleCov for coverage
+- **Fixtures:** `spec/fixtures/example.zip` extracted to `spec/fixtures/example/` via `FixtureHelper` before tests
+- **Test files:** `spec/spec_*.rb` pattern (spec_reenrb, spec_changes, spec_requests)
+
+## Style
+
+- RuboCop enforced: double quotes, 120 char line length, NewCops enabled
+- Target Ruby version: 3.0

data/.markdownlint.json

@@ -0,0 +1,3 @@
+{
+  "MD013": false
+}

data/.rubocop.yml

@@ -0,0 +1,24 @@
+AllCops:
+  TargetRubyVersion: 3.0
+  NewCops: enable
+
+Metrics/BlockLength:
+  Enabled: true
+  Exclude:
+  - reen.gemspec
+
+Style/HashSyntax:
+  Enabled: true
+  Exclude:
+  - Rakefile
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+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.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.2.1] - 2022-11-05
+
+### Changed
+
+- Simplified API for passing block to request/execute
+
+## [0.1.0] - 2022-11-05
+
+- Initial release: CLI and API working

data/CLAUDE.feature-numbered-lists.md

@@ -0,0 +1,145 @@
+# Numbered List Prefixes for Editor
+
+> **IMPORTANT**: This plan must be kept up-to-date at all times. Assume context can be cleared at any time — this file is the single source of truth for the current state of this work. Update this plan before and after task and subtask implementations.
+
+## Branch
+
+`feature-numbered-lists`
+
+## Goal
+
+Add numbered prefixes (e.g., `[01]`, `[002]`) to the file list shown in the editor so users can freely reorder entries without losing track of which original file each line corresponds to. Matching changes back to originals uses the number, not line position. Also fix the dash-operator ambiguity by requiring a space after `-`/`--` to distinguish delete operations from literal filenames starting with dashes. Introduce `PathEntry` and `PathEntryList` domain objects to replace raw path strings — `PathEntry` wraps a file path and answers filesystem queries, `PathEntryList` is a collection that owns numbered serialization for the editor.
+
+## Strategy: Vertical Slice
+
+1. **Refactor** — Introduce `PathEntry`/`PathEntryList` domain objects, migrate existing code (all tests pass)
+2. **Fix** — Require space after `-`/`--` for delete operators (dash ambiguity fix)
+3. **Feature** — Add numbered prefixes and number-based matching
+4. **Verify** — Manual test with real editor confirms behavior
+
+## Current State
+
+- [x] Plan created
+- [x] Slice 0: PathEntry/PathEntryList refactor
+- [x] Slice 1: Dash-operator ambiguity fix
+- [x] Slice 2: Numbered prefixes
+- [x] Slice 3: Number-based matching
+- [x] Slice 4: Documentation
+- [ ] Slice 5: Verification
+
+## Key Findings
+
+- `Change` currently owns filesystem queries (`request_dir?`, `request_file?`, `request_empty_dir?`, `request_full_dir?`) by checking `@original` path directly. These should move to `PathEntry`.
+- `Change` will hold an `PathEntry` instead of a raw `@original` string. `Change#original` delegates to `PathEntry#path`.
+- `PathEntryList` wraps an array of `PathEntry` objects. Constructed from `Dir.glob` results (array of strings). Owns numbered serialization (writing `[NN] path` lines) and parsing (stripping prefixes, returning number-keyed entries).
+- `ChangesFile#initialize` currently writes `requested_list.join("\n")` — will instead take an `PathEntryList` and call its serialization.
+- `ChangesFile#allow_changes` reads back lines, strips comments/blanks — will delegate prefix parsing to `PathEntryList`.
+- `Reen#request` does positional matching via `original_list.zip(changed_list)` — changes to number-based matching via `PathEntryList`.
+- `Reen#request` raises if list sizes differ (line deletion guard) — still valid with numbered approach.
+- `Change#extract_request` parses operator prefixes (`-`, `--`) greedily, which means renaming to `-` or `--` is impossible. Fix: require a space after `-`/`--` to trigger delete.
+- Tests manipulate `file.list` directly (mock editor) — the list exposed to the block will include number prefixes so test blocks simulate what a real user sees/edits.
+- Number width is auto-sized: `format("%0#{width}d")` where `width = list.size.to_s.length`.
+
+## Questions
+
+- ~~Should `Change` know about number prefixes?~~ No — `ChangesFile` handles writing and stripping prefixes. `Change` and `Reen` see clean filenames. `Reen#compare_lists` changes from positional zip to number-keyed matching.
+- ~~Should dashes go before or after number prefixes?~~ After. Dashes are operators on the filename, numbers are stable anchors: `[01] - file` = delete, `[01] -file` = rename to `-file`. Require space after `-`/`--` to distinguish.
+- [ ] Should reordering be reflected in the output summary? (Probably not needed for v1.)
+
+## Scope
+
+**In scope**:
+
+- `PathEntry` (`lib/reenrb/path_entry.rb`): wraps a file path, provides `file?`, `dir?`, `empty_dir?`, `full_dir?`, `path`
+- `PathEntryList` (`lib/reenrb/path_entry_list.rb`): collection of `PathEntry`, constructed from string array, owns numbered serialization/parsing
+- `Change`: refactor to hold `PathEntry` instead of raw string, delegate filesystem queries to `PathEntry`
+- `Change#extract_request`: require space after `-`/`--` for delete operators (fixes dash-name ambiguity)
+- `ChangesFile`: use `PathEntryList` for writing/reading, numbered prefixes, updated instructions
+- `Reen`: accept `PathEntryList` (or build one from string array), number-based matching
+- Tests for: `PathEntry`, `PathEntryList`, dash-space fix, prefix formatting/stripping, reordered matching
+
+**Out of scope**:
+
+- Reporting reorder information to the user
+- Any CLI flag to disable numbering
+- `Changes` refactor (stays as-is, wraps array of `Change`)
+- File/folder creation via unnumbered lines (touch/mkdir) — future feature, separate branch
+
+## Tasks
+
+> **Strict TDD cycle**: For each slice — (1) run full suite to confirm green baseline, (2) write failing tests (RED), (3) run tests to confirm they fail, (4) implement (GREEN), (5) run full suite to confirm all pass. **Check off each step immediately after completing it.**
+
+### Slice 0: Introduce PathEntry and PathEntryList domain objects (refactor)
+
+- [x] 0.0 Run full suite — confirm green baseline (11 tests, 0 failures)
+- [x] 0.1 RED — Write failing tests in `spec/spec_path_entry.rb`:
+  - [x] 0.1a `PathEntry` wraps a path and delegates `file?`, `dir?`, `empty_dir?`, `full_dir?`
+  - [x] 0.1b `PathEntryList` constructs from array of strings, iterates as `PathEntry` objects
+  - [x] 0.1c `PathEntryList#paths` returns array of path strings
+- [x] 0.2 Run new tests — confirm RED (6 errors, uninitialized constant)
+- [x] 0.3 GREEN — Implement `PathEntry` (`lib/reenrb/path_entry.rb`)
+- [x] 0.4 GREEN — Implement `PathEntryList` (`lib/reenrb/path_entry_list.rb`)
+- [x] 0.5 Run new tests — confirm GREEN (6 runs, 27 assertions, 0 failures)
+- [x] 0.6 Refactor `Change` to hold `PathEntry`, delegate filesystem queries
+- [x] 0.7 Refactor `Reen` and `ChangesFile` to accept/use `PathEntryList`
+- [x] 0.8 Run full suite — confirm all tests pass (17 runs, 58 assertions, 0 failures)
+
+### Slice 1: Fix dash-operator ambiguity in Change
+
+- [x] 1.0 Run full suite — confirm green baseline (17 runs, 0 failures)
+- [x] 1.1 RED — Write failing tests in `spec/spec_change.rb`:
+  - [x] 1.1a `- filename` (with space) triggers delete
+  - [x] 1.1b `-filename` (no space) triggers rename to `-filename`
+  - [x] 1.1c `-- filename` (with space) triggers force delete
+  - [x] 1.1d `--filename` (no space) triggers rename to `--filename`
+- [x] 1.2 Run new tests — confirm RED (1.1b and 1.1d fail as expected)
+- [x] 1.3 GREEN — Updated `Change#extract_request` regex: `^(--|-)·(?<name>.*)` with fallback `^()(?<name>.*)`
+- [x] 1.4 Run full suite — confirm GREEN (21 runs, 64 assertions, 0 failures)
+
+### Slice 2: Numbered prefixes in PathEntryList and ChangesFile
+
+- [x] 2.0 Run full suite — confirm green baseline (21 runs, 0 failures)
+- [x] 2.1 RED — Write failing tests:
+  - [x] 2.1a `PathEntryList#to_numbered` serializes as `[NN] path` lines (auto-sized width)
+  - [x] 2.1b `PathEntryList.from_numbered` parses `[NN] path` lines back to number-keyed entries
+  - [x] 2.1c (deferred to Slice 4 — documentation)
+- [x] 2.2 Run new tests — confirm RED (3 errors, undefined method `to_numbered`)
+- [x] 2.3 GREEN — Implement `PathEntryList#to_numbered` and `PathEntryList.from_numbered`
+- [x] 2.4 GREEN — Update `ChangesFile` to use numbered serialization
+- [x] 2.5 GREEN — Update `INSTRUCTIONS` constant with reorder/number/dash-space guidance
+- [x] 2.6 Run full suite — deferred to Slice 3 (existing tests broke as expected, fixed there)
+
+### Slice 3: Number-based matching in Reen
+
+- [x] 3.0 (combined with Slice 2 — baseline was 21 runs before numbered output broke existing tests)
+- [x] 3.1 RED — Write failing tests in `spec/spec_reorder.rb`:
+  - [x] 3.1a `Reen#request` correctly matches reordered entries to originals by number (reverse, rename+move)
+  - [x] 3.1b `Reen#request` still raises error when lines are removed
+- [x] 3.2 Run new tests — confirm RED (3.1a failed, 3.1b passed)
+- [x] 3.3 GREEN — Changed `Reen#compare_lists` to use `PathEntryList.from_numbered` for number-keyed matching
+- [x] 3.4 GREEN — Updated existing tests: delete/force-delete use `.sub("] ", "] - ")` pattern
+- [x] 3.5 Run full suite — confirm all pass (27 runs, 110 assertions, 0 failures)
+
+### Slice 4: Documentation
+
+- [x] 4.1 Update README.md: documented numbered prefixes, dash-space syntax, reordering, programmatic examples
+- [x] 4.2 CLI help in `bin/reen` — no changes needed (uses banner/options only, editing syntax is in INSTRUCTIONS)
+- [x] 4.3 `ChangesFile::INSTRUCTIONS` — updated in Slice 2.5, verified
+
+### Slice 5: Verification
+
+- [x] 5.1 Run full suite (`bundle exec rake`) — 29 tests, 115 assertions, 0 failures. RuboCop: only pre-existing offenses, no new ones.
+- [ ] 5.2 Manual verification with real editor (user to perform)
+
+## Completed
+
+- Slice 0: PathEntry/PathEntryList refactor — `PathEntry` wraps paths with filesystem queries, `PathEntryList` is an Enumerable collection. `Change` delegates to `PathEntry`. `Reen` and `ChangesFile` accept `PathEntryList`. All 17 tests pass.
+- Slice 1: Dash-operator ambiguity fix — `Change#extract_request` now requires space after `-`/`--` for delete operators. `-file` is rename to `-file`, `- file` is delete. All 21 tests pass.
+- Slice 2: Numbered prefixes — `PathEntryList#to_numbered` and `.from_numbered` implemented. `ChangesFile` writes `[NN] path` lines and updated `INSTRUCTIONS`.
+- Slice 3: Number-based matching — `Reen#compare_lists` uses `from_numbered` for number-keyed matching instead of positional zip. Reordering works. All 27 tests pass (110 assertions).
+- Slice 4: Documentation — README updated with numbered prefixes, dash-space syntax, reordering docs, programmatic examples. CLI help unchanged (banner only). INSTRUCTIONS verified.
+- Slice 5: Verification — 29 tests, 115 assertions, 0 failures. No new RuboCop offenses. Manual editor test pending.
+
+---
+
+Last updated: 2026-03-10

data/Gemfile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in reen.gemspec
+gemspec
+
+gem "irb"
+gem "minitest", "~> 5.0"
+gem "minitest-rg", "~> 5.0"
+gem "rake", "~> 13.0"
+gem "rerun", "~> 0.13"
+gem "rubocop", "~> 1.21"
+gem "rubyzip", "~> 2.3"
+gem "simplecov"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Soumya Ray
+
+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,131 @@
+# Reen
+
+Reen is a utility written in Ruby (requires Ruby installed on your machine) that mass renames/deletes files by allowing the user to modify a list. It includes a command line executable called `reen` that opens the user's default editor to permit interactive changes, or can be used programatically by modifying the list of file names using a code block.
+
+[![Reen usage introduction](https://img.youtube.com/vi/yJfDRfJr3os/0.jpg)](https://www.youtube.com/watch?v=yJfDRfJr3os)
+
+## Installation
+
+To install the command line utility, use:
+
+    $ gem install reen
+
+Or add this line to your Ruby application's Gemfile for programmatic use:
+
+```ruby
+gem 'reen'
+```
+
+## Usage
+
+### Command line
+
+From command line, run `reen` with file list:
+
+    reen files [options]
+
+where `files` are a list of files or wildcard pattern (defaults to `*`; see examples)
+
+Options include:
+
+- `--help` or `-h` to see options help
+- `--editor [EDITOR]` or `-e [EDITOR]` to use a specific editor, or just `-e` to use `$EDITOR`
+- `--visual [EDITOR]` or `-v [EDITOR]` to use a specific editor, or just `-v` to use `$VISUAL`
+- `--review` or `-r` request to review and confirm changes
+
+The editor must block until the file is closed — for VS Code use `'code -w'`, for Sublime use `'subl -w'`. Without `-e` or `-v`, Reen defaults to `$VISUAL` then `$EDITOR`.
+
+Examples:
+
+    reen                    # reen all files (*)
+    reen **/*               # reen all files in all subfolders
+    reen myfolder/**/*.mov  # reen all mov files in subfolders
+    reen -e                 # reen all files using $EDITOR
+    reen -v                 # reen all files using $VISUAL
+    reen -e vi *.md         # reen all markdown files using vi
+    reen --editor 'code -w' # reen all files using vscode
+
+### Specifying changes through the editor
+
+Upon running Reen on file list, your editor will open with a numbered list of file/folder names. Each line has a number prefix like `[01]` that tracks the original file. For example:
+
+```
+[01] LICENSE.txt
+[02] README.md
+[03] SETUP.txt
+[04] bin
+[05] bin/help
+[06] bin/myexec
+[07] tests
+[08] tests/fixtures
+[09] tests/fixtures/a.json
+[10] tests/fixtures/b.json
+[11] tests/fixtures/c.json
+[12] tests/helper.code
+[13] tests/tests.code
+```
+
+Specify changes to each file you wish changed modifying it in your editor:
+
+- Change the file/folder name (after the number prefix) to rename it
+- Put `- ` (dash followed by a space) after the number prefix to delete a file or empty folder
+- Put `-- ` (double dash followed by a space) to force delete a file or non-empty folder (recursively)
+- You may freely reorder lines — the number prefixes track which original file each line refers to
+- Do not change or remove the `[NN]` number prefixes
+
+For example, if we wanted to (a) rename `LICENSE.txt` to `LICENSE.md`, (b) delete `SETUP.txt`, and (c) recursively delete the `bin/` folder:
+
+```
+[01] LICENSE.md
+[02] README.md
+[03] - SETUP.txt
+[04] -- bin
+[05] bin/help
+[06] bin/myexec
+[07] tests
+[08] tests/fixtures
+[09] tests/fixtures/a.json
+[10] tests/fixtures/b.json
+[11] tests/fixtures/c.json
+[12] tests/helper.code
+[13] tests/tests.code
+```
+
+Note: filenames starting with dashes (e.g., `-myfile`) are safe — only a dash followed by a space triggers deletion.
+
+Upon saving and exiting the editor, Reen will execute all the changes.
+
+### Ruby application
+
+Use Reen programmatically using the `reen` gem. In the example below, we specify that we do not want to use an actual editor to modify the list, but rather alter the list file using a block. Note that `file.list` contains numbered lines (e.g., `[1] LICENSE.txt`).
+
+```ruby
+require 'reen'
+
+glob = Dir.glob("*")
+reen = Reen::Reen.new(editor: nil)
+
+reen.execute(glob) do |file|
+  # Rename LICENSE.txt -> LICENSE.md (gsub works on the path portion)
+  index = file.list.index { |l| l.include? "LICENSE.txt" }
+  file.list[index] = file.list[index].gsub("txt", "md")
+
+  # Delete a file — insert "- " after the number prefix
+  index = file.list.index { |l| l.include? "SETUP.txt" }
+  file.list[index] = file.list[index].sub("] ", "] - ")
+end
+```
+
+You may also pass a block with an editor specified, in which case the block is run after the editor has finished.
+
+## 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.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/soumyaray/reen.
+
+## 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,38 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:spec) do |t|
+  t.libs << "spec"
+  t.libs << "lib"
+  t.test_files = FileList["spec/**/spec_*.rb"]
+end
+
+task :respec do
+  sh "rerun -c --ignore 'spec/fixtures/*' rake spec"
+end
+
+namespace :example do
+  task :helper do
+    require_relative "spec/fixture_helper"
+  end
+
+  desc "Recreates the example fixture folder"
+  task :recreate => :helper do
+    FixtureHelper.recreate_example_dir
+    puts "Example fixture recreated"
+  end
+
+  desc "Deletes the example fixture folder"
+  task :remove => :helper do
+    FixtureHelper.remove_example_dirs
+    puts "Example fixture removed"
+  end
+end
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/bin/reen

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require "reen"
+require "optparse"
+
+# Reen command line application
+class ReenCLI
+  EDITOR_MSG = "Editor not set in $VISUAL or $EDITOR -- please set one of those environment variables"
+  Options = Struct.new(:editor, :review) do
+    def initialize(editor: nil, review: false)
+      editor ||= ENV["VISUAL"] || ENV["EDITOR"] # rubocop:disable Style/FetchEnvVar
+      super(editor, review)
+    end
+  end
+
+  attr_reader :options, :files
+
+  def initialize(args)
+    @options = Options.new
+    optparse = OptionParser.new { |parser| setup_options(parser) }
+    optparse.parse!(args, into: @options)
+
+    exit_with_msg(EDITOR_MSG) unless options.editor
+
+    @files = args.empty? ? Dir.glob("*") : args
+  rescue OptionParser::InvalidOption => e
+    puts "#{e.message}\n\n"
+    exit_with_msg(optparse)
+  end
+
+  def setup_options(parser) # rubocop:disable Metrics/MethodLength
+    parser.banner = "Usage: reen files [options]"
+    parser.version = Reen::VERSION
+
+    parser.on("-e", "--editor [EDITOR]", "Use EDITOR (default: $EDITOR)") do |ed|
+      @options.editor = ed || ENV["EDITOR"] # rubocop:disable Style/FetchEnvVar
+    end
+    parser.on("-v", "--visual [EDITOR]", "Use EDITOR (default: $VISUAL)") do |ed|
+      @options.editor = ed || ENV["VISUAL"] # rubocop:disable Style/FetchEnvVar
+    end
+    parser.on("-r", "--review", "Require review and confirmation of changes")
+
+    parser.on("-h", "--help", "Show help for options") do
+      exit_with_msg(parser)
+    end
+  end
+
+  def exit_with_msg(message)
+    puts message
+    exit(false)
+  end
+
+  def review_changes
+    puts
+    puts @requests.change_requested.summarize
+    print "\nContinue? (y/n) "
+    confirmation = %w[y yes].include?($stdin.gets.chomp.downcase)
+    exit_with_msg("Nothing changed") unless confirmation
+  end
+
+  def check_inputs
+    @files = files.empty? ? Dir.glob("*") : files
+    exit_with_msg(EDITOR_MSG) unless options.editor
+  end
+
+  def user_review?
+    @options.review && @requests.changes_requested?
+  end
+
+  def call
+    @requests = Reen::Reen.new(editor: options.editor).request(files)
+    review_changes if user_review?
+
+    changes = @requests
+              .execute_all
+              .change_requested
+
+    if user_review? && changes.all_executed?
+      puts "Changes made"
+    else
+      puts changes.summarize
+    end
+  end
+end
+
+begin
+  ReenCLI.new(ARGV).call
+rescue Reen::Error => e
+  puts "#{e.message}\n"
+end

data/lib/reen/actions/delete.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Reen
+  module Actions
+    # Deletes a file
+    class Delete
+      def initialize(old_name, new_name)
+        @old_name = old_name
+        @new_name = new_name
+      end
+
+      def call
+        File.delete(@old_name)
+        nil
+      rescue Errno::ENOENT
+        "Could not delete"
+      end
+    end
+  end
+end

data/lib/reen/actions/force_delete.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Reen
+  module Actions
+    # Deletes a file
+    class ForceDelete
+      def initialize(old_name, new_name)
+        @old_name = old_name
+        @new_name = new_name
+      end
+
+      def call
+        FileUtils.rm_rf(@old_name)
+        nil
+      rescue Errno::ENOENT
+        "Could not force delete"
+      end
+    end
+  end
+end

data/lib/reen/actions/nothing.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Reen
+  module Actions
+    # Does nothing to items
+    class DoNothing
+      def initialize(old_name, new_name)
+        @old_name = old_name
+        @new_name = new_name
+      end
+
+      def call
+        nil
+      end
+    end
+  end
+end

data/lib/reen/actions/rename.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Reen
+  module Actions
+    # Renames files
+    class Rename
+      def initialize(old_name, new_name)
+        @old_name = old_name
+        @new_name = new_name
+      end
+
+      def call
+        File.rename(@old_name, @new_name)
+        nil
+      rescue Errno::ENOENT
+        "No such target file or directory"
+      end
+    end
+  end
+end

data/lib/reen/change.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require_relative "actions/delete"
+require_relative "actions/force_delete"
+require_relative "actions/rename"
+require_relative "actions/nothing"
+
+module Reen
+  # Change to an orignal file
+  class Change
+    attr_reader :original, :requested, :change, :status
+
+    module STATUS
+      ACCEPTED = :accepted
+      REJECTED = :rejected
+      EXECUTED = :executed
+      FAILED   = :failed
+    end
+
+    module CHANGE
+      NONE = :none
+      DELETE = :delete
+      FORCE_DELETE = :force_delete
+      RENAME = :rename
+    end
+
+    module OBJECT
+      FILE = :file
+      FOLDER = :folder
+    end
+
+    ACTION_HANDLER = {
+      CHANGE::NONE => Actions::DoNothing,
+      CHANGE::DELETE => Actions::Delete,
+      CHANGE::FORCE_DELETE => Actions::ForceDelete,
+      CHANGE::RENAME => Actions::Rename
+    }.freeze
+
+    CHANGES_DESC = {
+      CHANGE::NONE => "Nothing",
+      CHANGE::DELETE => "Deleting",
+      CHANGE::FORCE_DELETE => "Force deleting",
+      CHANGE::RENAME => "Renaming"
+    }.freeze
+
+    def initialize(original, requested)
+      @entry = original
+      @original = @entry.path
+      extract_request(requested)
+      decide_object
+      decide_change
+      decide_status_reason
+    end
+
+    def extract_request(str)
+      requested = str.match(/^\s*(?<op>--|-) +(?<name>.*)/) || str.match(/^(?<op>)(?<name>.*)/)
+
+      @operator = requested[:op]
+      @requested = requested[:name].strip
+    end
+
+    def decide_change
+      @change =
+        if @operator == "--"
+          CHANGE::FORCE_DELETE
+        elsif @operator == "-"
+          CHANGE::DELETE
+        elsif @original != @requested
+          CHANGE::RENAME
+        else
+          CHANGE::NONE
+        end
+    end
+
+    def decide_object
+      @object = OBJECT::FILE if request_file?
+      @object = OBJECT::FOLDER if request_dir?
+    end
+
+    def decide_status_reason
+      if request_full_dir? && request_delete?
+        @status = STATUS::REJECTED
+        @reason = "Directories with files cannot be changed"
+      else
+        @status = STATUS::ACCEPTED
+        @reason = ""
+      end
+    end
+
+    def execute
+      return self if not_accepted?
+
+      @status = STATUS::EXECUTED
+      error = ACTION_HANDLER[@change].new(@original, @requested).call
+
+      if error
+        @status = STATUS::FAILED
+        @reason = error
+      end
+
+      self
+    end
+
+    # Predicates
+
+    def request_dir? = @entry.dir?
+
+    def request_file? = @entry.file?
+
+    def request_nothing? = @change == CHANGE::NONE
+
+    def request_rename? = @change == CHANGE::RENAME
+
+    def request_delete? = @change == CHANGE::DELETE
+
+    def request_empty_dir? = @entry.empty_dir?
+
+    def accepted? = @status == STATUS::ACCEPTED
+
+    def not_accepted? = !accepted?
+
+    def executed? = @status == STATUS::EXECUTED
+
+    def rejected? = @status == STATUS::REJECTED
+
+    def failed? = @status == STATUS::FAILED
+
+    def request_full_dir? = @entry.full_dir?
+
+    def executed_or_rejected? = %i[executed rejected].include?(@status)
+
+    # Decoration
+
+    def to_s
+      file_desc =
+        case @change
+        when CHANGE::RENAME
+          "#{@original} -> #{@requested}"
+        else
+          @original
+        end
+
+      reason_desc = rejected? || failed? ? " (failed: #{@reason})" : ""
+
+      "#{CHANGES_DESC[@change]}: #{file_desc}#{reason_desc}"
+    end
+  end
+end

data/lib/reen/changes.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "change"
+
+module Reen
+  # Change to an orignal file
+  class Changes
+    attr_reader :list
+
+    def initialize(changes_list)
+      @list = changes_list
+    end
+
+    def execute_all
+      @list.map(&:execute)
+      self
+    end
+
+    # Queries
+
+    def rename_requested
+      Changes.new(@list.select(&:request_rename?))
+    end
+
+    def delete_requested
+      Changes.new(@list.select(&:request_delete?))
+    end
+
+    def change_requested
+      Changes.new(@list.reject(&:request_nothing?))
+    end
+
+    def rejected
+      Changes.new(@list.select(&:rejected?))
+    end
+
+    def accepted
+      Changes.new(@list.select(&:accepted?))
+    end
+
+    def executed
+      Changes.new(@list.select(&:executed?))
+    end
+
+    def failed
+      Changes.new(@list.select(&:failed?))
+    end
+
+    def any?
+      !@list.empty?
+    end
+
+    def count
+      @list.size
+    end
+
+    # Decoration
+
+    def summarize
+      return "Nothing changed" if @list.empty?
+
+      @list.join("\n")
+    end
+
+    # Predicates
+
+    def no_changes_requested?
+      list.map(&:change).all? Change::CHANGE::NONE
+    end
+
+    def changes_requested?
+      !no_changes_requested?
+    end
+
+    def all_executed?
+      @list.all?(&:executed?)
+    end
+  end
+end

data/lib/reen/changes_file.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+module Reen
+  # Manages a temporary file with requested changes
+  class ChangesFile
+    INSTRUCTIONS = <<~COMMENTS
+      # Edit the names of any files/folders to rename or move them
+      # - Put a dash followed by a space to delete a file or empty folder: - filename
+      # - Put double dash followed by a space to force delete: -- filename
+      # - Do not change or remove the [NN] number prefixes
+      # - You may reorder lines freely; numbers track the original files
+
+    COMMENTS
+
+    attr_accessor :list
+
+    def initialize(entry_list)
+      @entry_list = entry_list
+      @list_file = Tempfile.new("reen-")
+      @list_file.write(INSTRUCTIONS)
+      @list_file.write(@entry_list.to_numbered.join("\n"))
+      @list_file.close
+    end
+
+    def allow_changes(editor, &block)
+      await_editor(editor) if editor
+      @list = File.read(path).split("\n").map(&:strip)
+                  .reject { |line| line.start_with?("#") || line.empty? }
+
+      block&.call(self)
+      @list
+    end
+
+    private
+
+    def path
+      @list_file.path
+    end
+
+    def await_editor(editor)
+      system("#{editor} #{@list_file.path}")
+    end
+  end
+end

data/lib/reen/path_entry.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Reen
+  # Wraps a file path and answers filesystem queries
+  class PathEntry
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def file? = File.file?(@path)
+
+    def dir? = Dir.exist?(@path)
+
+    def empty_dir? = dir? && Dir.empty?(@path)
+
+    def full_dir? = dir? && !Dir.empty?(@path)
+  end
+end

data/lib/reen/path_entry_list.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "path_entry"
+
+module Reen
+  # Collection of PathEntry objects, constructed from an array of path strings
+  class PathEntryList
+    include Enumerable
+
+    def initialize(path_strings)
+      @entries = path_strings.map { |p| PathEntry.new(p) }
+    end
+
+    def each(&block)
+      @entries.each(&block)
+    end
+
+    def paths
+      @entries.map(&:path)
+    end
+
+    def to_numbered
+      width = @entries.size.to_s.length
+      @entries.each_with_index.map do |entry, i|
+        num = format("%0#{width}d", i + 1)
+        "[#{num}] #{entry.path}"
+      end
+    end
+
+    def self.from_numbered(lines)
+      lines.each_with_object({}) do |line, hash|
+        match = line.match(/^\[(\d+)\] (.*)/)
+        next unless match
+
+        hash[match[1].to_i] = match[2]
+      end
+    end
+  end
+end

data/lib/reen/reen.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Reen
+  # Renames pattern of files with given editor
+  # Examples:
+  #   Reen::Reen.new(editor: "code -w").call("spec/fixtures/example/*")
+  #   Reen::Reen.new(editor: nil).call("spec/fixtures/example/*") { ... }
+  class Reen
+    DEL_ERROR = "Do not remove any file/folder names (no changes made)"
+
+    attr_reader :changes
+
+    def initialize(editor: "emacs", options: {})
+      @editor = editor
+      @options = options
+    end
+
+    def request(original_list, &block)
+      @entry_list = PathEntryList.new(original_list)
+      changed_list = ChangesFile.new(@entry_list).allow_changes(@editor, &block)
+
+      raise(Error, DEL_ERROR) if changed_list.size != @entry_list.count
+
+      @changes = compare_lists(@entry_list, changed_list)
+                 .then { |change_array| Changes.new(change_array) }
+    end
+
+    def execute(original_list, &block)
+      @changes ||= request(original_list, &block)
+      @changes = @changes.execute_all
+    end
+
+    private
+
+    def compare_lists(entry_list, changed_list)
+      changed_by_number = PathEntryList.from_numbered(changed_list)
+      entries = entry_list.to_a
+
+      entries.each_with_index.map do |entry, i|
+        number = i + 1
+        revised = changed_by_number[number]
+        Change.new(entry, revised)
+      end
+    end
+  end
+end

data/lib/reen/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Reen
+  VERSION = "1.0.0"
+end

data/lib/reen.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "reen/version"
+require_relative "reen/path_entry"
+require_relative "reen/path_entry_list"
+require_relative "reen/changes_file"
+require_relative "reen/change"
+require_relative "reen/changes"
+require_relative "reen/reen"
+
+module Reen
+  class Error < StandardError; end
+end

data/sig/reenrb.rbs

@@ -0,0 +1,4 @@
+module Reenrb
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: reen
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Soumya Ray
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Renames or deletes a pattern of files using your favorite editor
+email:
+- soumya.ray@gmail.com
+executables:
+- reen
+extensions: []
+extra_rdoc_files: []
+files:
+- ".claude/CLAUDE.md"
+- ".markdownlint.json"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CLAUDE.feature-numbered-lists.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/reen
+- lib/reen.rb
+- lib/reen/actions/delete.rb
+- lib/reen/actions/force_delete.rb
+- lib/reen/actions/nothing.rb
+- lib/reen/actions/rename.rb
+- lib/reen/change.rb
+- lib/reen/changes.rb
+- lib/reen/changes_file.rb
+- lib/reen/path_entry.rb
+- lib/reen/path_entry_list.rb
+- lib/reen/reen.rb
+- lib/reen/version.rb
+- sig/reenrb.rbs
+homepage: https://github.com/soumyaray/reen
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/soumyaray/reen
+  source_code_uri: https://github.com/soumyaray/reen
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.7
+specification_version: 4
+summary: Renames or deletes a pattern of files using your favorite editor
+test_files: []