immosquare-cleaner 0.1.104 → 0.1.105

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe176ca59627b1693859214bf23eb81860a761401abc4d76ed3412d70b586892
-  data.tar.gz: c7663e4b3eacacbf4e241bd2896ae714f388805c7c395b02ffa4528ba12f0696
+  metadata.gz: 73fae62cc9335a00c4ca43998545d10a0ca0ae7541c5aaa1d2721e03834f26ea
+  data.tar.gz: 122bd307b070b742dd7c2e1739503a5437d6feeaa0813bbf8c58eeeca315d7b5
 SHA512:
-  metadata.gz: b019065b995fbe5ac11216c458d467aa4ec0c65924afe26d29111953197b99992e1473f88eecfd5813db12211e9d0bfa6e9e6ab78df394a9c185300006e76a7e
-  data.tar.gz: eaad6f72c1e46688e230a52e2dcf5e040b3af9014f030a92742d0d227e13b25c02e3e57f3e334152c6fdce396f291baa91caf75a49400a72c88f22a5efc7aafa
+  metadata.gz: bff5c8d3ef37a3e24b05c262d23a119bd6bae616e84ce3625fd40921e7f5becb69520b7a4c1992e38e2de6ffde20778207c3f7c7c9e2ab846a6a69c3bfb01b8c
+  data.tar.gz: 9695564168f28471e05478bf1c8abb5c291704c1f7f60cc714defe46266791537b2d0cce549dcfcb93ea912f8e32d5ded3eb74d664107d6016cbe1a78cefb4eb

data/lib/immosquare-cleaner/version.rb

@@ -1,3 +1,3 @@
 module ImmosquareCleaner
-  VERSION = "0.1.104".freeze
+  VERSION = "0.1.105".freeze
 end

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

@@ -8,136 +8,144 @@ module RuboCop
 
           MSG              = "Comments should be normalized with the standard format if start with ##".freeze
           BORDER_LINE      = "###{"=" * 60}##".freeze
+          INSIDE_SEPARATOR = "## ---------".freeze
+          BLANK_LINE       = "##".freeze
+          EMPTY_BODY       = "## ...".freeze
           SPACE            = " ".freeze
-          INSIDE_SEPARATOR = "###{SPACE}---------".freeze
+
+          ##============================================================##
+          ## Patterns détectés ligne par ligne dans un bloc :
+          ## - STRUCTURED_LINE : puces, citations, listes numérotées
+          ## - INDENTED_LINE   : indentation explicite (3+ espaces après ##)
+          ## - RAW_LINE        : ligne préservée telle quelle (## | ...)
+          ## - FENCE_LINE      : ouverture/fermeture d'un bloc de code (## ```)
+          ## - USER_SEPARATOR  : séparateur explicite (## ---, ===, ___)
+          ##============================================================##
+          STRUCTURED_LINE = /\A##\s+([-*+>]|\d+[.)])\s/
+          INDENTED_LINE   = /\A##\s{3,}\S/
+          RAW_LINE        = /\A##\s*\|/
+          FENCE_LINE      = /\A##\s*```/
+          USER_SEPARATOR  = /\A##\s*[-=_]{3,}\s*\z/
 
           def on_new_investigation
             return if @investigation_in_progress
 
             @investigation_in_progress = true
 
-            comment_blocks = find_comment_blocks(processed_source.comments)
-
-            comment_blocks.each do |block|
-              correct_block = normalize_comment_block(block)
-
-
-              if needs_correction?(block, correct_block)
-                ##============================================================##
-                ## Pour désactiver les cops autres cops qui pourraient être
-                ## déclenchés par les commentaires
-                ##============================================================##
-                buffer    = processed_source.buffer
-                start_pos = buffer.line_range(block.first.location.line).begin_pos
-                end_pos   = buffer.line_range(block.last.location.line).end_pos
-                range     = Parser::Source::Range.new(buffer, start_pos, end_pos)
-                ignore_node(range)
-
-                ##============================================================##
-                ## Puis, on ajoute l'offense
-                ##============================================================##
-                add_offense(block.first) do |corrector|
-                  corrector.replace(range, normalize_comment_block(block))
-                end
+            find_comment_blocks(processed_source.comments).each do |block|
+              normalized = normalize_comment_block(block)
+              next if !needs_correction?(block, normalized)
+
+              range = block_range(block)
+              ignore_node(range)
+              add_offense(block.first) do |corrector|
+                corrector.replace(range, normalized)
               end
             end
           end
 
