immosquare-cleaner 0.1.65 → 0.1.66

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc5c57133db8755341c7dea0030318f79296ab019eb026017ac993e62e2066f2
-  data.tar.gz: 0fc112757a1f0023673778ef5581a5ad48c2bcccb25052cf403c31548cc21137
+  metadata.gz: afe08bb3ff3e8c0371bacff7e9b508e4efef53762832f1c654cf10304ca6f056
+  data.tar.gz: 55889ab55f094e8a5195c2bf99fd53e4e7a3a334a157ae0b9c8b52212f87a19d
 SHA512:
-  metadata.gz: 9f2ad98bda1e6b473871427b1d8259ef8a6db0cb51bcd18ed02d194b268801ee4764301e797a954b21c786502eeaef1ba14416944be287c86970b42e97ab2fd0
-  data.tar.gz: ca9859096a9954448f1bc618e3e068b696e98fe703e97bccc71c16590b87bd4e5b97504daeb8c8d8927d3accd35bce4a84fb6444ab69113a42f19390adb91759
+  metadata.gz: 14f1f84a35eba0140cebc8df823720be70ecfecb7be829dfe799bb087816a06c112883dddb9090c150b72a9b70c1db7db7bb7dfc0e5b77775e64fb9624a60c81
+  data.tar.gz: 8d18d9be48e914b21f4af508851efa1e3f31ab0ca6474e51c9fdb3b420655c7b25b29e672d8eb4380d010ed96d382ad684ce53df8343245b04d559b154fcec55

data/lib/immosquare-cleaner/version.rb

@@ -1,3 +1,3 @@
 module ImmosquareCleaner
-  VERSION = "0.1.65".freeze
+  VERSION = "0.1.66".freeze
 end

data/lib/immosquare-cleaner.rb

@@ -136,34 +136,35 @@ module ImmosquareCleaner
         elsif file_path =~ %r{locales/.*\.yml$}
           ImmosquareYaml.clean(file_path)
 
-
-        ##============================================================##
-        ## JS files
-        ## 16/05/2024
-        ## maj 06/01/2025
-        ## ---------
-        ## Depuis eslint V9 (acutellement en V9.17.0), il y a une erreur
-        ## "warning  File ignored because outside of base path"
-        ## si le fichier à linté est dans un dossier supérieur à celui du fichier de config.
-        ## ISSUE : https://github.com/eslint/eslint/issues/19118
-        ## ---------
-        ## Dans nos apps nous sommes tjs dans ce cas car le fichier de config est dans le dossier du gem.
-        ## et les fichiers à linté sont dans les apps.
-        ## ---------
-        ## Pour éviter ce problème on met le fichier dans un dossier temporaire dans le dossier du gem
-        ## et on le supprime par la suite.
-        ##============================================================##
-        elsif file_path.end_with?(".js") || file_path.end_with?(".mjs")
+          ##============================================================##
+          ## JS files
+          ## 16/05/2024
+          ## maj 06/01/2025
+          ## ---------
+          ## Depuis eslint V9 (acutellement en V9.17.0), il y a une erreur
+          ## "warning  File ignored because outside of base path"
+          ## si le fichier à linté est dans un dossier supérieur à celui du fichier de config.
+          ## ISSUE : https://github.com/eslint/eslint/issues/19118
+          ## ---------
+          ## Dans nos apps nous sommes tjs dans ce cas car le fichier de config est dans le dossier du gem.
+          ## et les fichiers à linté sont dans les apps.
+          ## ---------
+          ## Pour éviter ce problème on met le fichier dans un dossier temporaire dans le dossier du gem
+          ## et on le supprime par la suite.
+          ##============================================================##
+        elsif file_path.end_with?(".js", ".mjs", "js.erb")
           begin
             temp_folder_path = "#{gem_root}/tmp"
             temp_file_path = "#{temp_folder_path}/#{File.basename(file_path)}"
             FileUtils.mkdir_p(temp_folder_path)
             File.write(temp_file_path, File.read(file_path))
-            cmds = ["bun eslint --config #{gem_root}/linters/eslint.config.mjs  #{temp_file_path} --fix"]
+            cmds = []
+            cmds << "bundle exec erb_lint --config #{erblint_config_with_version_path} #{file_path} #{ImmosquareCleaner.configuration.erblint_options || "--autocorrect"}" if file_path.end_with?("js.erb")
+            cmds << "bun eslint --config #{gem_root}/linters/eslint.config.mjs  #{temp_file_path} --fix"
+
             launch_cmds(cmds)
             File.normalize_last_line(temp_file_path)
             File.write(file_path, File.read(temp_file_path))
