immosquare-cleaner 0.1.109 → 0.1.110

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd38a7439f9f3972620d9b1bd626dbdda59ea57c4b44b4c3358fae765d4ee25a
-  data.tar.gz: 13127c3a36e4b00c3b29de218df8f0c974f82b056f1c5ad2846cea09d69a610c
+  metadata.gz: 5ecfb20b449cc9d9a557ca71d325a463c4e3f11343b85ab2c336e74952a84599
+  data.tar.gz: e073034f35d4729ed66430456fc298eccc4dd1ee21f1e16f08ff263b51a63bc7
 SHA512:
-  metadata.gz: 3a27177e3c628cc6db2ad30fb6225111cd54e4dae8d0da0a94abec69bab21cd68fe99dc2357b0f15b3c7decd7648d719d0ed24f87b8960f78fef3147d885965b
-  data.tar.gz: 7f89548fc37bc0801b9609114ddfd752e59cbeab3ee35f12fb416ed32857cc5e87c8b506666631887112cca3aa8a9873a8547c938a68200ac55d3922a88e3793
+  metadata.gz: 45aff6bbc275cf2494ffb00617e5ea934836a7e3cf50bb6b640cdc7d462b2bff15e3ed3da79e0edb85753129df1f54d4b0206b1e22851638b38be36a894348ed
+  data.tar.gz: 0024bf22be91d820c4f817960f1551d3370038c013c45905bbbd600a7136b4c8630c6f597b8c84c404ebcb7a2aa3b6ee83e5df188dfa771fd1ca69a2d9464630

data/lib/immosquare-cleaner/version.rb

@@ -1,3 +1,3 @@
 module ImmosquareCleaner
-  VERSION = "0.1.109".freeze
+  VERSION = "0.1.110".freeze
 end

data/linters/{erb-lint-4.0.3.yml → erb-lint-4.0.4.yml}

@@ -9,10 +9,14 @@ linters:
     enabled: true
   CustomHtmlToContentTag:
     enabled: true
+  CustomAlignConsecutiveCalls:
+    enabled: true
+    methods:
+    - link_to
   Rubocop:
     enabled: true
     rubocop_config:
       inherit_from:
-      - linters/rubocop-4.0.3.yml
+      - linters/rubocop-4.0.4.yml
       Layout/TrailingWhitespace:
         Enabled: false

data/linters/erb-lint.yml

@@ -8,6 +8,10 @@ linters:
     enabled: true
   CustomHtmlToContentTag:
     enabled: true
+  CustomAlignConsecutiveCalls:
+    enabled: true
+    methods:
+      - link_to
   Rubocop:
     enabled: true
     rubocop_config:

