immosquare-cleaner 0.1.93 → 0.1.95

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 386d987876b864e4d445826193b67f8ea4bfdf30a292fc08f4271b2ab5eb1c06
-  data.tar.gz: 410548afe07047e7f7cef616f8d766a299f151ea95ee1f072b6d32ac147d3048
+  metadata.gz: ef4743e368013a24d51795c0401fb25551318cf708de34ede70da2463732fb14
+  data.tar.gz: d071271dcda68ef78e8c042217d39ba13f484b8081e120384c7c01b3c8e0deaa
 SHA512:
-  metadata.gz: 219571e479c00ae7575c079b2a504877ea4e3f85176bf0e7d44526684ef43dd68ae12e2b3b78c049a267ffa12dcf03c7925ce1786eba549c835f31cd484d1daf
-  data.tar.gz: 6aed55c5b70fa5116a34c4d49cac06f7aa7639b18d01806026ea0bcc2582db0b9f203fb733cd1ec431b58bc40705d3f51a14b13faa44468e7563997cd5279a0e
+  metadata.gz: 11cda1db31886b571cf81a294798e080eef10e30870adeb23071d37242415d047e0b7916c3c6af0bca855f116c49808a2bd38aeba1744f7e29bd1fbd768a5385
+  data.tar.gz: 2451ad2ef109bf3847a554d7d557bd182e24fae97c7be882e85e8ff1392cffc0a14258f724b2197e386ca6905a51e46c302d2c54d483eea8fc3b5ecd748b5520

data/lib/immosquare-cleaner/version.rb

@@ -1,3 +1,3 @@
 module ImmosquareCleaner
-  VERSION = "0.1.93".freeze
+  VERSION = "0.1.95".freeze
 end

data/lib/immosquare-cleaner.rb

@@ -168,7 +168,7 @@ 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 #{gem_root}/linters/normalize-comments.mjs #{temp_file_path}"
+            cmds << "bun #{gem_root}/linters/normalize-comments.mjs #{temp_file_path}" if !file_path.end_with?(".erb")
             cmds << "bun eslint --config #{gem_root}/linters/eslint.config.mjs #{temp_file_path} --fix"
 
             launch_cmds(cmds)

data/lib/tasks/immosquare_cleaner.rake

@@ -19,8 +19,19 @@ namespace :immosquare_cleaner do
     ]
     extensions_to_exclude = [
       ".lock",
-      ".lockb"
+      ".lockb",
+      ".otf",
+      ".ttf",
+      ".png",
+      ".jpg",
+      ".jpeg",
+      ".gif",
+      ".svg",
+      ".ico",
+      ".webp",
+      ".csv"
     ]
+
     file_paths = Dir.glob("#{Rails.root}/**/*").reject do |file_path|
       File.directory?(file_path) || file_path.gsub("#{Rails.root}/", "").start_with?(*paths_to_exclude) || file_path.end_with?(*extensions_to_exclude)
     end

data/linters/erb_lint/custom_html_to_content_tag.rb

@@ -213,21 +213,31 @@ module ERBLint
       ##============================================================##
       ## Extract single ERB output node from text node
       ## Returns nil if text contains anything other than whitespace
-      ## and a single ERB output
+      ## and a single ERB output. Also rejects if there are nested tags.
       ##============================================================##
       def extract_single_erb_output(text_node)
         erb_nodes = []
         has_non_whitespace_text = false
+        has_nested_tags = 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
+          elsif child.respond_to?(:type)
+            case child.type
+            when :erb
+              erb_nodes << child
+            when :tag
+              ##============================================================##
+              ## If there's any nested tag, don't convert the parent
+              ##============================================================##
+              has_nested_tags = true
+            end
           end
         end
 
         return nil if has_non_whitespace_text
+        return nil if has_nested_tags
         return nil if erb_nodes.size != 1
 
         erb_node = erb_nodes.first
@@ -256,41 +266,37 @@ module ERBLint
       def excluded_method?(erb_code)
         return false unless erb_code
 
-        call_node = extract_call_node(erb_code)
-        return false unless call_node
-
-        method_name = call_node.name.to_s
-        return true if EXCLUDED_METHODS.include?(method_name)
+        result = Prism.parse(erb_code)
+        node = result.value.statements.body.first
 
         ##============================================================##
