RubyGems - rubocop-tablecop - Versions diffs - 0.2.0 - Mend

rubocop-tablecop 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

checksums.yaml +7 -0
data/CHANGELOG.md +63 -0
data/LICENSE +21 -0
data/README.md +433 -0
data/config/default.yml +99 -0
data/lib/rubocop/cop/tablecop/align_assignments.rb +240 -0
data/lib/rubocop/cop/tablecop/align_methods.rb +140 -0
data/lib/rubocop/cop/tablecop/condense_when.rb +207 -0
data/lib/rubocop/cop/tablecop/safe_endless_method.rb +255 -0
data/lib/rubocop/cop/tablecop_cops.rb +6 -0
data/lib/rubocop/tablecop/plugin.rb +37 -0
data/lib/rubocop/tablecop/version.rb +17 -0
data/lib/rubocop/tablecop.rb +8 -0
data/lib/rubocop-tablecop.rb +8 -0
metadata +89 -0

data/lib/rubocop/cop/tablecop/safe_endless_method.rb ADDED Viewed

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+module RuboCop
+  module Cop
+    module Tablecop
+      # Converts multi-line single-expression methods to single-line form.
+      #
+      # Uses endless method syntax (`def foo = expr`) for simple cases, but falls
+      # back to traditional one-liner (`def foo() expr end`) for methods with
+      # modifier-if/unless that call other methods (which can fail in module_eval
+      # contexts or at parse time).
+      #
+      # This cop avoids the bugs in RuboCop's Style/EndlessMethod:
+      # - Heredoc destruction
+      # - Rescue clause orphaning
+      # - module_eval context failures
+      # - Modifier-if with dynamic method failures
+      #
+      # @example Endless method (safe)
+      #   # bad
+      #   def foo
+      #     42
+      #   end
+      #
+      #   # good
+      #   def foo = 42
+      #
+      # @example Traditional one-liner (modifier-if with method call)
+      #   # bad
+      #   def clear!
+      #     data_layer.clear! if data_layer.respond_to?(:clear!)
+      #   end
+      #
+      #   # good
+      #   def clear!() data_layer.clear! if data_layer.respond_to?(:clear!) end
+      #
+      class SafeEndlessMethod < Base
+        extend AutoCorrector
+        MSG_ENDLESS = "Use endless method: `def %<name>s%<args>s = %<body>s`"
+        MSG_TRADITIONAL = "Use single-line method: `def %<name>s%<args>s %<body>s end`"
+        def on_def(node)
+          return unless convertible?(node)
+          if should_use_traditional?(node)
+            register_traditional_offense(node)
+          else
+            register_endless_offense(node)
+          end
+        end
+        alias on_defs on_def
+        private
+        def convertible?(node)
+          # Skip if already single-line
+          return false if node.single_line?
+          # Must have a body
+          return false unless node.body
+          # Setter methods (ending with =) can't use endless syntax
+          return false if node.method_name.to_s.end_with?("=")
+          # Body must be single expression (not begin block with multiple children)
+          return false if node.body.begin_type?
+          # No heredocs
+          return false if contains_heredoc?(node.body)
+          # No rescue/ensure (these are resbody/ensure node types in the method)
+          return false if has_rescue_or_ensure?(node)
+          # No multi-statement blocks - condensing them breaks syntax
+          # (statements need semicolons or newlines, not just spaces)
+          return false if contains_multi_statement_block?(node.body)
+          # No complex control flow (if/else, case) - can't condense safely
+          return false if contains_complex_control_flow?(node.body)
+          # Check line length
+          return false unless fits_line_length?(node)
+          true
+        end
+        def should_use_traditional?(node)
+          # Use traditional one-liner if body has modifier-if/unless with method calls
+          # These can fail in module_eval contexts or at parse time
+          body = node.body
+          return false unless body.respond_to?(:type)
+          if body.type == :if && body.modifier_form?
+            # Check if the condition or body contains method calls
+            has_method_calls?(body)
+          else
+            false
+          end
+        end
+        def has_method_calls?(node)
+          return false unless node
+          # Direct method call (send node)
+          return true if node.send_type?
+          # Check children
+          node.each_child_node do |child|
+            return true if has_method_calls?(child)
+          end
+          false
+        end
+        def contains_heredoc?(node)
+          return false unless node
+          return true if node.respond_to?(:heredoc?) && node.heredoc?
+          node.each_descendant(:str, :dstr, :xstr).any?(&:heredoc?)
+        end
+        def has_rescue_or_ensure?(node)
+          # Check if the method has a rescue or ensure block
+          # These show up as the method body being a :rescue or :ensure node
+          return true if node.body&.rescue_type?
+          return true if node.body&.ensure_type?
+          # Also check for rescue as part of method definition (def foo; rescue; end)
+          node.each_descendant(:rescue, :ensure, :resbody).any?
+        end
+        def contains_multi_statement_block?(node)
+          return false unless node
+          # Check if node itself is a block with multiple statements
+          if node.block_type? || node.numblock_type?
+            block_body = node.body
+            # Multiple statements show up as a :begin node
+            return true if block_body&.begin_type?
+          end
+          # Check descendants for blocks with multiple statements
+          node.each_descendant(:block, :numblock) do |block_node|
+            block_body = block_node.body
+            return true if block_body&.begin_type?
+          end
+          false
+        end
+        def contains_complex_control_flow?(node)
+          return false unless node
+          # Multi-line if/unless/case can't be condensed safely
+          # (modifier-if is handled separately in should_use_traditional?)
+          if node.if_type? || node.case_type?
+            return true unless node.single_line?
+          end
+          # Check descendants for complex control flow
+          node.each_descendant(:if, :case) do |control_node|
+            return true unless control_node.single_line?
+          end
+          false
+        end
+        def fits_line_length?(node)
+          endless_line = build_endless_line(node)
+          traditional_line = build_traditional_line(node)
+          # Use the shorter form for checking
+          min_length = [endless_line.length, traditional_line.length].min
+          indent = node.loc.keyword.column
+          (indent + min_length) <= max_line_length
+        end
+        def build_method_signature(node)
+          if node.defs_type?
+            # Singleton method: def self.foo or def obj.foo
+            receiver = node.receiver.source
+            "def #{receiver}.#{node.method_name}"
+          else
+            "def #{node.method_name}"
+          end
+        end
+        def build_args(node)
+          return "" unless node.arguments?
+          args_source = node.arguments.source
+          # Arguments source may or may not include parens
+          if args_source.start_with?("(")
+            args_source
+          else
+            "(#{args_source})"
+          end
+        end
+        def build_endless_line(node)
+          sig = build_method_signature(node)
+          args = build_args(node)
+          body = node.body.source.gsub(/\s*\n\s*/, " ").strip
+          "#{sig}#{args} = #{body}"
+        end
+        def build_traditional_line(node)
+          sig = build_method_signature(node)
+          args = if node.arguments?
+                   args_source = node.arguments.source
+                   args_source.start_with?("(") ? args_source : "(#{args_source})"
+                 else
+                   "()"
+                 end
+          body = node.body.source.gsub(/\s*\n\s*/, " ").strip
+          "#{sig}#{args} #{body} end"
+        end
+        def register_endless_offense(node)
+          sig = build_method_signature(node)
+          args = build_args(node)
+          body = node.body.source.gsub(/\s*\n\s*/, " ").strip
+          message = format(MSG_ENDLESS, name: sig.sub("def ", ""), args: args, body: body)
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, build_endless_line(node))
+          end
+        end
+        def register_traditional_offense(node)
+          sig = build_method_signature(node)
+          args = node.arguments? ? "(#{node.arguments.source})" : "()"
+          body = node.body.source.gsub(/\s*\n\s*/, " ").strip
+          message = format(MSG_TRADITIONAL, name: sig.sub("def ", ""), args: args, body: body)
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, build_traditional_line(node))
+          end
+        end
+        def max_line_length
+          config.for_cop("Layout/LineLength")["Max"] || 120
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/tablecop_cops.rb ADDED Viewed

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+require_relative "tablecop/align_assignments"
+require_relative "tablecop/align_methods"
+require_relative "tablecop/condense_when"
+require_relative "tablecop/safe_endless_method"