-
-
           private
 
-
           ##============================================================##
-          ## On ne veut traiter que les commentaires ## qui ne sont pas
-          ## des commentaires de fin de ligne ruby
+          ## On ne traite que les commentaires qui commencent en début de
+          ## ligne par "##" (pas les commentaires de fin de ligne ruby).
+          ## Les blocs sont des suites de lignes contiguës.
           ##============================================================##
           def find_comment_blocks(comments)
-            blocks              = []
-            current_block       = []
-            standalone_comments = comments.select do |comment|
-              line = processed_source.lines[comment.location.line - 1]
-              line.strip.start_with?("##")
+            standalone = comments.select do |comment|
+              processed_source.lines[comment.location.line - 1].lstrip.start_with?("##")
             end
 
-            standalone_comments.each_with_index do |comment, index|
-              next_comment         = standalone_comments[index + 1]
-              next_line_contiguous = next_comment && next_comment.location.line == comment.location.line + 1
+            standalone.slice_when {|prev, nxt| nxt.location.line != prev.location.line + 1 }.to_a
+          end
 
-              if next_line_contiguous
-                current_block << comment
-              else
-                current_block << comment
-                blocks << current_block.dup if !current_block.empty?
-                current_block.clear
-              end
-            end
-            blocks
+          def block_range(block)
+            buffer    = processed_source.buffer
+            start_pos = buffer.line_range(block.first.location.line).begin_pos
+            end_pos   = buffer.line_range(block.last.location.line).end_pos
+            Parser::Source::Range.new(buffer, start_pos, end_pos)
           end
 
           ##============================================================##
-          ## Pour formater correctement le block de commentaires
+          ## Encadre le body avec BORDER_LINE et indente toutes les lignes
+          ## sur la colonne du bloc original. Le range remplacé démarre en
+          ## colonne 0, donc la première ligne doit aussi recevoir le pad.
           ##============================================================##
           def normalize_comment_block(block)
-            indent_level               = indent_level(block.first)
-            first_line_with_text_found = false
+            body = build_body(block)
+            body = [EMPTY_BODY] if body.empty?
 
-            body = block.map do |comment|
-              text                       = comment.text.to_s.strip
-              alphanumercic              = text.match?(/[\p{L}0-9]/)
-              first_line_with_text_found = true if alphanumercic && !first_line_with_text_found
-              if text == BORDER_LINE
-                nil
-              elsif alphanumercic
-                cleaned_line(text)
-              elsif !first_line_with_text_found
-                nil
-              else
-                text == "##" ? "##" : INSIDE_SEPARATOR
-              end
-            end.compact
+            pad = SPACE * indent_level(block.first)
+            [BORDER_LINE, *body, BORDER_LINE].map {|line| "#{pad}#{line}" }.join("\n")
+          end
 
+          ##============================================================##
+          ## Transforme chaque ligne du bloc :
+          ## - bordures existantes        → ignorées
+          ## - lignes vides en tête       → ignorées (avant tout contenu)
+          ## - fenced code blocks (## ```)→ contenu préservé tel quel
+          ## - lignes "raw" (## | ...)    → préservées
+          ## - listes / indentation 3+    → préservées
+          ## - séparateurs (## ---)       → INSIDE_SEPARATOR
+          ## - lignes "##" seules         → conservées comme ligne vide
+          ## - texte normal               → nettoyé via #cleaned_line
+          ##============================================================##
+          def build_body(block)
+            body         = []
+            in_code      = false
+            content_seen = false
 