data/linters/erb_lint/custom_align_consecutive_calls.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "rubocop-ast"
+
+module ERBLint
+  module Linters
+    ##============================================================##
+    ## Aligns the arguments of consecutive ERB output calls to the
+    ## same configured method (default: link_to) when:
+    ##   - they're on adjacent lines,
+    ##   - separated only by whitespace,
+    ##   - have the same arity,
+    ##   - have the same keyword keys in the same order.
+    ##
+    ## Each argument becomes a column; cells are right-padded with
+    ## spaces so that the next argument starts at the same column
+    ## across all lines in the group.
+    ##
+    ## @example
+    ## bad
+    ##   <%= link_to(t("a"), foo_path(:id => 1), :class => "dropdown-item", :remote => true) %>
+    ##   <%= link_to(t("bbbb"), bar_path(:id => 2), :class => "dropdown-item #{x}", :remote => true) %>
+    ##
+    ## good
+    ##   <%= link_to(t("a"),    foo_path(:id => 1), :class => "dropdown-item",      :remote => true) %>
+    ##   <%= link_to(t("bbbb"), bar_path(:id => 2), :class => "dropdown-item #{x}", :remote => true) %>
+    ##============================================================##
+    class CustomAlignConsecutiveCalls < Linter
+
+      include LinterRegistry
+
+      MSG = "Align consecutive `%s` calls."
+
+      class ConfigSchema < LinterConfig
+
+        property(:methods, :accepts => array_of?(String), :default => -> { ["link_to"] })
+
+      end
+
+      self.config_schema = ConfigSchema
+
+      def run(processed_source)
+        output_nodes = processed_source.ast.descendants(:erb).select {|n| output_erb?(n) }
+        return if output_nodes.size < 2
+
+        ##============================================================##
+        ## Group adjacent output ERB nodes (whitespace-only between).
+        ##============================================================##
+        groups = group_adjacent(output_nodes, processed_source)
+
+        groups.each do |group|
+          next if group.size < 2
+
+          rebuild_group(group, processed_source)
+        end
+      end
+
+      def autocorrect(_processed_source, offense)
+        lambda do |corrector|
+          corrector.replace(offense.source_range, offense.context[:new_code])
+        end
+      end
+
+      private
+
+      ##============================================================##
+      ## Build aligned rewrites for the group, add an offense per
+      ## call that needs to change.
+      ##============================================================##
+      def rebuild_group(group, processed_source)
+        parsed = group.map {|node| parse_call(strip_code(extract_code(node))) }
+        return if parsed.any?(&:nil?)
+
+        method_name = parsed.first[:method]
+        return unless allowed_methods.include?(method_name)
+        return unless parsed.all? {|p| p[:method] == method_name }
+
+        ##============================================================##
+        ## All calls must share the same arg signature
+        ## (same positional/kwarg layout, same kw keys in same order).
+        ##============================================================##
+        signatures = parsed.map {|p| p[:args].map {|a| a[:kind] == :kwarg ? [:kwarg, a[:key]] : [:positional] } }
+        return unless signatures.uniq.size == 1
+
+        n_cols     = parsed.first[:args].size
+        col_widths = (0...n_cols).map {|i| parsed.map {|p| p[:args][i][:text].length }.max }
+
+        parsed.each_with_index do |p, idx|
+          rebuilt = "#{p[:method]}(#{join_padded(p[:args], col_widths)})"
+          current = strip_code(extract_code(group[idx])).strip
+          next if current == rebuilt
+
+          code_loc = group[idx].children[2].loc
+          range    = processed_source.to_source_range(code_loc.begin_pos...code_loc.end_pos)
+          add_offense(range, format(MSG, method_name), :new_code => " #{rebuilt} ")
+        end
+      end
+
+      ##============================================================##
+      ## Join args with `, ` and right-pad AFTER the comma so the
+      ## next column starts at a consistent position across all rows
+      ## in the group. Padding goes after the comma (not before) so
+      ## the comma stays glued to its arg.
+      ##============================================================##
+      def join_padded(args, col_widths)
+        last = args.size - 1
+        out  = +""
+        args.each_with_index do |a, i|
+          if i == last
+            out << a[:text]
+          else
+            pad = " " * (col_widths[i] - a[:text].length)
+            out << a[:text] << ", " << pad
+          end
+        end
+        out
+      end
+
+      def allowed_methods
+        Array(@config.methods)
+      end
+
+      ##============================================================##
+      ## Parse a single Ruby call via the parser shipped with
+      ## rubocop-ast. Returns nil if the source isn't a clean
+      ## `method(args...)` call.
+      ##
+      ## Each hash pair is captured via `pair.loc.expression.source`
+      ## so we preserve the original syntax (hashrocket vs short
+      ## `key:` form). The `:key` field carries only the semantic
+      ## key name (used for signature comparison across calls).
+      ##
+      ## Note (perf) : a `RuboCop::ProcessedSource` is created per
+      ## call. For a view with hundreds of `link_to`s in a single
+      ## group this scales linearly. Acceptable for the typical
+      ## case (a few consecutive calls); memoise if it ever shows
+      ## up in profiling.
+      ##============================================================##
+      def parse_call(code)
+        return nil if code.nil? || code.empty?
+
+        source = RuboCop::ProcessedSource.new(code, RUBY_VERSION.to_f)
+        return nil if source.ast.nil?
+
+        node = source.ast
+        return nil unless node.respond_to?(:type) && node.type == :send
+        return nil unless node.children[0].nil?
+
+        method = node.children[1].to_s
+        args   = []
+        node.children[2..].each do |arg|
+          if arg.type == :hash
+            arg.children.each do |pair|
+              key_node = pair.children.first
+              args << {:kind => :kwarg, :key => key_name(key_node), :text => pair.loc.expression.source}
+            end
+          else
+            args << {:kind => :positional, :text => arg.loc.expression.source}
+          end
+        end
+
+        {:method => method, :args => args}
+      rescue StandardError
+        nil
+      end
+
+      ##============================================================##
+      ## Extract the semantic key name from a hash pair's key node.
+      ## Handles :sym (hashrocket and short syntax) and "string"
+      ## keys. Dynamic keys fall back to their source.
+      ##============================================================##
+      def key_name(key_node)
+        return nil unless key_node
+
+        case key_node.type
+        when :sym, :str then key_node.value.to_s
+        else key_node.loc.expression.source
+        end
+      end
+
+      ##============================================================##
+      ## Walk the output nodes and break into groups whenever the
+      ## text between two adjacent nodes is not whitespace-only or
+      ## contains zero newlines (meaning the nodes are on the same
+      ## line).
+      ##============================================================##
+      def group_adjacent(nodes, processed_source)
+        groups  = []
+        current = []
+        source  = processed_source.source_buffer.source
+
+        nodes.each do |node|
+          if current.empty?
+            current << node
+            next
+          end
+
+          between = source[current.last.loc.end_pos...node.loc.begin_pos]
+          if between.match?(/\A\s*\z/) && between.count("\n") >= 1
+            current << node
+          else
+            groups << current
+            current = [node]
+          end
+        end
+
+        groups << current unless current.empty?
+        groups
+      end
+
+      def output_erb?(erb_node)
+        indicator = erb_node.children.first
+        indicator.respond_to?(:children) && indicator.children.first == "="
+      end
+
+      def extract_code(erb_node)
+        erb_node.children[2]&.loc&.source
+      end
+
+      def strip_code(code)
+        code.to_s.strip
+      end
+
+    end
+  end
+end