data/lib/rubocop/tablecop/plugin.rb ADDED Viewed

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+require "lint_roller"
+module RuboCop
+  module Tablecop
+    # Integrates rubocop-tablecop with RuboCop's plugin system.
+    #
+    # This plugin provides cops for table-like, condensed Ruby formatting:
+    # - AlignAssignments: Align consecutive assignments on the = operator
+    # - AlignMethods: Align contiguous single-line method definitions
+    # - CondenseWhen: Condense multi-line when clauses to single lines
+    # - SafeEndlessMethod: Convert methods to endless form safely
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(
+          name: "rubocop-tablecop",
+          version: Version::STRING,
+          homepage: "https://github.com/v2-io/tablecop",
+          description: "Table-like, condensed Ruby formatting cops."
+        )
+      end
+      def supported?(context)
+        context.engine == :rubocop
+      end
+      def rules(_context)
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: Pathname.new(__dir__).join("../../../config/default.yml")
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/tablecop/version.rb ADDED Viewed

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module RuboCop
+  module Tablecop
+    # Version information for rubocop-tablecop.
+    module Version
+      STRING = "0.2.0"
+      def self.document_version
+        STRING.match('\d+\.\d+').to_s
+      end
+    end
+    # For backwards compatibility with code expecting RuboCop::Tablecop::VERSION
+    VERSION = Version::STRING
+  end
+end

data/lib/rubocop/tablecop.rb ADDED Viewed

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module RuboCop
+  # RuboCop Tablecop project namespace.
+  # Provides cops for table-like, condensed Ruby formatting.
+  module Tablecop
+  end
+end

data/lib/rubocop-tablecop.rb ADDED Viewed

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+require "rubocop"
+require_relative "rubocop/tablecop"
+require_relative "rubocop/tablecop/version"
+require_relative "rubocop/tablecop/plugin"
+require_relative "rubocop/cop/tablecop_cops"

metadata ADDED Viewed

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-tablecop
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Joseph Wecker
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-12-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.72'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.72'
+- !ruby/object:Gem::Dependency
+  name: lint_roller
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: Custom RuboCop cops that enforce vertical alignment and condensed single-line
+  expressions where appropriate.
+email:
+- joseph@v2.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- config/default.yml
+- lib/rubocop-tablecop.rb
+- lib/rubocop/cop/tablecop/align_assignments.rb
+- lib/rubocop/cop/tablecop/align_methods.rb
+- lib/rubocop/cop/tablecop/condense_when.rb
+- lib/rubocop/cop/tablecop/safe_endless_method.rb
+- lib/rubocop/cop/tablecop_cops.rb
+- lib/rubocop/tablecop.rb
+- lib/rubocop/tablecop/plugin.rb
+- lib/rubocop/tablecop/version.rb
+homepage: https://github.com/v2-io/rubocop-tablecop
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/v2-io/rubocop-tablecop
+  changelog_uri: https://github.com/v2-io/rubocop-tablecop/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+  default_lint_roller_plugin: RuboCop::Tablecop::Plugin
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: RuboCop extension for table-like, condensed Ruby formatting
+test_files: []