immosquare-cleaner 1.2.4 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f62bc1ef91591ce4508aab72115cb5acfe1f5e67cf2ca33aff2c4adaf50666c0
-  data.tar.gz: 63a788a487d902e7ca031dbe0df8586f58f44894534a3bcc2262f04a4b76b9e6
+  metadata.gz: 06af1c0a31ef811c54efdd4d3f845317c81f02db83112947da04390fd5c69e6c
+  data.tar.gz: d3c8617e585affa872699e5378ac6c90818d1fe0d6a3fe6f1bbcf62d727c7451
 SHA512:
-  metadata.gz: 8574bb58dc4ffc54d776a0345cf2028f7de7640ff5314ac0701c5e79a968111a7cd2809207c235c2b3b74f5fe438bf6325c6f8a3d77d4e0ee217525b7e1cffc6
-  data.tar.gz: a00acfbfdf8e625c2c43abc74fa2a2d12e931dc710d1c54809c5dbd9c723f74ebf8001a88e8d62a6d8a856f65e331bb8d7ee9709b8cdadc9a496f1bf8e6e4891
+  metadata.gz: 354c8df2a5913b65613909c4d000161aafb2fcb7ab66b09e1dd909f0df6d6b74c982f44a65c7f10bba1525ceb1a42203f1aa8df37b70eaf2a8bc327efd7b4808
+  data.tar.gz: b0df5b076458f940f997f92bd76643fa472d850c480f88cc9508eccf1fb7ab0cfd8b99429e80ce0d18c9bc85976c52423ae955e48983cfc7d58725d82fc5f641

data/lib/immosquare-cleaner/version.rb

@@ -1,3 +1,3 @@
 module ImmosquareCleaner
-  VERSION = "1.2.4".freeze
+  VERSION = "1.3.1".freeze
 end

data/linters/eslint-plugins/align-assignments.mjs