data/linters/{js-erb-lint-4.0.3.yml → js-erb-lint-4.0.4.yml}

@@ -21,6 +21,6 @@ linters:
     enabled: true
     rubocop_config:
       inherit_from:
-      - linters/rubocop-4.0.3.yml
+      - linters/rubocop-4.0.4.yml
       Layout/TrailingWhitespace:
         Enabled: false

data/linters/rubocop/cop/custom_cops/style/inline_multiline_calls.rb

@@ -0,0 +1,118 @@
+module RuboCop
+  module Cop
+    module CustomCops
+      module Style
+        ##============================================================##
+        ## Collapses multi-line method calls onto a single line when
+        ## the method name is part of the configurable allowlist
+        ## (`Methods`). No max-length cap — the call is always
+        ## collapsed.
+        ##
+        ## Designed for helper-like calls that read cleaner inline
+        ## (e.g. `link_to`, `button_to`, ...) but get split by hand
+        ## or by other autocorrects.
+        ##
+        ## The cop walks the AST and rebuilds the call from each
+        ## argument's source. This is intentionally safer than a
+        ## regex-based collapse: comments inside the call and
+        ## multi-line string literals would otherwise be silently
+        ## corrupted, so the cop refuses to act on them.
+        ##
+        ## @example
+        ## bad
+        ## link_to(t("app.add.something"),
+        ##         my_path(:id => id),
+        ##         :class  => "dropdown-item",
+        ##         :remote => true)
+        ##
+        ## good
+        ## link_to(t("app.add.something"), my_path(:id => id), :class => "dropdown-item", :remote => true)
+        ##============================================================##
+        class InlineMultilineCalls < RuboCop::Cop::Base
+
+          extend AutoCorrector
+
+          MSG = "Collapse multi-line `%<name>s` call into a single line.".freeze
+
+          DEFAULT_METHODS = ["link_to"].freeze
+
+          def on_send(node)
+            return unless target_methods.include?(node.method_name.to_s)
+            return unless multiline_call?(node)
+            return if contains_comment?(node)
+
+            rebuilt = rebuild(node)
+            return if rebuilt.nil?
+            return if rebuilt.include?("\n")
+            return if rebuilt == node.source
+
+            add_offense(node, :message => format(MSG, :name => node.method_name)) do |corrector|
+              corrector.replace(node, rebuilt)
+            end
+          end
+          alias on_csend on_send
+
+          private
+
+          ##============================================================##
+          ## A send node is multi-line if its source spans more than one
+          ## line. We rely on the source range rather than `node.multiline?`
+          ## because we want to react to formatting, not just node shape.
+          ##============================================================##
+          def multiline_call?(node)
+            range = node.source_range
+            range.first_line != range.last_line
+          end
+
+          ##============================================================##
+          ## Refuse to act if any comment lives inside the call. Comments
+          ## terminate at the next newline; collapsing newlines would
+          ## swallow the args that follow the comment.
+          ##============================================================##
+          def contains_comment?(node)
+            range = node.source_range
+            processed_source.comments.any? do |comment|
+              loc = comment.loc.expression
+              loc.begin_pos >= range.begin_pos && loc.end_pos <= range.end_pos
+            end
+          end
+
+          ##============================================================##
+          ## Rebuild the call by joining each argument's source. Hash
+          ## args are unfolded into their individual pairs so the joiner
+          ## (", ") is consistent across all chunks. Returns nil when
+          ## an individual arg is itself multi-line — a heredoc, a
+          ## multi-line string literal, or a multi-line block expression
+          ## inside an arg. Touching those would be unsafe.
+          ##============================================================##
+          def rebuild(node)
+            chunks = node.arguments.flat_map do |arg|
+              if arg.hash_type? && !arg.braces?
+                arg.children.map(&:source)
+              else
+                [arg.source]
+              end
+            end
+
+            return nil if chunks.any? {|src| src.include?("\n") }
+
+            receiver_part = node.receiver ? "#{node.receiver.source}#{node.csend_type? ? "&." : "."}" : ""
+            method_part   = node.method_name
+            args_joined   = chunks.join(", ")
+
+            if node.parenthesized?
+              "#{receiver_part}#{method_part}(#{args_joined})"
+            else
+              "#{receiver_part}#{method_part} #{args_joined}"
+            end
+          end
+
+          def target_methods
+            Array(cop_config["Methods"]).map(&:to_s).then {|list| list.empty? ? DEFAULT_METHODS : list }
+          end
+
+        end
+      end
+    end
+  end
+end