-          rescue StandardError => e
           ensure
             FileUtils.rm_f(temp_file_path)
           end

data/linters/eslint.config.mjs

@@ -3,6 +3,7 @@ import preferArrow      from "eslint-plugin-prefer-arrow"
 import sonarjs          from "eslint-plugin-sonarjs"
 import alignAssignments from "eslint-plugin-align-assignments"
 import alignImport      from "eslint-plugin-align-import"
+import erb              from "eslint-plugin-erb"
 
 export default [
   js.configs.recommended,
@@ -112,5 +113,18 @@ export default [
       // ==============================================================================================##
       "no-magic-numbers": ["off", { ignore: [], ignoreArrayIndexes: true, enforceConst: true, detectObjects: false }]
     }
+  },
+  erb.configs.recommended,
+  {
+    linterOptions: {
+      // The "unused disable directive" is set to "warn" by default.
+      // For the ERB plugin to work correctly, you must disable
+      // this directive to avoid issues described here
+      // https://github.com/eslint/eslint/discussions/18114
+      // If you're using the CLI, you might also use the following flag:
+      // --report-unused-disable-directives-severity=off
+      reportUnusedDisableDirectives: "off"
+    }
+    // your other configuration options
   }
 ]

data/node_modules/eslint-plugin-erb/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-2025 Splines
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/node_modules/eslint-plugin-erb/README.md

