immosquare-cleaner 0.1.71 → 0.1.72

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8aa35cadcbf70139cbb0af0a069f2a0fe2f0f2eebf7828a2a4f55cd561d244a0
-  data.tar.gz: 66bf6deadd22989fa4c3b77d3479760e68e0c8a17e2b3d102567686d2cc38e49
+  metadata.gz: 83217701b85a19b792303464dac395f9762fbc05bf5a249a7be5de644b6a4f78
+  data.tar.gz: e828cb27a783a4fd8ead1a3aa538419802799ce3a841dcf84b708e3bfc215ff8
 SHA512:
-  metadata.gz: e5f8431e8415eb8e90fe3373d7c3b2ac26c0753225b52ba4ac22b40323eb2943f7159520f672572c8f74d930f28ece4fef34837c8cefbd0431d801eede1f4e9c
-  data.tar.gz: 279c5b7297e477b301904215ce3db41d6c610b7fbd07d0a213f3490be33abb535a3fb6b8b4a865736b8a6bc582861e255c2adae6868738fbf6001e604e94dcdc
+  metadata.gz: 71aa540fd2b292d764a6b66103f5990e527c8f2e96ed52c9adaf3e9df18d8ff4ac737e974582664a130b86c75e811d6a0dfb04e84c618fa6c45af8b1251c0e10
+  data.tar.gz: 3d2a6afa00b20a5295423969e9d1fc5dc7726e5624298c2e1b9d846c58e66d7ec97774c1f67cf5d875096cbb8af4b78f06db31f1d71844d9675b4f32ac1d3265

data/lib/immosquare-cleaner/version.rb

@@ -1,3 +1,3 @@
 module ImmosquareCleaner
-  VERSION = "0.1.71".freeze
+  VERSION = "0.1.72".freeze
 end

data/linters/erb-lint-3.2.6.yml

@@ -0,0 +1,14 @@
+---
+EnableDefaultLinters: true
+linters:
+  NoJavascriptTagHelper:
+    enabled: false
+  SpaceInHtmlTag:
+    enabled: false
+  Rubocop:
+    enabled: true
+    rubocop_config:
+      inherit_from:
+      - linters/rubocop-3.2.6.yml
+      Layout/TrailingWhitespace:
+        Enabled: false

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

@@ -20,104 +20,148 @@ module RuboCop
 
           extend AutoCorrector
 
-          MSG              = "Align the assignment operators of consecutive assignments.".freeze
-          ASSIGNMENT_TYPES = [:lvasgn, :casgn, :ivasgn, :cvasgn, :gvasgn].freeze
+          MSG = "Align the assignment operators of consecutive assignments.".freeze
 
           def on_new_investigation
-            @assignment_groups = find_assignment_groups
+            @assignment_groups    = []
+            @current_group        = []
+            @last_assignment_line = nil
           end
 
-          ASSIGNMENT_TYPES.each do |type|
-            define_method(:"on_#{type}") do |node|
-              check_alignment(node)
-            end
+          def on_lvasgn(node)
+            check_assignment(node)
           end
 
-          private
+          def on_ivasgn(node)
+            check_assignment(node)
+          end
 
-          def find_assignment_groups
-            assignments_by_line = {}
+          def on_cvasgn(node)
+            check_assignment(node)
+          end
 
-            processed_source.ast.each_node do |node|
-              next unless ASSIGNMENT_TYPES.include?(node.type)
+          def on_gvasgn(node)
+            check_assignment(node)
+          end
 
-              assignments_by_line[node.source_range.line] = node
-            end
+          def on_casgn(node)
+            check_assignment(node)
+          end
 
-            group_consecutive_assignments(assignments_by_line)
+          def on_masgn(node)
+            check_assignment(node)
           end
 
-          def group_consecutive_assignments(assignments_by_line)
-            groups        = []
-            current_group = []
-            previous_line = nil
+          ##============================================================##
+          ## Pour les assignments d'index (listing["key"] = ...)
+          ##============================================================##
+          def on_send(node)
+            return unless node.method_name == :[]= && node.arguments.length == 2
 
-            assignments_by_line.keys.sort.each do |line|
-              if previous_line&.+(1) == line
-                current_group << assignments_by_line[previous_line] if current_group.empty?
-                current_group << assignments_by_line[line]
-              else
-                groups << current_group if current_group.size > 1
-                current_group = [assignments_by_line[line]]
-              end
-              previous_line = line
-            end
+            check_assignment(node)
+          end
 
-            groups << current_group if current_group.size > 1
-            groups
+          def on_investigation_end
+            finalize_current_group
+            process_groups
           end
 
-          def check_alignment(node)
-            group = @assignment_groups.find {|g| g.include?(node) }
-            return unless group
+          private
 
-            target_column  = calculate_target_column(group)
-            current_column = assignment_operator_column(node)
+          ##============================================================##
+          ## Vérifier que c'est bien un assignment simple (=) et pas (>=, <=, =>, etc.)
+          ##============================================================##
+          def check_assignment(node)
+            return unless assignment_operator?(node)
 
-            return if current_column == target_column
+            add_to_group(node)
+          end
 