data/linters/rubocop/cop/custom_cops/style/kwarg_priority_order.rb

@@ -0,0 +1,103 @@
+module RuboCop
+  module Cop
+    module CustomCops
+      module Style
+        ##============================================================##
+        ## Reorders the kwargs (implicit hash arg) of configured method
+        ## calls so that priority keys come first, in the order given
+        ## by `PriorityKeys`. Other kwargs keep their relative order.
+        ##
+        ## Targets the last positional arg only when it is a non-braced
+        ## hash (i.e. a real kwargs trailing hash). Explicit `{ ... }`
+        ## hash literals are left untouched.
+        ##
+        ## @example PriorityKeys: ["remote", "method"]
+        ## bad
+        ## link_to(t("x"), path, :class => "x", :remote => true)
+        ## link_to(t("x"), path, :class => "x", :method => :delete)
+        ##
+        ## good
+        ## link_to(t("x"), path, :remote => true, :class => "x")
+        ## link_to(t("x"), path, :method => :delete, :class => "x")
+        ##============================================================##
+        class KwargPriorityOrder < RuboCop::Cop::Base
+
+          extend AutoCorrector
+
+          MSG = "Move priority kwargs (%<keys>s) to the front of the call.".freeze
+
+          DEFAULT_METHODS = ["link_to"].freeze
+          DEFAULT_PRIORITY_KEYS = ["remote", "method"].freeze
+
+          def on_send(node)
+            return unless target_methods.include?(node.method_name.to_s)
+
+            hash_arg = node.last_argument
+            return unless hash_arg&.hash_type?
+            return if hash_arg.braces?
+
+            pairs = hash_arg.children
+            return if pairs.size < 2
+
+            priority_pairs, rest = partition_priority(pairs)
+            return if priority_pairs.empty?
+            return if pairs.first(priority_pairs.size) == priority_pairs
+
+            new_hash_src = (priority_pairs + rest).map {|p| p.loc.expression.source }.join(", ")
+            return if new_hash_src == hash_arg.loc.expression.source
+
+            add_offense(hash_arg, :message => format(MSG, :keys => priority_keys.join(", "))) do |corrector|
+              corrector.replace(hash_arg, new_hash_src)
+            end
+          end
+          alias on_csend on_send
+
+          private
+
+          ##============================================================##
+          ## Split pairs into priority (in PriorityKeys order) and rest
+          ## (original order preserved).
+          ##============================================================##
+          def partition_priority(pairs)
+            by_key = {}
+            rest   = []
+
+            pairs.each do |pair|
+              key_str = key_name(pair.children.first)
+              if key_str && priority_keys.include?(key_str)
+                by_key[key_str] = pair
+              else
+                rest << pair
+              end
+            end
+
+            priority = priority_keys.filter_map {|k| by_key[k] }
+            [priority, rest]
+          end
+
+          ##============================================================##
+          ## Extract the key name from a hash pair's key node. Handles
+          ## :sym, "string", and dynamic keys (returns nil for the
+          ## latter so they're treated as non-priority).
+          ##============================================================##
+          def key_name(key_node)
+            return nil unless key_node
+
+            case key_node.type
+            when :sym, :str then key_node.value.to_s
+            end
+          end
+
+          def priority_keys
+            Array(cop_config["PriorityKeys"]).map(&:to_s).then {|list| list.empty? ? DEFAULT_PRIORITY_KEYS : list }
+          end
+
+          def target_methods
+            Array(cop_config["Methods"]).map(&:to_s).then {|list| list.empty? ? DEFAULT_METHODS : list }
+          end
+
+        end
+      end
+    end
+  end
+end