@@ -0,0 +1,257 @@
+# eslint-plugin-erb
+
+**Lint your JavaScript code inside ERB files (`.js.erb`).**
+A zero-dependency plugin for [ESLint](https://eslint.org/).
+<br>Also lints your **HTML code** in `.html.erb` if you want to.
+
+![showcase-erb-lint-gif](https://github.com/Splines/eslint-plugin-erb/assets/37160523/623d6007-b4f5-41ce-be76-5bc0208ed636?raw=true)
+
+## Usage
+
+### Install
+
+Install the plugin alongside [ESLint](https://eslint.org/docs/latest/use/getting-started):
+
+```sh
+npm install --save-dev eslint eslint-plugin-erb
+```
+
+### Configure
+
+Starting of v9 ESLint provides a [new flat config format](https://eslint.org/docs/latest/use/configure/configuration-files-new) (`eslint.config.js`). Also see the [configuration migration guide](https://eslint.org/docs/latest/use/configure/migration-guide). Use it as follows and it will automatically lint all your **JavaScript code** in `.js.erb` files:
+
+```js
+// eslint.config.js
+import erb from "eslint-plugin-erb";
+
+export default [
+  erb.configs.recommended,
+  {
+    linterOptions: {
+      // The "unused disable directive" is set to "warn" by default.
+      // For the ERB plugin to work correctly, you must disable
+      // this directive to avoid issues described here
+      // https://github.com/eslint/eslint/discussions/18114
+      // If you're using the CLI, you might also use the following flag:
+      // --report-unused-disable-directives-severity=off
+      reportUnusedDisableDirectives: "off",
+    },
+    // your other configuration options
+  }
+];
+```
+
+<details>
+<summary>See more complete example</summary>
+
+```js
+// eslint.config.js
+import js from "@eslint/js";
+import stylistic from "@stylistic/eslint-plugin";
+import globals from "globals";
+import erb from "eslint-plugin-erb";
+
+const customizedStylistic = stylistic.configs.customize({
+  "indent": 2,
+  "jsx": false,
+  "quote-props": "always",
+  "semi": "always",
+  "brace-style": "1tbs",
+});
+
+const customGlobals = {
+  MyGlobalVariableOrFunctionOrClassOrWhatever: "readable",
+};
+
+// [1] https://eslint.org/docs/latest/use/configure/configuration-files-new#globally-ignoring-files-with-ignores
+
+export default [
+  js.configs.recommended,
+  erb.configs.recommended,
+  // Globally ignoring the following files
+  // "Note that only global ignores patterns can match directories.
+  // 'ignores' patterns that are specific to a configuration will
+  // only match file names." ~ see [1]
+  {
+    ignores: [
+      "node_modules/",
+      "tests/fixtures/",
+      "tmp/",
+    ],
+  },
+  {
+    plugins: {
+      "@stylistic": stylistic,
+    },
+    rules: {
+      ...customizedStylistic.rules,
+      "no-unused-vars": ["warn", { argsIgnorePattern: "^_" }],
+      "@stylistic/quotes": ["error", "double", { avoidEscape: true }],
+    },
+    languageOptions: {
+      ecmaVersion: 2022,
+      sourceType: "module",
+      globals: {
+        ...customGlobals,
+        ...globals.browser,
+        ...globals.node,
+      },
+    },
+    linterOptions: {
+      // The "unused disable directive" is set to "warn" by default.
+      // For the ERB plugin to work correctly, you must disable
+      // this directive to avoid issues described here
+      // https://github.com/eslint/eslint/discussions/18114
+      // If you're using the CLI, you might also use the following flag:
+      // --report-unused-disable-directives-severity=off
+      reportUnusedDisableDirectives: "off",
+    },
+  },
+];
+```
+
+</details>
+
+<details>
+
+<summary>Alternative way to configure the processor</summary>
+
+With this variant you have a bit more control over what is going on, e.g. you could name your files `.js.special-erb` and still lint them (if they contain JS and ERB syntax).
+
+```js
+// eslint.config.js
+import erb from "eslint-plugin-erb";
+
+export default [
+  {
+    files: ["**/*.js.erb"],
+    processor: erb.processors.processorJs,
+  },
+  {
+    linterOptions: {
+      // The "unused disable directive" is set to "warn" by default.
+      // For the ERB plugin to work correctly, you must disable
+      // this directive to avoid issues described here
+      // https://github.com/eslint/eslint/discussions/18114
+      // If you're using the CLI, you might also use the following flag:
+      // --report-unused-disable-directives-severity=off
+      reportUnusedDisableDirectives: "off",
+    },
+    // your other configuration options
+  }
+];
+```
+
+</details>
+
+<details>
+<summary>Legacy: you can still use the old `.eslintrc.js` format</summary>
+
+You can extend the `plugin:erb/recommended-legacy` config that will enable the ERB processor on all `.js.erb` files.
+
+```js
+// .eslintrc.js
+module.exports = {
+    extends: "plugin:erb/recommended-legacy"
+};
+```
+
+Or you can configure the processor manually:
+
+```js
+// .eslintrc.js
+module.exports = {
+    plugins: ["erb"],
+    overrides: [
+        {
+            files: ["**/*.js.erb"],
+            processor: "erb/processorJs"
+        }
+    ]
+};
+```
+
+</details>
+
+<br>
+
+If you also want to lint **HTML code** in `.html.erb` files, you can use our preprocessor in conjunction with the amazing [`html-eslint`](https://html-eslint.org/) plugin. Install `html-eslint`, then add the following to your ESLint config file (flat config format):
+
+```js
+// eslint.config.js
+import erb from "eslint-plugin-erb";
+
+export default [
+  // your other configurations...
+  {
+    processor: erb.processors["processorHtml"],
+    ...html.configs["flat/recommended"],
+    files: ["**/*.html", "**/*.html.erb"],
+    rules: {
+        ...html.configs["flat/recommended"].rules,
+        "@html-eslint/indent": ["error", 2],
+        // other rules...
+    },
+  }
+];
+```
+
+Additionally, you might want to add the following option to the other objects (`{}`) in `export default []` (at the same level like the `files` key above), since other rules might be incompatible with HTML files:
+
+```js
+ignores: ["**/*.html**"],
+```
+
+## Editor Integrations
+
+The [ESLint extension](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint) for VSCode has built-in support for the ERB processor once you've configured it in your `.eslintrc.js` file as shown above.
+
+If you're using VSCode, you may find this `settings.json` options useful:
+
+```jsonc
+{
+    "editor.formatOnSave": false, // it still autosaves with the options below
+    //////////////////////////////////////
+    // JS (ESLint)
+    //////////////////////////////////////
+    // https://eslint.style/guide/faq#how-to-auto-format-on-save
+    // https://github.com/microsoft/vscode-eslint#settings-options
+    "eslint.format.enable": true,
+    "[javascript]": {
+        "editor.formatOnSave": false, // to avoid formatting twice (ESLint + VSCode)
+        "editor.defaultFormatter": "dbaeumer.vscode-eslint" // use ESLint plugin
+    },
+    "editor.codeActionsOnSave": {
+        "source.fixAll.eslint": "explicit" // Auto-fix ESLint errors on save
+    },
+    // this disables VSCode built-int formatter (instead we want to use ESLint)
+    "javascript.validate.enable": false,
+    //////////////////////////////////////
+    // Files
+    //////////////////////////////////////
+    "files.associations": {
+        "*.js.erb": "javascript"
+    },
+}
+```
+
+## Limitations
+
+- Does not account for code indentation inside `if/else` ERB statements, e.g.
+this snippet
+
+```js
+<% if you_feel_lucky %>
+    console.log("You are lucky 🍀");
+<% end %>
+```
+
+will be autofixed to
+
+```js
+<% if you_feel_lucky %>
+console.log("You are lucky 🍀");
+<% end %>
+```
+
+- No support for ESLint _suggestions_ (but full support for _autofixes_ as shown in the GIF above)

data/node_modules/eslint-plugin-erb/index.js

@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = require("./lib");

data/node_modules/eslint-plugin-erb/lib/autofix.js

@@ -0,0 +1,44 @@
+const { coordinatesToIndex, indexToColumn } = require("./file_coordinates.js");
+const { calculateOffset } = require("./offset_calculation.js");
+
+function transformFix(message, originalText, lintableText, offsetMap, dummyReplacementsMap) {
+  const newRange = calculateNewRange(message, originalText, lintableText, offsetMap);
+  const newFixText = transformFixText(message, newRange, originalText,
+    offsetMap, dummyReplacementsMap);
+
+  return {
+    range: newRange,
+    text: newFixText,
+  };
+}
+
+function calculateNewRange(message, originalText, lintableText, offsetMap) {
+  let lastIndex = -1;
+  let lastIndexMapped = -1;
+
+  return message.fix.range.map((index) => {
+    if (index == lastIndex) {
+      return lastIndexMapped;
+    }
+
+    const pos = indexToColumn(lintableText, index);
+    const offset = calculateOffset(index, pos.line, offsetMap);
+    const posOriginal = {
+      line: pos.line + offset.lineOffset,
+      column: pos.column + offset.columnOffset,
+    };
+    const indexMapped = coordinatesToIndex(originalText, posOriginal.line, posOriginal.column);
+
+    lastIndex = index;
+    lastIndexMapped = indexMapped;
+
+    return indexMapped;
+  });
+}
+
+function transformFixText(message, newRange, originalText, offsetMap, dummyReplacementsMap) {
+  const fixText = message.fix.text;
+  return dummyReplacementsMap.apply(fixText);
+}
+
+module.exports = { transformFix };

data/node_modules/eslint-plugin-erb/lib/cache.js

@@ -0,0 +1,21 @@
+class Cache {
+  constructor() {
+    // filename -> { originalText, lintableText, offsetMap }
+    this.cache = new Map();
+  }
+
+  add(filename, originalText, lintableText, offsetMap, dummyReplacementsMap) {
+    this.cache.set(filename, { originalText, lintableText, offsetMap, dummyReplacementsMap });
+  }
+
+  get(filename) {
+    return this.cache.get(filename);
+  }
+
+  delete(filename) {
+    this.cache.delete(filename);
+  }
+}
+
+const cache = new Cache();
+module.exports = cache;

data/node_modules/eslint-plugin-erb/lib/dummy_replacements_map.js

@@ -0,0 +1,30 @@
+/**
+ * Array that tracks the replacements that have been made in the processed text,
+ * so that we can reverse them later.
+ */
+class DummyReplacementsMap {
+  constructor() {
+    this.replacements = [];
+  }
+
+  addMapping(originalText, dummyText) {
+    this.replacements.push([originalText, dummyText]);
+  }
+
+  /**
+   * Tries to apply all stored replacements to the given text.
+   * @param {string} text - The text to apply the replacements to.
+   * @returns {string} - The text with the replacements applied.
+   */
+  apply(text) {
+    let lintableText = text;
+    for (const [originalText, dummyText] of this.replacements) {
+      lintableText = lintableText.replace(dummyText, originalText);
+    }
+    return lintableText;
+  }
+}
+
+module.exports = {
+  DummyReplacementsMap,
+};

data/node_modules/eslint-plugin-erb/lib/file_coordinates.js

@@ -0,0 +1,41 @@
+/**
+ *
+ * @param {string} text Text
+ * @param {number} line 1-based line number
+ * @param {number} column 1-based column number
+ * @returns {number} 0-based index of the character in the text
+ * at the given line and column
+ */
+function coordinatesToIndex(text, line, column) {
+  const lines = text.split("\n");
+
+  // Lines
+  let index = 0;
+  for (let i = 0; i < line - 1; i++) { // lines are 1-based (!)
+    index += lines[i].length + 1; // +1 for newline character
+  }
+
+  // Column
+  index += (column - 1); // column is 1-based (while index is 0-based)
+
+  return index;
+}
+
+/**
+ *
+ * @param {*string} text Text
+ * @param {*number} index 0-based index in text
+ * @returns {*number} 1-based column number
+ */
+function indexToColumn(text, index) {
+  const linesUpToIndex = text.slice(0, index).split("\n");
+  const column = linesUpToIndex[linesUpToIndex.length - 1].length;
+  const lineNumber = linesUpToIndex.length;
+
+  return {
+    line: lineNumber,
+    column: column + 1, // column is 1-based
+  };
+}
+
+module.exports = { coordinatesToIndex, indexToColumn };

data/node_modules/eslint-plugin-erb/lib/index.js

@@ -0,0 +1,50 @@
+const { preprocessJs, preprocessHtml } = require("./preprocess.js");
+const postprocess = require("./postprocess.js");
+
+// Load processors
+const processorJs = {
+  meta: {
+    name: "processJs",
+  },
+  preprocess: preprocessJs,
+  postprocess,
+  supportsAutofix: true,
+};
+const processorHtml = {
+  meta: {
+    name: "processHtml",
+  },
+  preprocess: preprocessHtml,
+  postprocess,
+  supportsAutofix: true,
+};
+
+// Define & export plugin
+const plugin = {
+  meta: {
+    name: "eslint-plugin-erb",
+    version: "2.1.1",
+  },
+  configs: {
+    "recommended": {
+      files: ["**/*.js.erb"],
+      processor: processorJs,
+    },
+    // for the old non-flat config ESLint API
+    "recommended-legacy": {
+      plugins: ["erb"],
+      overrides: [
+        {
+          files: ["**/*.js.erb"],
+          processor: "erb/processorJs",
+        },
+      ],
+    },
+  },
+  processors: {
+    processorJs: processorJs,
+    processorHtml: processorHtml,
+  },
+};
+
+module.exports = plugin;

data/node_modules/eslint-plugin-erb/lib/offset_calculation.js

@@ -0,0 +1,50 @@
+////////////////////////////////////////////////////
+// Offset calculation
+////////////////////////////////////////////////////
+
+function calculateOffset(index, line, offsetMap) {
+  const lineOffsets = offsetMap.lookupLine(line);
+  if (lineOffsets) {
+    return calculateOffsetLineStrategy(index, line, lineOffsets, offsetMap);
+  }
+  else {
+    return calculateOffsetNormalIndexStrategy(index, offsetMap);
+  }
+}
+
+function calculateOffsetLineStrategy(index, line, lineOffsets, offsetMap) {
+  const indexKey = offsetMap.findKeyJustSmallerThan(index, line);
+
+  if (indexKey !== undefined) {
+    const offsets = lineOffsets.get(indexKey);
+    return {
+      lineOffset: offsets.lineOffset,
+      columnOffset: offsets.columnOffset,
+    };
+  }
+
+  // Situation: our index is on the left side of [..., ..., ...]
+  // We need to find the next smaller line number that is present in the map
+  // Therefore: Fallback to normal index strategy
+  return calculateOffsetNormalIndexStrategy(index, offsetMap);
+}
+
+function calculateOffsetNormalIndexStrategy(index, offsetMap) {
+  const indexKey = offsetMap.findKeyJustSmallerThan(index, null);
+
+  if (indexKey !== undefined) {
+    const offsets = offsetMap.lookupIndex(indexKey);
+    return {
+      lineOffset: offsets.lineOffset,
+      columnOffset: 0,
+    };
+  }
+
+  // Can only happen at the beginning of the file before first ERB tag
+  return {
+    lineOffset: 0,
+    columnOffset: 0,
+  };
+}
+
+module.exports = { calculateOffset };

data/node_modules/eslint-plugin-erb/lib/offset_map.js

@@ -0,0 +1,111 @@
+/* Sample view of the relevant data structures:
+
+this.lineOffsetLookup = {
+  1 => Map(1) { 43 => [ 0, -23 ] },
+  2 => Map(1) { 92 => [ 0, -17 ] },
+  6 => Map(1) { 224 => [ 3, 5 ] },
+  7 => Map(1) { 303 => [ 6, 6 ] },
+  12 => Map(1) { 605 => [ 6, -3 ] },
+  18 => Map(2) { 813 => [ 6, -26 ], 856 => [ 6, -43 ] },
+  21 => Map(1) { 942 => [ 6, 95 ] }
+}
+
+For brevity, we emit the respective property names and show the values in an
+array instead. First number is line offset, second number is column offset.
+
+this.offsetLookup = {
+  43 => [ 0, -23 ],
+  92 => [ 0, -17 ],
+  224 => [ 3, 5 ],
+  303 => [ 6, 6 ],
+  605 => [ 6, -3 ],
+  813 => [ 6, -26 ],
+  856 => [ 6, -43 ],
+  942 => [ 6, 95 ]
+}
+
+We store the end index of the respective ERB tag and use that as key for our map.
+Note that this end index refers to the processed text, i. e. the text after
+replacing ERB tags with dummy comments.
+The index is an index to the whole text.
+Note that line offsets accumulate.
+
+And to add to the good old off-by-one confusion:
+Line offsets: 1-based
+Column offsets: 0-based
+(also see file coordinates)
+
+*/
+
+class OffsetMap {
+  constructor() {
+    // (line number in processed text) -> (this.offsetLookup map with keys for that line)
+    this.lineOffsetLookup = new Map();
+
+    // (index in processed text) -> { lineOffset, columnOffset }
+    this.offsetLookup = new Map();
+  }
+
+  /**
+   *
+   * @param {Number} index end index in processed text
+   * @param {Number} line line number in processed text
+   * @param {Number} lineOffset number of lines that have to be added to a warning
+   * in the processed text
+   * @param {Number} columnOffset number of columns that have to be added to a
+   * warning in the processed text
+   */
+  addMapping(index, line, lineOffset, columnOffset) {
+    // Multiple ERB tags can be opened and closed on the same line
+    let sameLineAdditionalColumnOffset = 0;
+    let existingLineMap = new Map();
+
+    if (this.lineOffsetLookup.has(line)) {
+      existingLineMap = this.lineOffsetLookup.get(line);
+      const highestIndex = Math.max(...Array.from(existingLineMap.keys()));
+      sameLineAdditionalColumnOffset = existingLineMap.get(highestIndex).columnOffset;
+    }
+
+    // Construct new entry for data structures
+    const newPartialMap = new Map();
+    newPartialMap.set(index, {
+      lineOffset: lineOffset,
+      columnOffset: columnOffset + sameLineAdditionalColumnOffset,
+    });
+
+    // Update data structures (don't care if its inefficient, it works fast enough)
+    this.lineOffsetLookup.set(line, new Map([...existingLineMap, ...newPartialMap]));
+    this.offsetLookup = new Map([...this.offsetLookup, ...newPartialMap]);
+  }
+
+  lookupIndex(index) {
+    return this.offsetLookup.get(index);
+  }
+
+  lookupLine(line) {
+    return this.lineOffsetLookup.get(line);
+  }
+
+  // we assume that line has a valid entry in the map, caller needs to check (!)
+  findKeyJustSmallerThan(index, line) {
+    // Determine which map to use
+    let offsetLookup = line ? this.lineOffsetLookup.get(line) : this.offsetLookup;
+
+    const mapIndizes = Array.from(offsetLookup.keys());
+    mapIndizes.sort((a, b) => b - a); // from highest to lowest
+
+    let keyJustSmallerThanIndex;
+    for (let key of mapIndizes) {
+      if (key <= index) {
+        keyJustSmallerThanIndex = key;
+        return keyJustSmallerThanIndex;
+      }
+    }
+
+    return undefined;
+  }
+}
+
+module.exports = {
+  OffsetMap,
+};

data/node_modules/eslint-plugin-erb/lib/postprocess.js

@@ -0,0 +1,72 @@
+const cache = require("./cache.js");
+const { coordinatesToIndex } = require("./file_coordinates.js");
+const { calculateOffset } = require("./offset_calculation.js");
+const { transformFix } = require("./autofix.js");
+
+/**
+ * Transforms the messages form ESLint such that they point to the correct
+ * location in the source code.
+ * @param {Array<Message[]>} messages An array containing one array of messages
+ *    for each code block returned from `preprocess`. As we only deal with one
+ *    code block, this array contains only *one* array of messages.
+ * @param {string} filename filename of the file.
+ * @returns {Message[]} A flattened array of messages with mapped locations.
+ */
+function postprocess(messages, filename) {
+  const { originalText, lintableText, offsetMap, dummyReplacementsMap } = cache.get(filename);
+
+  const transformedMessages = messages[0].map((message) => {
+    return adjustMessage(message, originalText, lintableText, offsetMap, dummyReplacementsMap);
+  });
+  cache.delete(filename);
+
+  return transformedMessages;
+}
+
+/**
+ * Adjusts ESLint messages to point to the correct location in the source code.
+ * @param {Message} message message form ESLint
+ * @returns {Message} same message, but adjusted to the correct location
+ */
+function adjustMessage(message, originalText, lintableText, offsetMap, dummyReplacementsMap) {
+  if (!Number.isInteger(message.line)) {
+    return {
+      ...message,
+      line: 0,
+      column: 0,
+    };
+  }
+
+  // From now on: assume some kind of positivity, e.g. message.line and
+  // message.column exists.
+
+  // Start line/column
+  const index = coordinatesToIndex(lintableText, message.line, message.column);
+  const offset = calculateOffset(index, message.line, offsetMap);
+  let newCoordinates = {
+    line: message.line + offset.lineOffset,
+    column: message.column + offset.columnOffset,
+  };
+
+  // End line/column
+  if (Number.isInteger(message.endLine)) {
+    const indexEnd = coordinatesToIndex(lintableText, message.endLine, message.endColumn);
+    const offsetEnd = calculateOffset(indexEnd, message.endLine, offsetMap);
+
+    newCoordinates = {
+      ...newCoordinates,
+      endLine: message.endLine + offsetEnd.lineOffset,
+      endColumn: message.endColumn + offsetEnd.columnOffset };
+  }
+
+  // Autofixes
+  const adjustedFix = {};
+  if (message.fix) {
+    adjustedFix.fix = transformFix(message, originalText, lintableText,
+      offsetMap, dummyReplacementsMap);
+  }
+
+  return { ...message, ...newCoordinates, ...adjustedFix };
+}
+
+module.exports = postprocess;

data/node_modules/eslint-plugin-erb/lib/preprocess.js

@@ -0,0 +1,113 @@
+// The words "after" and "before" refer to "after" and "before" processing,
+// i.e. replacing of respective ERB tags with dummy comments.
+
+const cache = require("./cache.js");
+
+const { indexToColumn } = require("./file_coordinates.js");
+
+// how annoying is that kind of import in JS ?!
+var OffsetMap = require("./offset_map.js").OffsetMap;
+var DummyReplacementsMap = require("./dummy_replacements_map.js").DummyReplacementsMap;
+
+const ERB_REGEX = /<%[\s\S]*?%>/g;
+const HASH = "566513c5d83ac26e15414f2754"; // to avoid collisions with user code
+
+/**
+ * Transforms the given text into lintable text. We do this by stripping out
+ * ERB tags and replacing them with dummy comments. Additionally, we keep track
+ * of the offset introduced by this replacement, so that we can adjust the
+ * location of messages in the postprocess step later.
+ * @param {string} text text of the file
+ * @param {string} filename filename of the file
+ * @param {(id) => string} toDummyString function that takes an id and the
+ * matched text and returns a dummy string to replace the matched text with.
+ * This dummy string must be unique.
+ * @returns {Array<{ filename: string, text: string }>} source code blocks to lint
+ */
+function preprocess(text, filename, toDummyString) {
+  let lintableTextArr = text.split("");
+
+  let match;
+  let numAddLines = 0;
+  let numDiffChars = 0;
+  const offsetMap = new OffsetMap();
+  const dummyReplacementsMap = new DummyReplacementsMap();
+
+  let matchedId = 0;
+  while ((match = ERB_REGEX.exec(text)) !== null) {
+    // Match information
+    const startIndex = match.index;
+    const matchText = match[0];
+    const matchLength = matchText.length;
+    const endIndex = startIndex + matchLength;
+    const matchLines = matchText.split("\n");
+
+    // Lines
+    numAddLines += matchLines.length - 1;
+
+    // Columns
+    const dummy = toDummyString(matchedId, matchText);
+    const coordStartIndex = indexToColumn(text, startIndex);
+    const endColumnAfter = coordStartIndex.column + dummy.length;
+    const coordEndIndex = indexToColumn(text, endIndex);
+    const endColumnBefore = coordEndIndex.column;
+    const numAddColumns = endColumnBefore - endColumnAfter;
+    replaceTextWithDummy(lintableTextArr, startIndex, matchLength - 1, dummy);
+
+    const textWithErbSyntax = text.slice(startIndex, endIndex);
+    dummyReplacementsMap.addMapping(textWithErbSyntax, dummy);
+
+    // Store in map
+    const lineAfter = coordEndIndex.line - numAddLines;
+    numDiffChars += dummy.length - matchLength;
+    const endIndexAfter = endIndex + numDiffChars;
+    offsetMap.addMapping(endIndexAfter, lineAfter, numAddLines, numAddColumns);
+
+    matchedId += 1;
+  }
+
+  const lintableText = lintableTextArr.join("");
+  cache.add(filename, text, lintableText, offsetMap, dummyReplacementsMap);
+  return [lintableText];
+}
+
+/**
+ * In-place replaces the text (as array) at the given index, for a given length,
+ * with a dummy string.
+ *
+ * Note that the dummy string is inserted at the given index as one big string.
+ * For the length of the match, subsequent characters are replaced with empty
+ * strings in the array.
+ */
+function replaceTextWithDummy(lintableTextArr, startIndex, length, dummy) {
+  lintableTextArr[startIndex] = dummy;
+  const replaceArgs = Array(length).join(".").split(".");
+  // -> results in ['', '', '', '', ...]
+  lintableTextArr.splice(startIndex + 1, length, ...replaceArgs);
+}
+
+function preprocessJs(text, filename) {
+  function wrapInEslintDisable(text) {
+    return `/* eslint-disable */${text}/* eslint-enable */`;
+  }
+
+  function toDummyString(id, matchText) {
+    if (matchText.startsWith("<%=")) {
+      return wrapInEslintDisable(`{}/* eslint-plugin-erb ${HASH} ${id} */`);
+    }
+    return wrapInEslintDisable(`/* eslint-plugin-erb ${HASH} ${id} */`);
+  }
+  return preprocess(text, filename, toDummyString);
+}
+
+function preprocessHtml(text, filename) {
+  function toDummyString(id, _matchText) {
+    return `<!-- ${HASH} ${id} -->`;
+  }
+  return preprocess(text, filename, toDummyString);
+}
+
+module.exports = {
+  preprocessJs,
+  preprocessHtml,
+};

data/node_modules/eslint-plugin-erb/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "eslint-plugin-erb",
+  "version": "2.1.1",
+  "description": "An ESLint plugin to lint JavaScript in ERB files (.js.erb)",
+  "license": "MIT",
+  "author": {
+    "name": "Splines",
+    "url": "https://github.com/splines"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Splines/eslint-plugin-erb.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Splines/eslint-plugin-erb/issues"
+  },
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-processor",
+    "erb",
+    "ruby",
+    "embedded ruby",
+    "javascript",
+    "lint",
+    "linter"
+  ],
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "lib"
+  ],
+  "devDependencies": {
+    "@html-eslint/eslint-plugin": "^0.31.1",
+    "@html-eslint/parser": "^0.31.0",
+    "@stylistic/eslint-plugin": "^1.3.3",
+    "chai": "^4.3.10",
+    "eslint": "^9.17.0",
+    "globals": "^13.24.0",
+    "mocha": "^10.2.0"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "lint-fix": "eslint --fix .",
+    "test": "mocha",
+    "whats-included": "npm pack --dry-run",
+    "bump-version": "npm run test && npm version --no-git-tag-version",
+    "publish-final": "npm run test && npm publish"
+  }
+}

data/package.json

@@ -6,6 +6,7 @@
     "eslint":                          "^9.22.0",
     "eslint-plugin-align-assignments": "^1.1.2",
     "eslint-plugin-align-import":      "^1.0.0",
+    "eslint-plugin-erb":               "^2.1.1",
     "eslint-plugin-prefer-arrow":      "^1.2.3",
     "eslint-plugin-sonarjs":           "^3.0.2",
     "prettier":                        "^3.5.3"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: immosquare-cleaner
 version: !ruby/object:Gem::Version
-  version: 0.1.65
+  version: 0.1.66
 platform: ruby
 authors:
 - immosquare
@@ -5638,6 +5638,19 @@ files:
 - node_modules/eslint-plugin-align-import/package.json
 - node_modules/eslint-plugin-align-import/tests/lib/rules/align-import.js
 - node_modules/eslint-plugin-align-import/tests/lib/rules/trim-import.js
+- node_modules/eslint-plugin-erb/LICENSE
+- node_modules/eslint-plugin-erb/README.md
+- node_modules/eslint-plugin-erb/index.js
+- node_modules/eslint-plugin-erb/lib/autofix.js
+- node_modules/eslint-plugin-erb/lib/cache.js
+- node_modules/eslint-plugin-erb/lib/dummy_replacements_map.js
+- node_modules/eslint-plugin-erb/lib/file_coordinates.js
+- node_modules/eslint-plugin-erb/lib/index.js
+- node_modules/eslint-plugin-erb/lib/offset_calculation.js
+- node_modules/eslint-plugin-erb/lib/offset_map.js
+- node_modules/eslint-plugin-erb/lib/postprocess.js
+- node_modules/eslint-plugin-erb/lib/preprocess.js
+- node_modules/eslint-plugin-erb/package.json
 - node_modules/eslint-plugin-prefer-arrow/LICENSE
 - node_modules/eslint-plugin-prefer-arrow/README.md
 - node_modules/eslint-plugin-prefer-arrow/index.js