immosquare-cleaner 0.1.84 → 0.1.86

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5db4cb8de23d20003df752fda8dc72588776050a743e6c4f24cfaf9004e1a975
-  data.tar.gz: 94dd38d03de54e6a216a83eec05f4ee92ddf8154e2552ec8b1930a53d8c4a295
+  metadata.gz: f420f9fecadfdb09097a28fb22b0b319fcc88d68f22aad1278d8dc9dc71669d9
+  data.tar.gz: 03f4d9c7033a464609021a3c87768b66b62a5614543a16e9c75a5c50f5b30023
 SHA512:
-  metadata.gz: 86c068a18ff2ef426704c1585d940f9ce702f026b98c37e67797b8a12fe93a5232ad21cadf1cbebdb5b6fcd7ca678a8956747e1d4c547710ec9a672106b7325a
-  data.tar.gz: fae01ff6fb1c24ec38f95ca92095b17e85d8024f9fd35372941ce14a862a0a7dc00db3361545f6199620ebefdceb735cbd42c772d96bc7bbada453a575bb409f
+  metadata.gz: fb224bbda3fab24d76e9d3a65f301a084773b92f587aaf28ecd115abc67e5d9b8bd10d1bdd797aa8e9520f2ca3f3f1a51ec55d385afe8a330930bfd72a7ad136
+  data.tar.gz: 32a944821528ea234e8df348c43d17e3aa2b780270ec4fbf329753a6611cbda52d40a47e1fc8cba7dcf77a8f751656a0da90ee75fa1bc98f614604c0105d6696

data/lib/immosquare-cleaner/version.rb

@@ -1,3 +1,3 @@
 module ImmosquareCleaner
-  VERSION = "0.1.84".freeze
+  VERSION = "0.1.86".freeze
 end

data/lib/immosquare-cleaner.rb

@@ -168,7 +168,8 @@ module ImmosquareCleaner
             File.write(temp_file_path, File.read(file_path))
             cmds = []
             cmds << "bundle exec erb_lint --config #{erblint_config_with_version_path} #{file_path} #{ImmosquareCleaner.configuration.erblint_options || "--autocorrect"}" if file_path.end_with?(".erb")
-            cmds << "bun eslint --config #{gem_root}/linters/eslint.config.mjs  #{temp_file_path} --fix"
+            cmds << "bun #{gem_root}/linters/normalize-comments.mjs #{temp_file_path}"
+            cmds << "bun eslint --config #{gem_root}/linters/eslint.config.mjs #{temp_file_path} --fix"
 
             launch_cmds(cmds)
             File.normalize_last_line(temp_file_path)

data/linters/erb_lint/custom_html_to_content_tag.rb

@@ -61,7 +61,8 @@ module ERBLint
       EXCLUDED_METHODS = [
         "render",
         "content_tag",
-        "image_tag"
+        "image_tag",
+        "link_to"
       ].freeze
 
       ##============================================================##

data/linters/normalize-comments.mjs

