rubocop-tablecop 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 51eef2c0d5feffe748c3522a755b445f04c3a4b3375ae0aea80fed3abac7e3c6
+  data.tar.gz: d970c3c03b7cf9e4dc01c3184e276e79aaf7e88651d651f5f7d0b444ba7bad21
+SHA512:
+  metadata.gz: 19bed6636d3be68d97d506d660dab28f2470eb2e6f3dc94312809a32ee7909a66d914e3a1995e65278f38e4c8b21c4365cde21839528be48748dad27661bde65
+  data.tar.gz: e0c333e488389fee8c0cace9506b429e3eff5fed20b503ec2972ecbe5030c2b4791ba91cd5f8518e90338d48c93064a4c28b83e0f1507bf57bd7877d8be60b4d

data/CHANGELOG.md

@@ -0,0 +1,63 @@
+# 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.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0] - 2025-12-13
+
+### Changed
+
+- **BREAKING**: Renamed gem from `tablecop` to `rubocop-tablecop` for RuboCop plugin auto-discovery
+- **BREAKING**: Minimum RuboCop version increased from 1.50 to 1.72 (required for plugin system)
+- Migrated to RuboCop's plugin system using `lint_roller`
+- Version module relocated to `RuboCop::Tablecop::Version::STRING` (backwards-compatible `VERSION` constant retained)
+
+### Added
+
+- `RuboCop::Tablecop::Plugin` class for native plugin integration
+- Can now use `plugins: [rubocop-tablecop]` in `.rubocop.yml` instead of `require:`
+
+### Fixed
+
+- Removed unused variable warning in `AlignAssignments` cop
+
+### Migration
+
+Update your configuration:
+
+```yaml
+# Before (.rubocop.yml)
+require:
+  - tablecop
+
+# After (.rubocop.yml)
+plugins:
+  - rubocop-tablecop
+```
+
+Update your Gemfile:
+
+```ruby
+# Before
+gem "tablecop"
+
+# After
+gem "rubocop-tablecop", "~> 0.2"
+```
+
+## [0.1.0] - 2025-12-10
+
+### Added
+
+- `Tablecop/CondenseWhen` - Condenses multi-line `when` clauses to single lines and aligns `then` keywords
+- `Tablecop/AlignMethods` - Aligns contiguous single-line method definitions on the `=` operator
+- `Tablecop/AlignAssignments` - Aligns consecutive assignment statements on the `=` operator
+- `Tablecop/SafeEndlessMethod` - Converts multi-line methods to endless or traditional one-liner form, avoiding RuboCop's known bugs
+- Safe default configuration that disables known-buggy RuboCop cops:
+  - `Style/EndlessMethod` (heredoc destruction, rescue orphaning, module_eval failures)
+  - `Style/DoubleNegation` (semantically wrong: `!!false` ≠ `!false.nil?`)
+  - `Style/HashExcept` (breaks mixed symbol/string key handling)
+  - `Layout/ExtraSpacing` with `ForceEqualSignAlignment` (infinite loops with heredocs)
+- Documentation of known RuboCop autocorrect bugs in `docs/known-issues.md`

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Joseph Wecker
+
+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,433 @@
+# rubocop-tablecop
+
+A RuboCop plugin for table-like, condensed Ruby formatting. Enforces vertical alignment and single-line expressions where they improve readability, while avoiding RuboCop's known autocorrect bugs.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "rubocop-tablecop"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+## Configuration
+
+Add to your `.rubocop.yml`:
+
+```yaml
+# RuboCop 1.72+ (plugin system - recommended)
+plugins:
+  - rubocop-tablecop
+
+# Or for older RuboCop versions
+require:
+  - rubocop-tablecop
+```
+
+The plugin requires **RuboCop >= 1.72**.
+
+## Cops
+
+### Tablecop/AlignAssignments
+
+Aligns consecutive assignment statements on the `=` operator for improved readability.
+
+**Enabled by default:** Yes
+
+**Supports autocorrect:** Yes
+
+**What it does:**
+- Aligns consecutive assignments at the same indentation level
+- Handles simple assignments (`=`), compound assignments (`||=`, `&&=`, `+=`, etc.), and constant assignments
+- Skips lines containing heredocs to avoid infinite loops with other cops
+- Respects `Layout/LineLength` configuration
+
+**Examples:**
+
+```ruby
+# bad
+x = 1
+foo = 2
+barbaz = 3
+
+# good
+x      = 1
+foo    = 2
+barbaz = 3
+```
+
+```ruby
+# bad (compound operators)
+data ||= attrs
+options = default
+config &&= fallback
+
+# good
+data    ||= attrs
+options   = default
+config  &&= fallback
+```
+
+**Limitations:**
+- Skips assignments inside blocks
+- Skips multi-assignment (`a, b = ...`)
+- Skips assignments containing heredocs
+- Only aligns assignments on consecutive lines at the same indentation level
+
+### Tablecop/AlignMethods
+
+Aligns contiguous single-line method definitions so their bodies start at the same column.
+
+**Enabled by default:** Yes
+
+**Supports autocorrect:** Yes
+
+**What it does:**
+- Aligns on `=` for endless methods
+- Aligns traditional one-liners as if they had an invisible `=`
+- Works with both instance and singleton methods
+- Respects `Layout/LineLength` configuration
+
+**Examples:**
+
+```ruby
+# bad
+def foo = 1
+def barbaz = 2
+
+# good
+def foo    = 1
+def barbaz = 2
+```
+
+```ruby
+# bad (mixed endless and traditional)
+def foo = 1
+def bar() 2 end
+
+# good
+def foo   = 1
+def bar()   2 end
+```
+
+```ruby
+# bad (singleton methods)
+def self.x = 1
+def self.longer_name = 2
+
+# good
+def self.x           = 1
+def self.longer_name = 2
+```
+
+**Limitations:**
+- Only aligns methods on consecutive lines at the same indentation level
+- Only processes single-line methods
+
+### Tablecop/CondenseWhen
+
+Condenses multi-line `when` clauses to single lines using the `then` keyword and aligns them vertically.
+
+**Enabled by default:** Yes
+
+**Supports autocorrect:** Yes
+
+**What it does:**
+- Converts multi-line `when` clauses to single-line format with `then`
+- Aligns `then` keywords across sibling `when` clauses for table-like appearance
+- Only condenses when the result fits within `Layout/LineLength`
+- Preserves complex bodies that shouldn't be condensed
+
+**Examples:**
+
+```ruby
+# bad
+case foo
+when 1
+  "one"
+when 200
+  "two hundred"
+end
+
+# good
+case foo
+when 1   then "one"
+when 200 then "two hundred"
+end
+```
+
+```ruby
+# bad
+case status
+when :pending
+  handle_pending
+when :approved
+  handle_approved
+end
+
+# good
+case status
+when :pending  then handle_pending
+when :approved then handle_approved
+end
+```
+
+**What it skips:**
+- Multi-statement bodies
+- Bodies with heredocs
+- Bodies with multi-line strings
+- Bodies with comments between `when` and body
+- Complex control flow (multi-line `if`/`case`)
+- Multi-statement blocks
+- Cases where condensing would exceed line length
+
+**Example of what's left alone:**
+
+```ruby
+# left alone (multiple statements)
+case foo
+when 1
+  do_something
+  do_something_else
+end
+
+# left alone (heredoc)
+case foo
+when 1
+  <<~MSG
+    Hello
+  MSG
+end
+```
+
+### Tablecop/SafeEndlessMethod
+
+Converts multi-line single-expression methods to single-line form, avoiding all the known bugs in RuboCop's `Style/EndlessMethod`.
+
+**Enabled by default:** Yes
+
+**Supports autocorrect:** Yes
+
+**What it does:**
+- Converts simple multi-line methods to endless method syntax (`def foo = expr`)
+- Falls back to traditional one-liner (`def foo() expr end`) for methods with modifier-if/unless that call other methods
+- Avoids RuboCop's `Style/EndlessMethod` bugs:
+  - Heredoc destruction
+  - Rescue clause orphaning
+  - module_eval context failures
+  - Modifier-if with dynamic method failures
+
+**Examples:**
+
+```ruby
+# bad
+def foo
+  42
+end
+
+# good
+def foo = 42
+```
+
+```ruby
+# bad
+def calculate(x, y)
+  x + y
+end
+
+# good
+def calculate(x, y) = x + y
+```
+
+```ruby
+# bad (modifier-if with method call)
+def clear!
+  data_layer.clear! if data_layer.respond_to?(:clear!)
+end
+
+# good (uses traditional one-liner to avoid bugs)
+def clear!() data_layer.clear! if data_layer.respond_to?(:clear!) end
+```
+
+**What it skips:**
+- Methods already on a single line
+- Methods with multiple statements
+- Methods with heredocs
+- Methods with rescue/ensure clauses
+- Setter methods (ending with `=`)
+- Methods with multi-statement blocks
+- Methods with complex control flow (multi-line `if`/`case`)
+- Methods where condensing would exceed line length
+
+## Built-in Cop Configuration
+
+Tablecop sets opinionated defaults for RuboCop's built-in cops to achieve a table-like, condensed style. These are configured in `config/default.yml` and automatically applied when you use the plugin.
+
+### Disabled Cops (Conflicts)
+
+These cops are disabled because they conflict with Tablecop's alignment features:
+
+```yaml
+# Conflicts with Tablecop/AlignAssignments
+Layout/SpaceAroundOperators:
+  Enabled: false  # Enforces exactly one space, undoes alignment
+
+# Conflicts with Tablecop/SafeEndlessMethod
+Style/SingleLineDoEndBlock:
+  Enabled: false  # Would reformat SafeEndlessMethod output
+
+Style/SingleLineMethods:
+  Enabled: false  # Would reformat SafeEndlessMethod output
+```
+
+### Disabled Cops (Known Bugs)
+
+These cops have critical autocorrect bugs and are replaced by safer Tablecop equivalents:
+
+```yaml
+# REPLACED by Tablecop/SafeEndlessMethod
+Style/EndlessMethod:
+  Enabled: false  # Destroys heredocs, orphans rescue clauses
+
+Style/AmbiguousEndlessMethodDefinition:
+  Enabled: false  # Related to EndlessMethod issues
+
+# BUGS: Creates syntax errors and silent logic bugs
+Style/DoubleNegation:
+  Enabled: false  # !!false ≠ !false.nil?
+
+Style/HashExcept:
+  Enabled: false  # Breaks mixed symbol/string key handling
+```
+
+### Layout Configuration
+
+```yaml
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+  EnforcedLastArgumentHashStyle: always_inspect
+
+Layout/ExtraSpacing:
+  AllowForAlignment: true
+  AllowBeforeTrailingComments: true
+  ForceEqualSignAlignment: false  # Would cause infinite loops with heredocs
+
+Layout/FirstArrayElementIndentation:
+  EnforcedStyle: consistent  # Not aligned to brackets
+
+Layout/FirstArgumentIndentation:
+  EnforcedStyle: consistent  # Not aligned to parens
+
+Layout/SpaceInsideHashLiteralBraces:
+  EnforcedStyle: space  # { foo: 1 } not {foo: 1}
+```
+
+See `config/default.yml` for the complete configuration.
+
+## Known Issues
+
+RuboCop has several autocorrect bugs that can destroy code. Tablecop's default configuration disables or works around these where possible. See [docs/known-issues.md](docs/known-issues.md) for detailed documentation of:
+
+| Bug | Cop | Impact | Tablecop Mitigation |
+|-----|-----|--------|---------------------|
+| Heredoc destruction | `Style/EndlessMethod` | Data loss | Disabled; use `Tablecop/SafeEndlessMethod` |
+| Rescue orphaning | `Style/EndlessMethod` | Scope/syntax errors | Disabled; use `Tablecop/SafeEndlessMethod` |
+| module_eval failures | `Style/EndlessMethod` | Runtime NameError | Disabled; use `Tablecop/SafeEndlessMethod` |
+| Modifier-if parse failures | `Style/EndlessMethod` | Parse-time NameError | Disabled; use `Tablecop/SafeEndlessMethod` |
+| Heredoc alignment loop | `Layout/ExtraSpacing` | Process hangs | `ForceEqualSignAlignment: false` |
+| `!!false` → `!false.nil?` | `Style/DoubleNegation` | Silent logic bug | Disabled |
+| Mixed key types | `Style/HashExcept` | Data corruption | Disabled |
+
+## Example Output
+
+Here's what code looks like with Tablecop's formatting:
+
+```ruby
+# Method alignment
+class Calculator
+  def add(x, y)      = x + y
+  def subtract(x, y) = x - y
+  def multiply(x, y) = x * y
+  def divide(x, y)   = x / y
+end
+
+# Assignment alignment
+class Config
+  BASE_URL    = "https://example.com"
+  API_VERSION = "v1"
+  TIMEOUT     = 30
+
+  def initialize
+    @cache   = {}
+    @enabled = true
+    @retries = 3
+  end
+end
+
+# Case statement condensing
+def status_message(status)
+  case status
+  when :pending   then "Waiting for approval"
+  when :approved  then "Ready to proceed"
+  when :rejected  then "Cannot continue"
+  when :completed then "All done"
+  end
+end
+
+# Hash alignment
+config = {
+  host:     "localhost",
+  port:     3000,
+  ssl:      true,
+  timeout:  30,
+  retries:  3,
+  pool:     10
+}
+```
+
+## Philosophy
+
+Tablecop prioritizes:
+
+1. **Vertical alignment** - Code aligned in columns is easier to scan
+2. **Density** - Single-line expressions where appropriate reduce scrolling
+3. **Safety** - Avoid RuboCop's known autocorrect bugs
+4. **Readability** - Only condense when it improves clarity
+
+This style works best for:
+- Configuration files with many similar assignments
+- Simple data transformations and mappings
+- API clients with many similar methods
+- DSLs with repetitive structures
+
+This style may not work well for:
+- Complex business logic with deep nesting
+- Long method chains
+- Files with highly variable line lengths
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then:
+
+```bash
+# Run RuboCop on the project
+bundle exec rubocop
+
+# Run autocorrect
+bundle exec rubocop -a
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/v2-io/tablecop.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE).

data/config/default.yml

@@ -0,0 +1,99 @@
+# Tablecop Default Configuration
+#
+# Table-like, condensed Ruby formatting.
+# These defaults prioritize vertical alignment and single-line expressions
+# where they improve readability.
+#
+# CAUTION: Some alignment cops have known bugs with autocorrect.
+# See docs/known-issues.md for details.
+
+# =============================================================================
+# Tablecop Custom Cops
+# =============================================================================
+
+Tablecop/AlignAssignments:
+  Description: "Align consecutive assignments on the = operator."
+  Enabled: true
+  VersionAdded: "0.1.0"
+
+Tablecop/AlignMethods:
+  Description: "Align contiguous single-line method definitions."
+  Enabled: true
+  VersionAdded: "0.1.0"
+
+Tablecop/CondenseWhen:
+  Description: "Condense multi-line `when` clauses to single lines when possible."
+  Enabled: true
+  VersionAdded: "0.1.0"
+
+Tablecop/SafeEndlessMethod:
+  Description: "Convert multi-line methods to single-line, avoiding RuboCop bugs."
+  Enabled: true
+  VersionAdded: "0.1.0"
+
+# =============================================================================
+# Disabled Cops (conflict with Tablecop alignment)
+# =============================================================================
+
+# DISABLED: Conflicts with Tablecop/AlignAssignments.
+# SpaceAroundOperators enforces exactly one space, which undoes alignment padding.
+Layout/SpaceAroundOperators:
+  Enabled: false
+
+# DISABLED: Conflicts with Tablecop/SafeEndlessMethod.
+# These cops try to reformat blocks/methods that SafeEndlessMethod creates,
+# causing infinite autocorrect loops.
+Style/SingleLineDoEndBlock:
+  Enabled: false
+
+Style/SingleLineMethods:
+  Enabled: false
+
+# =============================================================================
+# Disabled Cops (replaced by Tablecop equivalents)
+# =============================================================================
+
+# DISABLED: Style/EndlessMethod has critical autocorrect bugs:
+# - Destroys heredoc content entirely
+# - Breaks rescue clauses (orphans them outside the class)
+# - Fails in module_eval contexts (Toys, DSLs)
+# - Fails with modifier-if calling dynamic methods
+# See docs/known-issues.md for details.
+# Use Tablecop/SafeEndlessMethod instead.
+Style/EndlessMethod:
+  Enabled: false
+
+# Related to EndlessMethod - can cause issues in the same contexts
+Style/AmbiguousEndlessMethodDefinition:
+  Enabled: false
+
+# =============================================================================
+# Layout - Alignment
+# =============================================================================
+
+# Require spaces inside hash braces: { foo: 1 }
+Layout/SpaceInsideHashLiteralBraces:
+  EnforcedStyle: space
+
+# Allow extra spacing for alignment
+# NOTE: ForceEqualSignAlignment has a bug with compound operators (||=, &&=)
+# that can create syntax errors. Use with caution.
+Layout/ExtraSpacing:
+  AllowForAlignment: true
+  AllowBeforeTrailingComments: true
+  ForceEqualSignAlignment: false  # Disabled due to ||= bug
+
+# Table-style hash alignment
+# NOTE: Can cause infinite loops when combined with other alignment cops.
+# If you experience hangs, try switching to 'key' style.
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+  EnforcedLastArgumentHashStyle: always_inspect
+
+# Consistent indentation (not aligned to brackets/parens)
+Layout/FirstArrayElementIndentation:
+  EnforcedStyle: consistent
+
+Layout/FirstArgumentIndentation:
+  EnforcedStyle: consistent