-            spaces_needed = target_column - current_column
-            return if spaces_needed <= 0
+          ##============================================================##
+          ## Vérifier si l'opérateur est un simple "=" (pas >=, <=, =>, etc.)
+          ##============================================================##
+          def assignment_operator?(node)
+            ##============================================================##
+            ## Pour les send nodes (index assignment)
+            ##============================================================##
+            return true if node.respond_to?(:method_name) && node.method_name == :[]=
+
+            ##============================================================##
+            ## Pour les assignments classiques
+            ##============================================================##
+            source = node.source.strip
+            return false unless source.include?("=")
 
-            add_offense(node.source_range, :message => MSG) do |corrector|
-              corrector.insert_before(assignment_operator_range(node), " " * spaces_needed)
-            end
-          end
+            equals_pos = source.index("=")
+            return false if equals_pos > 0 && [">", "<"].include?(source[equals_pos - 1])
+            return false if equals_pos < source.length - 1 && source[equals_pos + 1] == ">"
 
-          def calculate_target_column(group)
-            base_column    = group.first.source_range.column
-            max_var_length = group.map {|node| variable_name_length(node) }.max
-            base_column + max_var_length + 1
+            true
           end
 
-          def variable_name_length(node)
-            case node.type
-            when :lvasgn, :ivasgn, :cvasgn, :gvasgn
-              node.children[0].to_s.length
-            when :casgn
-              if node.children[0]
-                "#{node.children[0].source}::#{node.children[1]}".length
-              else
-                node.children[1].to_s.length
-              end
+          ##============================================================##
+          ## Ajouter un assignment au groupe courant ou créer un nouveau groupe
+          ##============================================================##
+          def add_to_group(node)
+            current_line = node.location.line
+            if @current_group.empty?
+              @current_group = [node]
+            elsif consecutive_lines?(@last_assignment_line, current_line)
+              @current_group << node
+            else
+              finalize_current_group
+              @current_group = [node]
             end
+            @last_assignment_line = current_line
           end
 
-          def assignment_operator_column(node)
-            assignment_operator_range(node).column
+          ##============================================================##
+          ## Retourne true si les deux lignes sont consécutives (pas de ligne vide entre elles)
+          ##============================================================##
+          def consecutive_lines?(line1, line2)
+            gap = line2 - line1 - 1
+            gap == 0
           end
 
-          def assignment_operator_range(node)
-            source     = node.source
-            equals_pos = source.index("=")
-            return node.source_range if equals_pos.nil?
+          ##============================================================##
+          ## Finaliser le groupe courant s'il contient plus d'un assignment
+          ##============================================================##
+          def finalize_current_group
+            @assignment_groups << @current_group.dup if @current_group.length > 1
+            @current_group        = []
+            @last_assignment_line = nil
+          end
 
-            start_pos = node.source_range.begin_pos + equals_pos
-            range(processed_source.buffer, start_pos, start_pos + 1)
+          ##============================================================##
+          ## Traiter tous les groupes d'assignments pour vérifier l'alignement
+          ##============================================================##
+          def process_groups
+            @assignment_groups.each do |group|
+              check_and_correct_alignment(group)
+            end
           end
 
-          def range(buffer, start_pos, end_pos)
-            Parser::Source::Range.new(buffer, start_pos, end_pos)
+          ##============================================================##
+          ## Vérifier l'alignement d'un groupe et corriger si nécessaire
+          ##============================================================##
+          def check_and_correct_alignment(group)
+            lefts         = group.map {|node| node.source.split("=")[0].to_s.strip.gsub(/\s+/, "").gsub(",", ", ") }
+            required_size = lefts.map(&:length).max + 1
+
+            group.each.with_index do |node, index|
+              current_source = node.source
+              new_left       = lefts[index]
+              new_left += " " * (required_size - new_left.length)
+              split           = current_source.split("=")
+              split[0]        = new_left
+              expected_source = split.join("=")
+
+              if current_source != expected_source
+                add_offense(node, :message => MSG) do |corrector|
+                  corrector.replace(node, expected_source)
+                end
+              end
+            end
           end
 
         end

data/linters/rubocop-3.4.1.yml

@@ -98,5 +98,9 @@ CustomCops/Style/CommentNormalization:
   Enabled: true
 CustomCops/Style/FontAwesomeNormalization:
   Enabled: true
+CustomCops/Style/AlignAssignments:
+  Enabled: true
+Layout/SpaceAroundOperators:
+  Enabled: false
 Gemspec/RequireMFA:
   Enabled: false

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: immosquare-cleaner
 version: !ruby/object:Gem::Version
-  version: 0.1.71
+  version: 0.1.72
 platform: ruby
 authors:
 - immosquare
@@ -146,6 +146,7 @@ files:
 - lib/immosquare-cleaner/railtie.rb
 - lib/immosquare-cleaner/version.rb
 - lib/tasks/immosquare_cleaner.rake
+- linters/erb-lint-3.2.6.yml
 - linters/erb-lint-3.4.1.yml
 - linters/erb-lint.yml
 - linters/eslint.config.mjs