-            body = ["## ..."] if body.empty?
+            block.each do |comment|
+              text = comment.text.to_s.rstrip
 
-            ##============================================================##
-            ## Le block va être remis à la place du block original sur
-            ## la colone du block original. Donc la première ligne du block
-            ## ne doit pas être indentée manuellement. Par contre les autres
-            ## lignes doivent être indentées sur la même colonne que la première
-            ##============================================================##
-            [BORDER_LINE, body, BORDER_LINE].flatten.map.with_index {|line, index| index == 0 ? line : "#{SPACE * indent_level}#{line}" }.join("\n")
-          end
+              if text == BORDER_LINE
+                next
+              elsif text.match?(FENCE_LINE)
+                in_code = !in_code
+                body << text
+                content_seen = true
+              elsif in_code || text.match?(RAW_LINE)
+                body << text
+                content_seen = true
+              elsif text == BLANK_LINE
+                body << BLANK_LINE if content_seen
+              elsif text.match?(USER_SEPARATOR)
+                body << INSIDE_SEPARATOR if content_seen
+              elsif text.match?(STRUCTURED_LINE) || text.match?(INDENTED_LINE)
+                body << text
+                content_seen = true
+              else
+                body << cleaned_line(text)
+                content_seen = true
+              end
+            end
 
-          def indent_level(line)
-            line_content(line)[/\A */].size
+            body
           end
 
           ##============================================================##
-          ## Pour récupérer le contenu de la ligne courante
+          ## Nettoie une ligne de texte standard :
+          ## - "### foo"  → "## foo"  (collapse les # répétés)
+          ## - "##  foo"  → "## foo"  (un seul espace après ##)
+          ## NB : les lignes avec 3+ espaces volontaires sont déjà
+          ## interceptées en amont par INDENTED_LINE.
           ##============================================================##
-          def line_content(comment)
-            processed_source.lines[comment.location.line - 1]
+          def cleaned_line(text)
+            text.sub(/\A##\s*#+\s*(?=\S)/, "## ").sub(/\A##\s+(?=\S)/, "## ")
           end
 
-          ##============================================================##
-          ## Expliquons la regex :
-          ## ##\s*#*\s*(?=[[:alnum:]])
-          ## ---------
-          ## ## : match littéralement "##"
-          ## \s* : match 0 ou plusieurs espaces
-          ## #* : match 0 ou plusieurs #
-          ## \s* : match encore 0 ou plusieurs espaces
-          ## (?=[[:alnum:]]) : lookahead positif qui vérifie qu'on a un caractère alphanumérique après
-          ##============================================================##
-          def cleaned_line(line)
-            return line if line.start_with?("## |")
-
-            line.gsub(/##\s*#*\s*(?=[[:alnum:]])/, "## ")
+          def indent_level(comment)
+            processed_source.lines[comment.location.line - 1][/\A */].size
           end
 
-          def needs_correction?(block, correct_block)
-            block.map(&:text).map(&:strip).join("|") != correct_block.split("\n").map(&:strip).join("|")
+          ##============================================================##
+          ## Compare en strippant chaque ligne : on ignore les différences
+          ## d'indentation puisque le range cible déjà la bonne colonne.
+          ##============================================================##
+          def needs_correction?(block, normalized)
+            current_lines    = block.map {|c| c.text.to_s.strip }
+            normalized_lines = normalized.split("\n").map(&:strip)
+            current_lines != normalized_lines
           end
 
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: immosquare-cleaner
 version: !ruby/object:Gem::Version
-  version: 0.1.104
+  version: 0.1.105
 platform: ruby
 authors:
 - immosquare
@@ -190,7 +190,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.11
 specification_version: 4
 summary: A gem to lint and organize files in a Rails application.
 test_files: []