data/linters/{rubocop-4.0.3.yml → rubocop-4.0.4.yml}

@@ -4,13 +4,15 @@ require:
 - rubocop/cop/custom_cops/style/comment_normalization
 - rubocop/cop/custom_cops/style/font_awesome_normalization
 - rubocop/cop/custom_cops/style/align_assignments
+- rubocop/cop/custom_cops/style/inline_multiline_calls
+- rubocop/cop/custom_cops/style/kwarg_priority_order
 AllCops:
   NewCops: enable
   EnabledByDefault: false
   UseCache: true
   SuggestExtensions: false
   ActiveSupportExtensionsEnabled: true
-  TargetRubyVersion: 4.0.3
+  TargetRubyVersion: 4.0.4
   ParserEngine: parser_prism
 Metrics:
   Enabled: false
@@ -198,5 +200,16 @@ CustomCops/Style/FontAwesomeNormalization:
   Enabled: true
 CustomCops/Style/AlignAssignments:
   Enabled: false
+CustomCops/Style/InlineMultilineCalls:
+  Enabled: true
+  Methods:
+  - link_to
+CustomCops/Style/KwargPriorityOrder:
+  Enabled: true
+  Methods:
+  - link_to
+  PriorityKeys:
+  - remote
+  - method
 Gemspec/RequireMFA:
   Enabled: false