-        ## If method is a form builder method called on a receiver,
-        ## skip conversion (e.g., f.input, form.text_field, etc.)
+        ## yield is a YieldNode, not a CallNode - always exclude it
+        ## Note: Prism reports yield outside block as syntax error,
+        ## but still creates the node, so check before result.success?
         ##============================================================##
-        return true if call_node.receiver && FORM_BUILDER_METHODS.include?(method_name)
-
-        false
-      end
-
-      ##============================================================##
-      ## Extract the CallNode from Ruby code using Prism parser
-      ## Handles both direct calls and calls with if/unless modifiers
-      ##============================================================##
-      def extract_call_node(erb_code)
-        result = Prism.parse(erb_code)
-        return nil unless result.success?
+        return true if node.is_a?(Prism::YieldNode)
 
-        node = result.value.statements.body.first
+        return false unless result.success?
 
         ##============================================================##
         ## Handle if/unless modifiers: `render(...) if condition`
         ##============================================================##
         node = node.statements&.body&.first if node.is_a?(Prism::IfNode) || node.is_a?(Prism::UnlessNode)
 
-        return nil unless node.is_a?(Prism::CallNode)
+        return false unless node.is_a?(Prism::CallNode)
+
+        method_name = node.name.to_s
+        return true if EXCLUDED_METHODS.include?(method_name)
 
-        node
+        ##============================================================##
+        ## If method is a form builder method called on a receiver,
+        ## skip conversion (e.g., f.input, form.text_field, etc.)
+        ##============================================================##
+        return true if node.receiver && FORM_BUILDER_METHODS.include?(method_name)
+
+        false
       rescue StandardError
-        nil
+        false
       end
 
       ##============================================================##
@@ -322,25 +328,54 @@ module ERBLint
 
       ##============================================================##
       ## Extract attribute value, handling both static and ERB values
+      ## Returns a hash with :type (:static, :dynamic, :erb_only)
+      ## For :dynamic, also includes :parts array for proper escaping
       ##============================================================##
       def extract_attribute_value(value_node)
         return nil unless value_node
 
         parts = []
+        erb_parts = []
+        static_parts = []
+
         value_node.children.each do |child|
           if child.is_a?(String)
-            parts << child
+            parts << {:type => :static, :value => child}
+            static_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}}"
+              parts << {:type => :erb, :value => erb_code}
+              erb_parts << erb_code
             end
           end
         end
 
-        parts.join
+        ##============================================================##
+        ## Determine the attribute value type:
+        ## - :erb_only: Only ERB, no static text (use Ruby directly)
+        ## - :dynamic: Mix of static and ERB (use interpolation)
+        ## - :static: Only static text (use quoted string)
+        ##============================================================##
+        if erb_parts.any? && static_parts.all? {|s| s.match?(/\A\s*\z/) }
+          ##============================================================##
+          ## Pure ERB value: class="<%= expr %>" -> :class => (expr)
+          ##============================================================##
+          {:type => :erb_only, :value => erb_parts.first}
+        elsif erb_parts.any?
+          ##============================================================##
+          ## Mixed value: keep parts separate for proper escaping
+          ## class="foo <%= expr %>" -> :class => "foo #{expr}"
+          ##============================================================##
+          {:type => :dynamic, :parts => parts}
+        else
+          ##============================================================##
+          ## Static value: class="foo" -> :class => "foo"
+          ##============================================================##
+          {:type => :static, :value => static_parts.join}
+        end
       end
 
       ##============================================================##
@@ -367,10 +402,10 @@ module ERBLint
         if attributes.empty?
           base = "content_tag(#{formatted_tag}, #{wrapped_content})"
         else
-          attrs_str = attributes.map do |name, value|
+          attrs_str = attributes.map do |name, attr_data|
             key = normalize_attribute_name(name)
-            quoted_value = quote_attribute_value(value)
-            "#{key} => #{quoted_value}"
+            formatted_value = format_attribute_value(attr_data)
+            "#{key} => #{formatted_value}"
           end.join(", ")
 
           base = "content_tag(#{formatted_tag}, #{wrapped_content}, #{attrs_str})"
