immosquare-cleaner 0.1.79 → 0.1.81

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45e404f079f70d3ef6f0094bcf52a1faf665c26f73745414a673d9c5714c9a09
-  data.tar.gz: 751950bcd194667c031f409d63a195b9b7aa1cfaabd0249462ccbba3f51ec1bb
+  metadata.gz: 3f7191ad53888a016ec0dfa5fd727e79303c499d6a6be0219e8b34dbe1f882e3
+  data.tar.gz: cff9ae3ebbe2136a1fec9cf40131741b2a445ee84ef3db21d955a0404937a321
 SHA512:
-  metadata.gz: a50362fc98a675691238e826f71beeed82632c9a71490ffca677677c85241af7dc4917947962717faa2ff38b700472902b1b4fe7f5c48c5e5402b5e321e6c738
-  data.tar.gz: 2bc538063808ced4b902e52755c04ffbb65686799366feba4c970c95aec366f2af6a258b914f292d64f989e53d3f906fa6fc229ade87278ae36cecc635335e71
+  metadata.gz: c0273782e0e3f462f7ee7ae2869fce0a73096616ac3f84069f4cd78503e0700ac34e549eca1aff8c3617fca22d4af9e754bd81f946d79b553edcdf52f653ca3d
+  data.tar.gz: 5ba775d04996966b8ce6a6406e722db27ef9d7c040ea4fb1ed6ef58960e53540487ebaccbcae7a6ec8e26e0a77c0c987d02521105b2640ed6ba19fd140e8417c

data/.erb_linters

@@ -0,0 +1 @@
+linters/erb_lint

data/bin/immosquare-cleaner

@@ -29,7 +29,7 @@ OptionParser.new do |parser|
   parser.banner = "Usage: immosquare-cleaner [options] file"
 
   parser.on("-h", "--help", "Prints this help") do
-    puts parser
+    puts(parser)
     exit
   end
 end.parse!

data/lib/immosquare-cleaner/configuration.rb

@@ -1,7 +1,7 @@
 module ImmosquareCleaner
   class Configuration
 
-    attr_accessor :rubocop_options, :htmlbeautifier_options, :erblint_options, :exclude_files
+    attr_accessor(:rubocop_options, :htmlbeautifier_options, :erblint_options, :exclude_files)
 
     def initialize
       @rubocop_options        = nil

data/lib/immosquare-cleaner/railtie.rb

@@ -2,7 +2,7 @@ module ImmosquareCleaner
   class Railtie < Rails::Railtie
 
     rake_tasks do
-      load "tasks/immosquare_cleaner.rake"
+      load("tasks/immosquare_cleaner.rake")
     end
 
   end

data/lib/immosquare-cleaner/version.rb

@@ -1,3 +1,3 @@
 module ImmosquareCleaner
-  VERSION = "0.1.79".freeze
+  VERSION = "0.1.81".freeze
 end

data/lib/immosquare-cleaner.rb

@@ -9,10 +9,17 @@ require_relative "immosquare-cleaner/markdown"
 require_relative "immosquare-cleaner/railtie" if defined?(Rails)
 
 ##============================================================##
-## Importing the 'English' library allows us to use more human-readable
+## note 1 : Importing the 'English' library allows us to use more human-readable
 ## global variables, such as $INPUT_RECORD_SEPARATOR instead of $/,
 ## which enhances code clarity and makes it easier to understand
 ## the purpose of these variables in our code.
+## ---------
+## note 2 :
+## Custom erb_lint linters are stored in this folder.
+## A symlink .erb_linters -> linters/erb_lint is required at the
+## gem root because erb_lint hardcodes the custom linters directory
+## to ".erb_linters" and this cannot be configured.
+## See: https://github.com/Shopify/erb_lint/blob/main/lib/erb_lint/linter_registry.rb#L7
 ##============================================================##
 module ImmosquareCleaner
   class << self
@@ -46,7 +53,7 @@ module ImmosquareCleaner
     ##============================================================##
     ## Gem configuration
     ##============================================================##
-    attr_writer :configuration
+    attr_writer(:configuration)
 
     def configuration
       @configuration ||= Configuration.new

data/lib/tasks/immosquare_cleaner.rake