@@ -0,0 +1,229 @@
+import { readFileSync, writeFileSync } from "fs"
+import * as babelParser from "@babel/parser"
+
+//============================================================//
+// Constants
+//============================================================//
+const BORDER_LINE      = "//" + "=".repeat(60) + "//"
+const INSIDE_SEPARATOR = "// ---------"
+
+//============================================================//
+// Main function
+//============================================================//
+const normalizeComments = (filePath) => {
+  const code  = readFileSync(filePath, "utf-8")
+  const lines = code.split("\n")
+
+  //============================================================//
+  // Parse the code with babel to get comment positions
+  //============================================================//
+  const ast = babelParser.parse(code, {
+    sourceType: "module",
+    plugins:    ["typescript", "jsx"]
+  })
+
+  //============================================================//
+  // Get all comments from the AST
+  //============================================================//
+  const comments = ast.comments || []
+
+  //============================================================//
+  // Group consecutive standalone line comments
+  //============================================================//
+  const commentBlocks = groupConsecutiveComments(comments, lines)
+
+  //============================================================//
+  // Process blocks in reverse order to avoid line number shifts
+  //============================================================//
+  const blocksReversed = [...commentBlocks].reverse()
+
+  blocksReversed.forEach((block) => {
+    const normalized = normalizeCommentBlock(block, lines)
+    if (normalized) {
+      const startLine = block[0].loc.start.line - 1
+      const endLine   = block[block.length - 1].loc.start.line - 1
+
+      //============================================================//
+      // Replace the lines in the original array
+      //============================================================//
+      lines.splice(startLine, endLine - startLine + 1, ...normalized)
+    }
+  })
+
+  writeFileSync(filePath, lines.join("\n"))
+}
+
+//============================================================//
+// Group consecutive line comments together
+// Only includes standalone comments (not end-of-line comments)
+//============================================================//
+const groupConsecutiveComments = (comments, originalLines) => {
+  const blocks     = []
+  let currentBlock = []
+  let lastLine     = -2
+
+  comments.forEach((comment) => {
+    //============================================================//
+    // Only process line comments (// style), not block comments (/* */)
+    //============================================================//
+    if (comment.type !== "CommentLine") {
+      if (currentBlock.length > 0) {
+        blocks.push(currentBlock)
+        currentBlock = []
+      }
+      lastLine = -2
+      return
+    }
+
+    //============================================================//
+    // Skip triple-slash comments (/// for TypeScript docs)
+    //============================================================//
+    if (comment.value.startsWith("/")) {
+      if (currentBlock.length > 0) {
+        blocks.push(currentBlock)
+        currentBlock = []
+      }
+      lastLine = -2
+      return
+    }
+
+    //============================================================//
+    // Check if this is a standalone comment (line starts with //)
+    // Skip end-of-line comments (e.g., const x = 1 // comment)
+    //============================================================//
+    const lineContent = originalLines[comment.loc.start.line - 1]
+    const isStandalone = lineContent.trim().startsWith("//")
+
+    if (!isStandalone) {
+      if (currentBlock.length > 0) {
+        blocks.push(currentBlock)
+        currentBlock = []
+      }
+      lastLine = -2
+      return
+    }
+
+    const currentLine = comment.loc.start.line
+
+    if (currentLine === lastLine + 1) {
+      currentBlock.push(comment)
+    } else {
+      if (currentBlock.length > 0) {
+        blocks.push(currentBlock)
+      }
+      currentBlock = [comment]
+    }
+    lastLine = currentLine
+  })
+
+  if (currentBlock.length > 0) {
+    blocks.push(currentBlock)
+  }
+
+  return blocks
+}
+
+//============================================================//
+// Normalize a block of comments
+// Returns an array of new lines, or null if no change needed
+//============================================================//
+const normalizeCommentBlock = (block, originalLines) => {
+  if (block.length === 0) return null
+
+  //============================================================//
+  // Get the indentation from the first comment
+  //============================================================//
+  const firstLine = originalLines[block[0].loc.start.line - 1]
+  const indent    = firstLine.match(/^(\s*)/)[1]
+
+  //============================================================//
+  // Extract the text content from each comment
+  //============================================================//
+  const bodyLines            = []
+  let firstLineWithTextFound = false
+
+  block.forEach((comment) => {
+    const text        = comment.value.trim()
+    const hasAlphaNum = /[\p{L}0-9]/u.test(text)
+
+    if (isBorderLine(text)) {
+      return
+    } else if (isSeparatorLine(text)) {
+      if (firstLineWithTextFound) {
+        bodyLines.push(INSIDE_SEPARATOR)
+      }
+    } else if (hasAlphaNum) {
+      firstLineWithTextFound = true
+      bodyLines.push("// " + cleanedLine(text))
+    } else if (firstLineWithTextFound && text === "") {
+      bodyLines.push("//")
+    }
+  })
+
+  //============================================================//
+  // If block is empty, add a placeholder
+  //============================================================//
+  if (bodyLines.length === 0) {
+    bodyLines.push("// ...")
+  }
+
+  //============================================================//
+  // Build the new lines with borders
+  //============================================================//
+  const result = []
+  result.push(indent + BORDER_LINE)
+  bodyLines.forEach((line) => {
+    result.push(indent + line)
+  })
+  result.push(indent + BORDER_LINE)
+
+  return result
+}
+
+//============================================================//
+// Check if a line is a border (long line of = or #)
+//============================================================//
+const isBorderLine = (text) => {
+  const cleaned    = text.replace(/[/=\-\s#]/g, "")
+  const hasEquals  = text.includes("=")
+  const longEnough = text.length > 20
+
+  return cleaned === "" && hasEquals && longEnough
+}
+
+//============================================================//
+// Check if a line is an internal separator (---------)
+//============================================================//
+const isSeparatorLine = (text) => {
+  const cleaned = text.replace(/[-\s]/g, "")
+  return cleaned === "" && text.length >= 5
+}
+
+//============================================================//
+// Clean a comment line
+//============================================================//
+const cleanedLine = (text) => {
+  //============================================================//
+  // Preserve lines with | (markdown tables)
+  //============================================================//
+  if (text.startsWith("|")) {
+    return text
+  }
+
+  //============================================================//
+  // Remove leading special characters and normalize
+  //============================================================//
+  return text.replace(/^[/=\s]*(?=[\p{L}0-9])/u, "").trim()
+}
+
+//============================================================//
+// Run the script
+//============================================================//
+const filePath = process.argv[2]
+
+if (!filePath) {
+  console.error("Usage: bun normalize-comments.mjs <file>")
+  process.exit(1)
+}
+
+normalizeComments(filePath)

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

@@ -18,16 +18,6 @@ module RuboCop
 
             comment_blocks = find_comment_blocks(processed_source.comments)
 
-
-            ##============================================================##
-            ## On ne veut traiter que les blocs de commentaires où la première ligne
-            ## du bloc commence par ##
-            ##============================================================##
-            comment_blocks = comment_blocks.select do |block|
-              block.first.text.strip.start_with?("##")
-            end
-
-
             comment_blocks.each do |block|
               correct_block = normalize_comment_block(block)
 
@@ -59,7 +49,7 @@ module RuboCop
 
 
           ##============================================================##
-          ## On ne veut traiter que les commentaires qui ne sont pas
+          ## On ne veut traiter que les commentaires ## qui ne sont pas
           ## des commentaires de fin de ligne ruby
           ##============================================================##
           def find_comment_blocks(comments)
@@ -67,26 +57,14 @@ module RuboCop
             current_block       = []
             standalone_comments = comments.select do |comment|
               line = processed_source.lines[comment.location.line - 1]
-              line.strip.start_with?("#")
+              line.strip.start_with?("##")
             end
 
             standalone_comments.each_with_index do |comment, index|
-              next_comment      = standalone_comments[index + 1]
-              comment_text      = comment.text.strip
-              next_comment_text = next_comment&.text&.strip
-              is_double_hash    = comment_text.start_with?("##")
-
-              ##============================================================##
-              ## On vérifie si le prochain commentaire est sur la ligne suivante
-              ## ET si les deux commentaires sont du même "type" (## ou #)
-              ## Cela permet de ne pas fusionner les commentaires temporaires
-              ## (# x = 1) avec les vrais commentaires (##)
-              ##============================================================##
-              next_is_double_hash  = next_comment_text&.start_with?("##")
-              same_type            = is_double_hash == next_is_double_hash
+              next_comment         = standalone_comments[index + 1]
               next_line_contiguous = next_comment && next_comment.location.line == comment.location.line + 1
 
-              if next_line_contiguous && same_type
+              if next_line_contiguous
                 current_block << comment
               else
                 current_block << comment
@@ -106,7 +84,6 @@ module RuboCop
 
             body = block.map do |comment|
               text                       = comment.text.to_s.strip
-              chars                      = text.chars.uniq
               alphanumercic              = text.match?(/[\p{L}0-9]/)
               first_line_with_text_found = true if alphanumercic && !first_line_with_text_found
               if text == BORDER_LINE
@@ -145,25 +122,18 @@ module RuboCop
 
           ##============================================================##
           ## 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
+          ## \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)
-            if line.start_with?("## |")
-              line
-            elsif line.start_with?("##")
-              line.gsub(/##\s*#*\s*(?=[[:alnum:]])/, "## ")
-            else
-              ##============================================================##
-              ## Pour une ligne commençant par # simple, on la convertit en ##
-              ## On enlève d'abord le # initial et tous les espaces qui suivent
-              ##============================================================##
-              cleaned = line.gsub(/^#\s*/, "")
-              "## #{cleaned}"
-            end
+            return line if line.start_with?("## |")
+
+            line.gsub(/##\s*#*\s*(?=[[:alnum:]])/, "## ")
           end
 
           def needs_correction?(block, correct_block)

data/package.json

@@ -2,6 +2,7 @@
   "name":         "immosquare-cleaner",
   "private":      true,
   "dependencies": {
+    "@babel/parser":                    "^7.28.5",
     "@eslint/js":                       "^9.39.1",
     "@typescript-eslint/eslint-plugin": "^8.48.1",
     "@typescript-eslint/parser":        "^8.48.1",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: immosquare-cleaner
 version: !ruby/object:Gem::Version
-  version: 0.1.84
+  version: 0.1.86
 platform: ruby
 authors:
 - immosquare
@@ -152,6 +152,7 @@ files:
 - linters/erb_lint/custom_html_to_content_tag.rb
 - linters/erb_lint/custom_single_line_if_modifier.rb
 - linters/eslint.config.mjs
+- linters/normalize-comments.mjs
 - linters/prettier.yml
 - linters/rubocop-3.4.1.yml
 - linters/rubocop.yml