@@ -451,27 +486,76 @@ module ERBLint
       end
 
       ##============================================================##
-      ## Quote attribute value for Ruby output
-      ## - Uses double quotes by default
-      ## - Switches to single quotes if value contains double quotes
-      ## - Handles interpolation by keeping double quotes and escaping
+      ## Format attribute value based on its type
+      ## - :erb_only: Pure ERB -> (expr) with parentheses if needed
+      ## - :dynamic: Mixed -> "text #{expr}" with interpolation
+      ## - :static: Pure text -> "value" with proper quoting
       ##============================================================##
-      def quote_attribute_value(value)
-        return '""' if value.nil? || value.empty?
+      def format_attribute_value(attr_data)
+        return '""' if attr_data.nil?
 
-        has_interpolation = value.include?('#{')
-        has_double_quotes = value.include?('"')
+        type = attr_data[:type]
 
-        if has_interpolation
+        case type
+        when :erb_only
           ##============================================================##
-          ## Must use double quotes for interpolation, escape inner quotes
+          ## Pure ERB: wrap in parentheses for safety
+          ## class="<%= x if y %>" -> :class => (x if y)
           ##============================================================##
-          escaped = value.gsub('"', '\\"')
-          "\"#{escaped}\""
-        elsif has_double_quotes
+          value = attr_data[:value]
+          return '""' if value.nil? || value.empty?
+
+          "(#{value})"
+        when :dynamic
           ##============================================================##
-          ## Use single quotes to avoid escaping
+          ## Mixed static and ERB: build string from parts
+          ## Escape quotes only in static parts, not in ERB parts
+          ## class="foo <%= bar %>" -> :class => "foo #{bar}"
+          ##============================================================##
+          parts = attr_data[:parts]
+          return '""' if parts.nil? || parts.empty?
+
+          build_interpolated_string(parts)
+        else
           ##============================================================##
+          ## Static value: simple quoting
+          ##============================================================##
+          value = attr_data[:value]
+          return '""' if value.nil? || value.empty?
+
+          quote_static_string(value)
+        end
+      end
+
+      ##============================================================##
+      ## Build an interpolated string from parts
+      ## Static parts have quotes escaped, ERB parts are wrapped in #{}
+      ##============================================================##
+      def build_interpolated_string(parts)
+        result = parts.map do |part|
+          if part[:type] == :erb
+            ##============================================================##
+            ## ERB part: wrap in interpolation, no escaping needed
+            ##============================================================##
+            "\#{#{part[:value]}}"
+          else
+            ##============================================================##
+            ## Static part: escape double quotes
+            ##============================================================##
+            part[:value].gsub('"', '\\"')
+          end
+        end.join
+
+        "\"#{result}\""
+      end
+
+      ##============================================================##
+      ## Quote a static string value for Ruby output
+      ## - Uses double quotes by default
+      ## - Switches to single quotes if value contains double quotes
+      ##============================================================##
+      def quote_static_string(value)
+        if value.include?('"')
           "'#{value}'"
         else
           "\"#{value}\""
@@ -497,8 +581,10 @@ module ERBLint
         if node.is_a?(Prism::IfNode) || node.is_a?(Prism::UnlessNode)
           ##============================================================##
           ## Only handle modifier form (no else, single statement body)
+          ## Use subsequent for IfNode, else_clause for UnlessNode
           ##============================================================##
-          if node.consequent.nil? && node.statements&.body&.size == 1
+          else_branch = node.is_a?(Prism::IfNode) ? node.subsequent : node.else_clause
+          if else_branch.nil? && node.statements&.body&.size == 1
             keyword = node.is_a?(Prism::IfNode) ? "if" : "unless"
             condition = node.predicate.slice
             content = node.statements.body.first.slice

data/linters/normalize-comments.mjs

@@ -87,6 +87,18 @@ const groupConsecutiveComments = (comments, originalLines) => {
       return
     }
 
+    //============================================================//
+    // Skip Sprockets directives (//= link, //= require, etc.)
+    //============================================================//
+    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)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: immosquare-cleaner
 version: !ruby/object:Gem::Version
-  version: 0.1.93
+  version: 0.1.95
 platform: ruby
 authors:
 - immosquare