@@ -24,10 +24,10 @@ namespace :immosquare_cleaner do
       File.directory?(file_path) || file_path.gsub("#{Rails.root}/", "").start_with?(*paths_to_exclude) || file_path.end_with?(*extensions_to_exclude)
     end
 
-    puts "Cleaning files..."
+    puts("Cleaning files...")
 
     file_paths.each.with_index do |file_path, index|
-      puts "#{index + 1}/#{file_paths.size} - #{file_path}"
+      puts("#{index + 1}/#{file_paths.size} - #{file_path}")
       ImmosquareCleaner.clean(file_path)
     end
   end

data/linters/erb-lint-3.4.1.yml

@@ -5,6 +5,10 @@ linters:
     enabled: false
   SpaceInHtmlTag:
     enabled: false
+  CustomSingleLineIfModifier:
+    enabled: true
+  CustomHtmlToContentTag:
+    enabled: true
   Rubocop:
     enabled: true
     rubocop_config:

data/linters/erb-lint.yml

@@ -4,6 +4,10 @@ linters:
     enabled: false
   SpaceInHtmlTag:
     enabled: false
+  CustomSingleLineIfModifier:
+    enabled: true
+  CustomHtmlToContentTag:
+    enabled: true
   Rubocop:
     enabled: true
     rubocop_config:

data/linters/erb_lint/custom_html_to_content_tag.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module ERBLint
+  module Linters
+    ##============================================================##
+    ## This linter detects HTML tags containing only a single ERB
+    ## output statement and converts them to content_tag helpers.
+    ##
+    ## @example
+    ##   # bad
+    ##   <div class="card-title"><%= t("app.title") %></div>
+    ##
+    ##   # good
+    ##   <%= content_tag(:div, t("app.title"), :class => "card-title") %>
+    ##
+    ##============================================================##
+    class CustomHtmlToContentTag < Linter
+      include LinterRegistry
+
+      MSG = "Use content_tag helper instead of HTML tag with ERB output."
+
+      ##============================================================##
+      ## Void elements that cannot have content (self-closing tags)
+      ##============================================================##
+      VOID_ELEMENTS = %w[
+        area base br col command embed hr img input keygen
+        link menuitem meta param source track wbr
+      ].freeze
+
+      def run(processed_source)
+        document = processed_source.ast
+        children = document.children.to_a
+
+        children.each_with_index do |child, index|
+          ##============================================================##
+          ## Look for opening tag (not closing, not void element)
+          ##============================================================##
+          next unless child&.type == :tag
+          next if closing_tag?(child)
+
+          tag_name = extract_tag_name(child)
+          next if tag_name.nil?
+          next if VOID_ELEMENTS.include?(tag_name.downcase)
+
+          ##============================================================##
+          ## Check if next child is text containing only ERB output
+          ##============================================================##
+          next_child = children[index + 1]
+          next unless next_child&.type == :text
+
+          erb_node = extract_single_erb_output(next_child)
+          next unless erb_node
+
+          ##============================================================##
+          ## Check if next-next child is the closing tag
+          ##============================================================##
+          closing_child = children[index + 2]
+          next unless closing_child&.type == :tag
+          next unless closing_tag?(closing_child)
+          next unless extract_tag_name(closing_child) == tag_name
+
+          ##============================================================##
+          ## Build the content_tag replacement
+          ##============================================================##
+          attributes = extract_attributes(child)
+          erb_code = extract_erb_code(erb_node)
+
+          new_code = build_content_tag(tag_name, erb_code, attributes)
+
+          ##============================================================##
+          ## Calculate the full range from opening to closing tag
+          ##============================================================##
+          full_range = processed_source.to_source_range(
+            child.loc.begin_pos...closing_child.loc.end_pos
+          )
+
+          add_offense(full_range, MSG, {:new_code => new_code})
+        end
+      end
+
+      def autocorrect(_processed_source, offense)
+        lambda do |corrector|
+          corrector.replace(offense.source_range, offense.context[:new_code])
+        end
+      end
+
+      private
+
+      ##============================================================##
+      ## Check if tag is a closing tag (has solidus as first child)
+      ##============================================================##
+      def closing_tag?(tag_node)
+        tag_node.children.first&.type == :solidus
+      end
+
+      ##============================================================##
+      ## Extract tag name from tag node
+      ##============================================================##
+      def extract_tag_name(tag_node)
+        name_node = tag_node.children.find {|c| c&.type == :tag_name }
+        name_node&.children&.first
+      end
+
+      ##============================================================##
+      ## Extract single ERB output node from text node
+      ## Returns nil if text contains anything other than whitespace
+      ## and a single ERB output
+      ##============================================================##
+      def extract_single_erb_output(text_node)
+        erb_nodes = []
+        has_non_whitespace_text = false
+
+        text_node.children.each do |child|
+          if child.is_a?(String)
+            has_non_whitespace_text = true unless child.match?(/\A\s*\z/)
+          elsif child&.type == :erb
+            erb_nodes << child
+          end
+        end
+
+        return nil if has_non_whitespace_text
+        return nil if erb_nodes.size != 1
+
+        erb_node = erb_nodes.first
+        ##============================================================##
+        ## Must be output ERB (<%= ... %>) not statement (<% ... %>)
+        ##============================================================##
+        indicator = erb_node.children.first
+        return nil unless indicator&.type == :indicator
+        return nil unless indicator.children.first == "="
+
+        erb_node
+      end
+
+      ##============================================================##
+      ## Extract Ruby code from ERB node
+      ##============================================================##
+      def extract_erb_code(erb_node)
+        code_node = erb_node.children.find {|c| c&.type == :code }
+        code_node&.loc&.source&.strip
+      end
+
+      ##============================================================##
+      ## Extract attributes from tag node as hash
+      ##============================================================##
+      def extract_attributes(tag_node)
+        attrs = {}
+        attrs_node = tag_node.children.find {|c| c&.type == :tag_attributes }
+        return attrs unless attrs_node
+
+        attrs_node.children.each do |attr|
+          next unless attr&.type == :attribute
+
+          name_node = attr.children.find {|c| c&.type == :attribute_name }
+          value_node = attr.children.find {|c| c&.type == :attribute_value }
+
+          name = name_node&.children&.first
+          next unless name
+
+          ##============================================================##
+          ## Value can be a string or contain ERB
+          ##============================================================##
+          value = extract_attribute_value(value_node)
+          attrs[name] = value
+        end
+
+        attrs
+      end
+
+      ##============================================================##
+      ## Extract attribute value, handling both static and ERB values
+      ##============================================================##
+      def extract_attribute_value(value_node)
+        return nil unless value_node
+
+        parts = []
+        value_node.children.each do |child|
+          if child.is_a?(String)
+            parts << child
+          elsif child.respond_to?(:type)
+            next if child.type == :quote
+
+            if child.type == :erb
+              erb_code = extract_erb_code(child)
+              parts << "\#{#{erb_code}}"
+            end
+          end
+        end
+
+        parts.join
+      end
+
+      ##============================================================##
+      ## Build content_tag call
+      ##============================================================##
+      def build_content_tag(tag_name, content, attributes)
+        if attributes.empty?
+          "<%= content_tag(:#{tag_name}, #{content}) %>"
+        else
+          attrs_str = attributes.map do |name, value|
+            key = normalize_attribute_name(name)
+            ##============================================================##
+            ## Check if value contains interpolation
+            ##============================================================##
+            if value&.include?('#{')
+              "#{key} => \"#{value}\""
+            else
+              "#{key} => \"#{value}\""
+            end
+          end.join(", ")
+
+          "<%= content_tag(:#{tag_name}, #{content}, #{attrs_str}) %>"
+        end
+      end
+
+      ##============================================================##
+      ## Normalize attribute name to Ruby symbol format
+      ## class -> :class, data-value -> :\"data-value\" or data: { value: }
+      ##============================================================##
+      def normalize_attribute_name(name)
+        if name.match?(/\A[a-z_][a-z0-9_]*\z/i)
+          ":#{name}"
+        else
+          ":\"#{name}\""
+        end
+      end
+    end
+  end
+end