data/linters/rubocop.yml

@@ -3,6 +3,8 @@ require:
   - rubocop/cop/custom_cops/style/comment_normalization
   - rubocop/cop/custom_cops/style/font_awesome_normalization
   - rubocop/cop/custom_cops/style/align_assignments
+  - rubocop/cop/custom_cops/style/inline_multiline_calls
+  - rubocop/cop/custom_cops/style/kwarg_priority_order
 
 # Enable all RuboCop methods and turn caching on for large files
 AllCops:
@@ -225,6 +227,19 @@ CustomCops/Style/FontAwesomeNormalization:
 CustomCops/Style/AlignAssignments:
   Enabled: false # Force alignment of consecutive assignments
 
+CustomCops/Style/InlineMultilineCalls:
+  Enabled: true # Always collapse multi-line calls of the listed methods onto a single line
+  Methods:
+    - link_to
+
+CustomCops/Style/KwargPriorityOrder:
+  Enabled: true # Reorder kwargs of the listed methods so priority keys come first
+  Methods:
+    - link_to
+  PriorityKeys:
+    - remote
+    - method
+
 #################### GEM ###########################
 Gemspec/RequireMFA:
   Enabled: false # Don't require MFA to push a gem

data/package.json

@@ -4,9 +4,9 @@
   "dependencies": {
     "@babel/parser":                    "^7.29.3",
     "@eslint/js":                       "^10.0.1",
-    "@typescript-eslint/eslint-plugin": "^8.59.2",
-    "@typescript-eslint/parser":        "^8.59.2",
-    "eslint":                           "^10.3.0",
+    "@typescript-eslint/eslint-plugin": "^8.59.3",
+    "@typescript-eslint/parser":        "^8.59.3",
+    "eslint":                           "^10.4.0",
     "eslint-plugin-align-assignments":  "^1.1.2",
     "eslint-plugin-align-import":       "^1.0.0",
     "eslint-plugin-erb":                "^2.1.1",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: immosquare-cleaner
 version: !ruby/object:Gem::Version
-  version: 0.1.109
+  version: 0.1.110
 platform: ruby
 authors:
 - immosquare
@@ -176,21 +176,24 @@ files:
 - lib/immosquare-cleaner/railtie.rb
 - lib/immosquare-cleaner/version.rb
 - lib/tasks/immosquare_cleaner.rake
-- linters/erb-lint-4.0.3.yml
+- linters/erb-lint-4.0.4.yml
 - linters/erb-lint.yml
+- linters/erb_lint/custom_align_consecutive_calls.rb
 - linters/erb_lint/custom_html_to_content_tag.rb
 - linters/erb_lint/custom_single_line_if_modifier.rb
 - linters/eslint-plugins/eslint10-compat.mjs
 - linters/eslint.config.mjs
-- linters/js-erb-lint-4.0.3.yml
+- linters/js-erb-lint-4.0.4.yml
 - linters/js-erb-lint.yml
 - linters/normalize-comments.mjs
 - linters/prettier.yml
-- linters/rubocop-4.0.3.yml
+- linters/rubocop-4.0.4.yml
 - linters/rubocop.yml
 - linters/rubocop/cop/custom_cops/style/align_assignments.rb
 - linters/rubocop/cop/custom_cops/style/comment_normalization.rb
 - linters/rubocop/cop/custom_cops/style/font_awesome_normalization.rb
+- linters/rubocop/cop/custom_cops/style/inline_multiline_calls.rb
+- linters/rubocop/cop/custom_cops/style/kwarg_priority_order.rb
 - linters/rubocop/cop/style/method_call_with_args_parentheses_override.rb
 - package.json
 homepage: https://github.com/immosquare/Immosquare-cleaner