@@ -38,8 +38,6 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //============================================================//
-const hasRequire   = /require\(/
-const spaceMatcher = /(\s*)((?:\|\||&&|\?\?|\+|-|\*|\/|%|&|\^|\||<<|>>|\*\*|>>>)?=)/
 
 const assignmentOperators = ["=", "+=", "-=", "*=", "/=", "%=", "&=", "^=", "|=", "<<=", ">>=", "**=", ">>>=", "||=", "&&=", "??="]
 
@@ -100,35 +98,31 @@ const rule = {
       previousNode = groupNode
     }
 
-    const getPrefix = (node) => {
-      const nodeBefore = isAssignmentExpression(node) ? node.left : node.declarations.find((dcl) => dcl.type === "VariableDeclarator").id
-      return nodeBefore.loc.end.column - nodeBefore.loc.start.column
+    const assignmentTokenOf = (node) => {
+      const left = isAssignmentExpression(node) ? node.left : node.declarations[0]?.id
+      if (!left) return null
+      const token = sourceCode.getTokenAfter(left)
+      return token && assignmentOperators.includes(token.value) ? token : null
     }
 
-    const findAssigment = (node) => {
-      const prefix = getPrefix(node)
-      const source = sourceCode.getText(node)
-      const match  = source.slice(prefix).match(spaceMatcher)
-      return match ? match.index + prefix + match[2].length : null
+    const findAssignment = (node) => {
+      const token = assignmentTokenOf(node)
+      return token ? token.loc.end.column - sourceCode.getFirstToken(node).loc.start.column - 1 : null
     }
 
     const assignmentOnFirstLine = (node) => {
-      if (isAssignmentExpression(node)) return node.left.loc.start.line === node.right.loc.start.line
-
-      const source = sourceCode.getText(node)
-      const lines  = source.split("\n")
-      return lines[0].includes("=")
+      const token = assignmentTokenOf(node)
+      return token && !isMultiline(sourceCode.getFirstToken(node), token)
     }
 
     const areAligned = (maxPos, nodes) => nodes
       .filter(assignmentOnFirstLine)
-      .map((node) => sourceCode.getText(node))
-      .every((source) => source.charAt(maxPos) === "=")
+      .every((node) => findAssignment(node) === maxPos)
 
     const getMaxPos = (nodes) => nodes
       .filter(assignmentOnFirstLine)
-      .map(findAssigment)
-      .reduce((last, current) => Math.max(last, current), [])
+      .map(findAssignment)
+      .reduce((last, current) => Math.max(last, current), 0)
 
     const check = (group) => {
       const maxPos = getMaxPos(group)
@@ -141,27 +135,21 @@ const rule = {
           end:   getLast(group).loc.end
         },
         message: "This group of assignments is not aligned",
-        fix:     (fixer) => group.map((node) => {
-          const tokens          = sourceCode.getTokens(node)
-          const firstToken      = tokens[0]
-          const assignmentToken = tokens.find((token) => assignmentOperators.includes(token.value))
-          const line            = sourceCode.getText(node)
-          const lineIsAligned   = line.charAt(maxPos) === "="
-
-          if (lineIsAligned || !assignmentToken || isMultiline(firstToken, assignmentToken)) return fixer.replaceText(node, line)
+        fix:     (fixer) => group.flatMap((node) => {
+          const firstToken      = sourceCode.getFirstToken(node)
+          const assignmentToken = assignmentTokenOf(node)
+          if (!assignmentToken || isMultiline(firstToken, assignmentToken) || findAssignment(node) === maxPos) return []
+          const previousToken = sourceCode.getTokenBefore(assignmentToken)
+          const gap           = [previousToken.range[1], assignmentToken.range[0]]
+          if (sourceCode.commentsExistBetween(previousToken, assignmentToken)) return []
 
           //============================================================//
-          // Source line may include spaces, we need to accomodate
-          // for that.
+          // Only the spacing before the operator belongs to this rule. Replacing a declaration
+          // can cut a template processor's placeholder at an AST boundary inside that marker.
           //============================================================//
-          const spacePrefix    = firstToken.loc.start.column
-          const startDelimiter = assignmentToken.loc.start.column - spacePrefix
-          const endDelimiter   = assignmentToken.loc.end.column - spacePrefix
-          const start          = line.slice(0, startDelimiter).replace(/\s+$/m, "")
-          const ending         = line.slice(endDelimiter).replace(/^\s+/m, "")
-          const spacesRequired = maxPos - start.length - assignmentToken.value.length + 1
-          const spaces         = " ".repeat(spacesRequired)
-          return fixer.replaceText(node, `${start}${spaces}${assignmentToken.value} ${ending}`)
+          const prefixWidth    = previousToken.loc.end.column - firstToken.loc.start.column
+          const spacesRequired = maxPos - prefixWidth - assignmentToken.value.length + 1
+          return [fixer.replaceTextRange(gap, " ".repeat(spacesRequired))]
         })
       })
     }
@@ -169,7 +157,7 @@ const rule = {
     return {
       VariableDeclaration: (node) => {
         const source = sourceCode.getText(node)
-        if (requiresOnly && !hasRequire.test(source)) return
+        if (requiresOnly && !source.includes("require(")) return
 
         addNode(node, node)
       },

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

@@ -0,0 +1,308 @@
+module RuboCop
+  module Cop
+    module CustomCops
+      module Style
+        ##============================================================##
+        ## This cop aligns the blocks of Rails routes in
+        ## `config/routes.rb` and `config/routes/*.rb`: inside a
+        ## block of consecutive route lines, the verb, the path,
+        ## the target and every option (`:as`, `:via`,
+        ## `:constraints`...) start in the same column. Options are
+        ## aligned by name: a route without `:via` leaves that
+        ## column empty and its `:as` lands under the `:as` of its
+        ## neighbours.
+        ##
+        ## Only whitespace changes: paths, targets, options and
+        ## comments come out identical, in the same order. The
+        ## corrections only rewrite the gaps between tokens, never
+        ## a token itself, so they cannot clash with the
+        ## corrections of other cops.
+        ##
+        ## The option columns follow an order compatible with the
+        ## order of every route in the block (`:via` before `:as`
+        ## when a route carries them in that order, even when a
+        ## neighbour without `:via` meets `:as` first). When two
+        ## routes impose opposite orders, the block is left alone:
+        ## no alignment can satisfy both without reordering.
+        ##
+        ## Recognized shapes: `get "a" => "c#a", :as => ...`, the
+        ## same call with parentheses (`match("a" => "c#a", ...)`),
+        ## and the shape without a positional target
+        ## (`match "404", :to => ...`).
+        ##
+        ## @example
+        ## bad
+        ## get "users" => "users#index", :as => :users
+        ## match "users/:id" => "users#update", :via => [:patch, :put], :as => :user
+        ##
+        ## good
+        ## get   "users"     => "users#index",                            :as => :users
+        ## match "users/:id" => "users#update", :via => [:patch, :put], :as => :user
+        ##============================================================##
+        class AlignRoutes < RuboCop::Cop::Base
+
+          extend AutoCorrector
+
+          MSG = "Align the columns of consecutive routes.".freeze
+
+          VERBS = [:get, :post, :put, :patch, :delete, :match].freeze
+
+          ##============================================================##
+          ## Only the files Rails loads its routes from. A `get`
+          ## call anywhere else is not a route.
+          ##============================================================##
+          ROUTES_FILE = %r{config/routes(?:/[^/]+\.rb|\.rb)\z}
+
+          def on_new_investigation
+            @routes = []
+          end
+
+          def on_send(node)
+            return unless routes_file?
+            return unless VERBS.include?(node.method_name)
+            return unless node.receiver.nil?
+
+            route = parse_route(node)
+            @routes << route if route
+          end
+
+          def on_investigation_end
+            groups.each {|group| check_group(group) }
+          end
+
+          private
+
+          def routes_file?
+            path = processed_source.file_path
+            path.nil? || ROUTES_FILE.match?(path.to_s)
+          end
+
+          ##============================================================##
+          ## A route line cut into segments: verb, path, target when
+          ## there is one, then its options under their name (`:as`,
+          ## `:via`...), in the order the line carries them. Every
+          ## segment keeps its source range, so the corrections can
+          ## address the gaps between segments. Nil when the call
+          ## is not a single-line route starting its line.
+          ##============================================================##
+          def parse_route(node)
+            range = node.source_range
+            return if range.first_line != range.last_line
+
+            line = processed_source.lines[range.first_line - 1]
+            return if line.nil? || !line.strip.start_with?(node.source.strip)
+
+            first = node.arguments.first
+            return if first.nil?
+
+            if first.hash_type?
+              return if first.braces? || first.pairs.empty?
+
+              pair = first.pairs.first
+              return unless pair.key.str_type?
+
+              target_pair = pair
+              path_range  = pair.key.source_range
+              rest_pairs  = first.pairs.drop(1)
+            elsif first.str_type?
+              target_pair = nil
+              path_range  = first.source_range
+              rest_pairs  = []
+              if node.arguments.size > 1
+                hash = node.arguments[1]
+                return unless hash.hash_type? && !hash.braces?
+
+                rest_pairs = hash.pairs
+              end
+            else
+              return
+            end
+
+            segments = [{:kind => :path, :range => path_range}]
+            segments << {:kind => :target, :range => target_pair.value.source_range, :pair => target_pair} if target_pair
+            rest_pairs.each_with_index do |pair, index|
+              key = pair.key.sym_type? ? ":#{pair.key.value}" : "__raw#{index}"
+              segments << {:kind => :option, :key => key, :range => pair.source_range}
+            end
+
+            {:node => node, :line => range.first_line, :segments => segments}
+          end
+
+          ##============================================================##
+          ## Blocks of routes on adjacent lines. Any other line
+          ## (comment, `scope`, `end`, a route this cop does not
+          ## recognize...) puts at least one line between two
+          ## routes and so closes the block. Two routes sharing a
+          ## line are dropped: aligning them would rewrite the
+          ## same line twice.
+          ##============================================================##
+          def groups
+            sorted = @routes.sort_by {|route| route[:node].source_range.begin_pos }
+            counts = sorted.map {|route| route[:line] }.tally
+            sorted = sorted.reject {|route| counts[route[:line]] > 1 }
+
+            sorted.chunk_while {|a, b| b[:line] == a[:line] + 1 }.to_a
+          end
+
+          ##============================================================##
+          ## Check one block: compute the column of every segment,
+          ## then flag each route whose gaps differ, correcting
+          ## gap by gap.
+          ##============================================================##
+          def check_group(group)
+            return if group.size < 2
+
+            keys = ordered_keys(group)
+            return if keys.nil?
+
+            place_segments(group, keys)
+
+            group.each do |route|
+              corrections = corrections_for(route)
+              next if corrections.empty?
+
+              add_offense(route[:node], :message => MSG) do |corrector|
+                corrections.each {|range, text| corrector.replace(range, text) }
+              end
+            end
+          end
+
+          ##============================================================##
+          ## The column of every segment of every route of the
+          ## block: first `=>` in one column, then one column per
+          ## option name, in the order computed for the block. The
+          ## comma stays glued to the value before it, the spaces
+          ## follow it.
+          ##============================================================##
+          def place_segments(group, keys)
+            verb_width = group.map {|route| route[:node].method_name.length }.max
+            path_width = group.map {|route| segment(route, :path)[:range].size }.max
+
+            group.each do |route|
+              node       = route[:node]
+              path_start = node.source_range.column + verb_width + 1
+              segment(route, :path)[:start] = path_start
+
+              target = segment(route, :target)
+              head_end =
+                if target
+                  target[:start] = path_start + path_width + 4
+                  target[:start] + target[:range].size
+                else
+                  path_start + path_width
+                end
+              route[:head_end] = head_end
+            end
+
+            starts = {}
+            column = group.map {|route| route[:head_end] }.max + 2
+            keys.each do |key|
+              starts[key] = column
+              followers = keys.drop(keys.index(key) + 1)
+              ends      = group.filter_map do |route|
+                option = route[:segments].find {|seg| seg[:key] == key }
+                column + option[:range].size if option && (option_keys(route) & followers).any?
+              end
+              column = ends.max + 2 if ends.any?
+            end
+
+            group.each do |route|
+              route[:segments].each do |seg|
+                seg[:start] = starts[seg[:key]] if seg[:kind] == :option
+              end
+            end
+          end
+
+          ##============================================================##
+          ## The gaps of one route that do not match the computed
+          ## columns, as [range, expected text] pairs. Ranges only
+          ## ever span whitespace and the commas separating the
+          ## segments, never a segment itself.
+          ##============================================================##
+          def corrections_for(route)
+            node        = route[:node]
+            selector    = node.loc.selector
+            path        = segment(route, :path)
+            corrections = []
+
+            if node.loc.begin
+              replace_gap(corrections, selector.end_pos, node.loc.begin.begin_pos, "")
+              replace_gap(corrections, node.loc.begin.end_pos, path[:range].begin_pos, "")
+            else
+              replace_gap(corrections, selector.end_pos, path[:range].begin_pos,
+                " " * (path[:start] - selector.column - selector.size))
+            end
+
+            previous = path
+            if (target = segment(route, :target))
+              operator = target[:pair].loc.operator
+              ##============================================================##
+              ## The `=>` sits 3 columns before the target (its 2
+              ## chars plus the space after it); the path ends, in
+              ## the aligned line, at its start plus its length.
+              ##============================================================##
+              replace_gap(corrections, path[:range].end_pos, operator.begin_pos,
+                " " * ((target[:start] - 3) - (path[:start] + path[:range].size)))
+              replace_gap(corrections, operator.end_pos, target[:range].begin_pos, " ")
+              previous = target
+            end
+
+            route[:segments].select {|seg| seg[:kind] == :option }.each do |option|
+              prev_end = previous[:start] + previous[:range].size
+              replace_gap(corrections, previous[:range].end_pos, option[:range].begin_pos,
+                ",#{" " * (option[:start] - prev_end - 1)}")
+              previous = option
+            end
+            corrections
+          end
+
+          ##============================================================##
+          ## Record a gap correction when the current text differs.
+          ##============================================================##
+          def replace_gap(corrections, begin_pos, end_pos, expected)
+            range = Parser::Source::Range.new(processed_source.buffer, begin_pos, end_pos)
+            return if range.source == expected
+
+            corrections << [range, expected]
+          end
+
+          def segment(route, kind)
+            route[:segments].find {|seg| seg[:kind] == kind }
+          end
+
+          def option_keys(route)
+            route[:segments].filter_map {|seg| seg[:key] }
+          end
+
+          ##============================================================##
+          ## The order of the option columns: the first one
+          ## compatible with the order every route gives its
+          ## options, keeping first-encounter order on ties. Nil
+          ## when two routes impose opposite orders.
+          ##============================================================##
+          def ordered_keys(group)
+            keys         = group.flat_map {|route| option_keys(route) }.uniq
+            predecessors = Hash.new {|hash, key| hash[key] = [] }
+            group.each do |route|
+              option_keys(route).each_cons(2) do |before, after|
+                predecessors[after] << before unless predecessors[after].include?(before)
+              end
+            end
+
+            sorted    = []
+            remaining = keys.dup
+            while remaining.any?
+              ready = remaining.select {|key| (predecessors[key] - sorted).empty? }
+              return if ready.empty?
+
+              sorted << ready.first
+              remaining.delete(ready.first)
+            end
+            sorted
+          end
+
+        end
+      end
+    end
+  end
+end

data/linters/rubocop.yml

@@ -5,6 +5,7 @@ require:
   - rubocop/cop/custom_cops/style/align_assignments
   - rubocop/cop/custom_cops/style/inline_multiline_calls
   - rubocop/cop/custom_cops/style/kwarg_priority_order
+  - rubocop/cop/custom_cops/style/align_routes
 
 # Enable all RuboCop methods and turn caching on for large files
 AllCops:
@@ -261,6 +262,9 @@ CustomCops/Style/KwargPriorityOrder:
     - remote
     - method
 
+CustomCops/Style/AlignRoutes:
+  Enabled: true # Align the columns of consecutive routes in config/routes.rb and config/routes/*.rb
+
 #################### GEM ###########################
 Gemspec/RequireMFA:
   Enabled: false # Don't require MFA to push a gem

data/package.json

@@ -7,10 +7,10 @@
   ],
   "private":      true,
   "dependencies": {
-    "@babel/parser":                    "^8.0.7",
+    "@babel/parser":                    "^8.0.8",
     "@eslint/js":                       "^10.0.1",
-    "@typescript-eslint/eslint-plugin": "^8.71.2",
-    "@typescript-eslint/parser":        "^8.71.2",
+    "@typescript-eslint/eslint-plugin": "^8.72.0",
+    "@typescript-eslint/parser":        "^8.72.0",
     "@typescript/native":               "npm:typescript@^7.0.2",
     "eslint":                           "^10.13.0",
     "eslint-plugin-align-import":       "^1.0.0",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: immosquare-cleaner
 version: !ruby/object:Gem::Version
-  version: 1.2.4
+  version: 1.3.1
 platform: ruby
 authors:
 - immosquare
@@ -195,6 +195,7 @@ files:
 - linters/prettier.yml
 - linters/rubocop.yml
 - linters/rubocop/cop/custom_cops/style/align_assignments.rb
+- linters/rubocop/cop/custom_cops/style/align_routes.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