data/linters/erb_lint/custom_single_line_if_modifier.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module ERBLint
+  module Linters
+    ##============================================================##
+    ## This linter detects if/unless blocks with a single ERB output
+    ## statement and converts them to inline modifier syntax.
+    ##
+    ## @example
+    ## bad
+    ##   <% if condition %>
+    ##     <%= link_to("Home", root_path) %>
+    ##   <% end %>
+    ##
+    ## good
+    ##   <%= link_to("Home", root_path) if condition %>
+    ##
+    ##============================================================##
+    class CustomSingleLineIfModifier < Linter
+
+      include LinterRegistry
+
+      MSG = "Use modifier if/unless for single-line ERB output."
+
+      def run(processed_source)
+        erb_nodes = processed_source.ast.descendants(:erb).to_a
+        return if erb_nodes.size < 3
+
+        erb_nodes.each_with_index do |erb_node, index|
+          ##============================================================##
+          ## We need at least 3 consecutive ERB nodes:
+          ## 1. <% if/unless condition %>
+          ## 2. <%= output %>
+          ## 3. <% end %>
+          ##============================================================##
+          next if index + 2 >= erb_nodes.size
+
+          if_node     = erb_node
+          output_node = erb_nodes[index + 1]
+          end_node    = erb_nodes[index + 2]
+
+          ##============================================================##
+          ## Check if this is a valid pattern to transform
+          ##============================================================##
+          next unless valid_if_modifier_pattern?(if_node, output_node, end_node, processed_source)
+
+          ##============================================================##
+          ## Extract the condition and output code
+          ##============================================================##
+          if_code     = extract_code(if_node)
+          output_code = extract_code(output_node)
+
+          condition_match = if_code.match(/\A\s*(if|unless)\s+(.+)\s*\z/m)
+          next unless condition_match
+
+          keyword   = condition_match[1]
+          condition = condition_match[2].strip
+
+          ##============================================================##
+          ## Build the new inline syntax
+          ##============================================================##
+          new_code = "#{output_code.strip} #{keyword} #{condition}"
+
+          ##============================================================##
+          ## Calculate the full range from if to end (inclusive)
+          ##============================================================##
+          full_range = processed_source.to_source_range(
+            if_node.loc.begin_pos...end_node.loc.end_pos
+          )
+
+          ##============================================================##
+          ## Store context for autocorrect
+          ##============================================================##
+          context = {
+            :new_code       => "<%= #{new_code} %>",
+            :output_node    => output_node,
+            :is_output_node => is_output_erb?(output_node)
+          }
+
+          add_offense(full_range, MSG, context)
+        end
+      end
+
+      def autocorrect(_processed_source, offense)
+        lambda do |corrector|
+          corrector.replace(offense.source_range, offense.context[:new_code])
+        end
+      end
+
+      private
+
+      ##============================================================##
+      ## Check if this is a valid pattern:
+      ## - First node is <% if/unless condition %>
+      ## - Second node is <%= output %> (output ERB)
+      ## - Third node is <% end %>
+      ## - No other ERB nodes between them
+      ##============================================================##
+      def valid_if_modifier_pattern?(if_node, output_node, end_node, processed_source)
+        ##============================================================##
+        ## Check indicators: if_node should be <% (not <%=)
+        ## output_node should be <%= (output)
+        ## end_node should be <% (not <%=)
+        ##============================================================##
+        return false unless is_statement_erb?(if_node)
+        return false unless is_output_erb?(output_node)
+        return false unless is_statement_erb?(end_node)
+
+        ##============================================================##
+        ## Extract and validate the code
+        ##============================================================##
+        if_code     = extract_code(if_node)
+        output_code = extract_code(output_node)
+        end_code    = extract_code(end_node)
+
+        return false unless if_code&.match?(/\A\s*(if|unless)\s+.+\z/m)
+        return false unless end_code&.strip == "end"
+        return false if output_code.to_s.strip.empty?
+
+        ##============================================================##
+        ## Check that there's only whitespace/newlines between the nodes
+        ## (no other HTML content or ERB nodes)
+        ##============================================================##
+        between_if_and_output = source_between(processed_source, if_node, output_node)
+        between_output_and_end = source_between(processed_source, output_node, end_node)
+
+        return false unless between_if_and_output&.match?(/\A\s*\z/)
+        return false unless between_output_and_end&.match?(/\A\s*\z/)
+
+        true
+      end
+
+      ##============================================================##
+      ## Check if ERB node is a statement (<% ... %>)
+      ##============================================================##
+      def is_statement_erb?(erb_node)
+        indicator = erb_node.children.first
+        indicator.nil? || (indicator.respond_to?(:children) && indicator.children.first.nil?)
+      end
+
+      ##============================================================##
+      ## Check if ERB node is an output (<%= ... %>)
+      ##============================================================##
+      def is_output_erb?(erb_node)
+        indicator = erb_node.children.first
+        indicator.respond_to?(:children) && indicator.children.first == "="
+      end
+
+      ##============================================================##
+      ## Extract the Ruby code from an ERB node
+      ##============================================================##
+      def extract_code(erb_node)
+        code_node = erb_node.children[2]
+        return nil unless code_node
+
+        code_node.loc.source
+      end
+
+      ##============================================================##
+      ## Get the source text between two nodes
+      ##============================================================##
+      def source_between(processed_source, node1, node2)
+        start_pos = node1.loc.end_pos
+        end_pos   = node2.loc.begin_pos
+        return "" if start_pos >= end_pos
+
+        processed_source.source_buffer.source[start_pos...end_pos]
+      end
+
+    end
+  end
+end

data/linters/rubocop-3.4.1.yml

@@ -96,6 +96,23 @@ Style/RescueModifier:
   Enabled: false
 Style/MethodCallWithArgsParentheses:
   Enabled: true
+  EnforcedStyle: require_parentheses
+  IgnoreMacros: false
+  AllowedMethods:
+  - require
+  - require_relative
+  - include
+  - extend
+  - prepend
+  - raise
+  - fail
+  - gem
+  - source
+  - ruby
+  - desc
+  - task
+  - namespace
+  - yield
 CustomCops/Style/CommentNormalization:
   Enabled: true
 CustomCops/Style/FontAwesomeNormalization:

data/linters/rubocop.yml

@@ -108,6 +108,23 @@ Style/RescueModifier:
 #################### OVERWRITE ###########################
 Style/MethodCallWithArgsParentheses:
   Enabled: true # On veut forcer les parenthèses où elles sont utilises pour rendre le code plus propre
+  EnforcedStyle: require_parentheses
+  IgnoreMacros: false
+  AllowedMethods:
+    - require
+    - require_relative
+    - include
+    - extend
+    - prepend
+    - raise
+    - fail
+    - gem
+    - source
+    - ruby
+    - desc
+    - task
+    - namespace
+    - yield
 
 #################### CUSTOMS ###########################
 CustomCops/Style/CommentNormalization:

data/package.json

@@ -2,16 +2,16 @@
   "name":         "immosquare-cleaner",
   "private":      true,
   "dependencies": {
-    "@eslint/js":                       "^9.36.0",
-    "@typescript-eslint/eslint-plugin": "^8.45.0",
-    "@typescript-eslint/parser":        "^8.45.0",
-    "eslint":                           "^9.36.0",
+    "@eslint/js":                       "^9.39.1",
+    "@typescript-eslint/eslint-plugin": "^8.48.1",
+    "@typescript-eslint/parser":        "^8.48.1",
+    "eslint":                           "^9.39.1",
     "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.5",
-    "prettier":                         "^3.6.2",
-    "typescript":                       "^5.9.2"
+    "prettier":                         "^3.7.4",
+    "typescript":                       "^5.9.3"
   }
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: immosquare-cleaner
 version: !ruby/object:Gem::Version
-  version: 0.1.79
+  version: 0.1.81
 platform: ruby
 authors:
 - immosquare
@@ -139,6 +139,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".erb_linters"
 - bin/immosquare-cleaner
 - lib/immosquare-cleaner.rb
 - lib/immosquare-cleaner/configuration.rb
@@ -148,6 +149,8 @@ files:
 - lib/tasks/immosquare_cleaner.rake
 - linters/erb-lint-3.4.1.yml
 - linters/erb-lint.yml
+- linters/erb_lint/custom_html_to_content_tag.rb
+- linters/erb_lint/custom_single_line_if_modifier.rb
 - linters/eslint.config.mjs
 - linters/prettier.yml
 - linters/rubocop-3.4.1.yml
@@ -176,7 +179,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 4.0.0
 specification_version: 4
 summary: A gem to lint and organize files in a Rails application.
 test_files: []