gl_rubocop 0.2.19 → 0.2.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd4eb564bfaea4ae8ab15506ff2196070f55223989f1ac9504f281913a55dd6c
-  data.tar.gz: 931bb25c4f11632bacfada61d5cf99306dbfddf1d4ba056f9ee773f86a876e6c
+  metadata.gz: e5cfeeb9c783874509854ab8f98e6c8f1d17284f81e16193666d99e49b2a7d0b
+  data.tar.gz: 295a40eae88db48e09a7a03026e89744f511d57748e0591565f0767e3ab80257
 SHA512:
-  metadata.gz: 1db06adef9f18338c30d02177c993ef7c7978f4563683ac821c933f824170476f0088b90cc29ce87629d6b0d5bf76e335cacb8662d25a6583de074e5f92de18b
-  data.tar.gz: d2631001ed66f5f91ede31f60387f07edf95bb297cd999e2b2528b29b79c215c75bfa0c79771804505b25b3ccfc457c54b8a42f35cc615f5af9d621e8769b86e
+  metadata.gz: 8344a4c809b323cdcc4c4a7d15441aa08346a8a6964237d4efc1e9fc9895293e098960d60268e74274720cc5f56c0472aea24b30c75abc8bbcad93b0b48e79f7
+  data.tar.gz: 496e86ca9704c2329455f7f001dbd8fe89405dda81b23a9b6a0067b6d0760f9b49d202e4db532d97626673508ab8814a53f0d0dce5b0a6dd2fe4ece5ca85d930

data/default.yml

@@ -15,6 +15,7 @@ require:
   - ./lib/gl_rubocop/gl_cops/rails_cache.rb
   - ./lib/gl_rubocop/gl_cops/sidekiq_inherits_from_sidekiq_job.rb
   - ./lib/gl_rubocop/gl_cops/unique_identifier.rb
+  - ./lib/gl_rubocop/gl_cops/tailwind_no_contradicting_class_name.rb
 
 AllCops:
   SuggestExtensions: false

data/lib/gl_rubocop/gl_cops/tailwind_no_contradicting_class_name.rb

@@ -0,0 +1,423 @@
+# frozen_string_literal: true
+
+require_relative '../helpers/haml_content_helper'
+require_relative '../helpers/erb_content_helper'
+
+module GLRubocop
+  module GLCops
+    # Cop to detect contradicting Tailwind CSS class names
+    #
+    # @example
+    #   # bad
+    #   %div{ class: "tw:w-1 tw:w-2" }
+    #   .tw:h-5.tw:h-6
+    #   %button.tw:w-1.tw:w-2
+    #
+    #
+    #   # good
+    #   %div{ class: "tw:w-1 tw:h-2" }
+    #   tw:h-5
+    #   %button.tw:m-4.tw:p-8
+
+    # rubocop:disable Metrics/ClassLength
+    class TailwindNoContradictingClassName < RuboCop::Cop::Cop
+      include GLRubocop::HamlContentHelper
+      include GLRubocop::ErbContentHelper
+
+      MSG =
+        'Contradicting Tailwind CSS classes found: %<classes>s both affect the same CSS property'
+      GIVELIVELY_TAILWIND_CLASS_PREFIX = 'tw:'
+
+      # Tailwind CSS property groups that should not contradict
+      CONTRADICTION_GROUPS = {
+        width: %w[w],
+        height: %w[h],
+        max_width: %w[max-w],
+        max_height: %w[max-h],
+        min_width: %w[min-w],
+        min_height: %w[min-h],
+        margin_top: %w[m my mt],
+        margin_right: %w[m mx mr],
+        margin_bottom: %w[m my mb],
+        margin_left: %w[m mx ml],
+        padding_top: %w[p py pt],
+        padding_right: %w[p px pr],
+        padding_bottom: %w[p py pb],
+        padding_left: %w[p px pl],
+        display: %w[block hidden flex inline inline-block inline-flex grid inline-grid table],
+        position: %w[static relative absolute fixed sticky],
+        text_align: %w[text-left text-center text-right text-justify],
+        flex_direction: %w[flex-row flex-row-reverse flex-col flex-col-reverse],
+        flex_wrap: %w[flex-nowrap flex-wrap flex-wrap-reverse],
+        justify_content: %w[
+          justify-start justify-end justify-center justify-between justify-around justify-evenly
+        ],
+        align_items: %w[items-start items-end items-center items-baseline items-stretch],
+        place_content: %w[
+          place-content-center place-content-start place-content-end place-content-between
+          place-content-around place-content-evenly
+        ],
+        place_items: %w[
+          place-items-start place-items-end place-items-center place-items-baseline
+          place-items-stretch
+        ],
+        place_self: %w[
+          place-self-auto place-self-start place-self-end place-self-center place-self-stretch
+        ],
+        align_content: %w[
+          content-center content-start content-end content-between content-around content-evenly
+        ],
+        align_self: %w[
+          self-auto self-start self-end self-center self-stretch self-baseline
+        ],
+        justify_items: %w[
+          justify-items-start justify-items-end justify-items-center justify-items-stretch
+        ],
+        justify_self: %w[
+          justify-self-auto justify-self-start justify-self-end justify-self-center
+          justify-self-stretch
+        ],
+        font_size: %w[
+          text-xs text-sm text-base text-lg text-xl text-2xl text-3xl text-4xl text-5xl text-6xl
+        ],
+        font_weight: %w[
+          font-thin font-extralight font-light font-normal font-medium font-semibold font-bold
+          font-extrabold font-black
+        ],
+        font_style: %w[italic not-italic],
+        letter_spacing: %w[
+          tracking-tighter tracking-tight tracking-normal tracking-wide tracking-wider
+          tracking-widest
+        ],
+        line_height: %w[
+          leading-none leading-tight leading-snug leading-normal leading-relaxed leading-loose
+        ],
+        text_decoration_line: %w[underline line-through no-underline],
+        text_transform: %w[uppercase lowercase capitalize normal-case],
+        text_decoration_style: %w[
+          decoration-solid decoration-dashed decoration-dotted decoration-double decoration-wavy
+        ],
+        text_wrap: %w[break-normal break-words break-all],
+        vertical_align: %w[
+          align-baseline align-top align-middle align-bottom align-text-top align-text-bottom
+        ],
+        text_overflow: %w[truncate overflow-ellipsis overflow-clip],
+        overflow: %w[
+          overflow-auto overflow-hidden overflow-visible overflow-scroll
+        ],
+        visibility: %w[visible invisible collapse],
+        border_style: %w[
+          border-solid border-dashed border-dotted border-double border-none
+        ],
+        box_shadow: %w[
+          shadow-sm shadow shadow-md shadow-lg shadow-xl shadow-2xl shadow-inner shadow-none
+        ]
+        # Add more property groups as needed, currently we have chosen to omit color-related properties and border-radius classes
+        # to reduce false positives in common use cases.
+      }.freeze
+
+      BREAKPOINT_ORDER = %w[sm md lg xl 2xl].freeze
+
+      def on_send(node)
+        return unless render_method?(node)
+
+        if haml_file?
+          haml_content = read_haml_file
+          return unless haml_content
+
+          check_haml_content(haml_content, node)
+        elsif erb_file?
+          erb_content = read_erb_file
+          return unless erb_content
+
+          check_erb_content(erb_content, node)
+        end
+      end
+
+      def on_str(node)
+        # Check string literals for Tailwind classes
+        check_string_for_tailwind_classes(node)
+      end
+
+      private
+
+      def render_method?(node)
+        node.method_name == :render && node.arguments.any?
+      end
+
+      def check_erb_content(content, node)
+        classes = extract_all_erb_classes(content)
+        contradicting_classes = find_contradicting_classes(classes)
+
+        return if contradicting_classes.empty?
+
+        contradicting_classes.each do |group|
+          add_offense(
+            node,
+            message: format(MSG, classes: group.join(', '))
+          )
+        end
+      end
+
+      def extract_all_erb_classes(content)
+        classes = []
+        classes.concat(extract_classes_from_html_attributes(content))
+        classes.concat(extract_classes_from_rails_hash(content))
+        classes.concat(extract_classes_from_rails_symbol_hash(content))
+        classes.select { |class_name| tailwind_class?(class_name) }
+      end
+
+      def extract_classes_from_html_attributes(content)
+        # Example: <div class="tw:w-1 tw:w-2"></div>
+        content.scan(/class\s*=\s*['"]([^'"]+)['"]/).flat_map { |match| match.first.split(/\s+/) }
+      end
+
+      def extract_classes_from_rails_hash(content)
+        # Example: <%= radio_button_tag { class: 'tw:w-1 tw:w-2' } %>
+        content.scan(/class:\s*['"]([^'"]+)['"]/).flat_map { |match| match.first.split(/\s+/) }
+      end
+
+      def extract_classes_from_rails_symbol_hash(content)
+        # Example: <%= text_field_tag( ..., :class => 'tw:w-1 tw:w-2' ) %>
+        content.scan(/:class\s*=>\s*['"]([^'"]+)['"]/).flat_map { |match| match.first.split(/\s+/) }
+      end
+
+      def check_haml_content(content, node)
+        classes = extract_all_haml_classes(content)
+        contradicting_classes = find_contradicting_classes(classes)
+
+        return if contradicting_classes.empty?
+
+        contradicting_classes.each do |group|
+          add_offense(
+            node,
+            message: format(MSG, classes: group.join(', '))
+          )
+        end
+      end
+
+      def check_string_for_tailwind_classes(node)
+        return unless node.str_type?
+
+        content = node.value
+        classes = extract_classes_from_string(content)
+        contradicting_classes = find_contradicting_classes(classes)
+
+        return if contradicting_classes.empty?
+
+        contradicting_classes.each do |group|
+          add_offense(
+            node,
+            message: format(MSG, classes: group.join(', '))
+          )
+        end
+      end
+
+      def extract_classes_from_string(content)
+        # Split by whitespace and filter for Tailwind classes
+        content.split(/\s+/).select { |cls| tailwind_class?(cls) }
+      end
+
+      def extract_all_haml_classes(content)
+        classes = []
+
+        # Extract from HAML class shortcuts (e.g., %div.tw:w-1.tw:w-2)
+        content.scan(/^[^#]*%\w+(?:\.[^{\s#]+)+/m) do |match|
+          class_shortcuts = match.scan(/\.([^.{\s#]+)/).flatten
+          classes.concat(class_shortcuts)
+        end
+
+        # Extract from HAML hash syntax (e.g., %div{ class: 'tw:m-4 tw:m-8' })
+        content.scan(/class:\s*['"]([^'"]+)['"]/) do |match|
+          class_list = match.first.split(/\s+/)
+          classes.concat(class_list)
+        end
+
+        classes.select { |class_name| tailwind_class?(class_name) }
+      end
+
+      def tailwind_class?(class_name)
+        class_name.start_with?(GIVELIVELY_TAILWIND_CLASS_PREFIX)
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def find_contradicting_classes(classes)
+        # Remove the 'tw:' prefix for property matching
+        normalized_classes = classes.map { |class_name| class_name.sub(matcher, '') }
+
+        contradictions = []
+
+        normalized_classes.each_with_index do |first_class, index|
+          first_class_data = extract_class_data(first_class)
+          next unless valid_property?(first_class_data[:css_property])
+
+          classes_to_compare = normalized_classes[(index + 1)..]
+
+          classes_to_compare.each_with_index do |second_class, j|
+            second_class_data = extract_class_data(second_class)
+            next unless valid_property?(second_class_data[:css_property])
+
+            next unless contradiction_found?(first_class_data, second_class_data)
+
+            original_class = classes[index]
+            contradicting_class = classes[index + j + 1]
+            contradictions << [original_class, contradicting_class]
+          end
+        end
+
+        contradictions
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def contradiction_found?(first_class_data, second_class_data)
+        breakpoint_ranges_overlap?(first_class_data[:breakpoint_range],
+                                   second_class_data[:breakpoint_range]) &&
+          container_queries_overlap?(first_class_data[:container_query],
+                                     second_class_data[:container_query]) &&
+          properties_contradict?(first_class_data[:css_property], second_class_data[:css_property])
+      end
+
+      def extract_class_data(class_name)
+        {
+          css_property: extract_css_property(class_name),
+          breakpoint_range: extract_breakpoint_range(class_name),
+          container_query: extract_container_query(class_name)
+        }
+      end
+
+      # Extracts container query (e.g., @md:) from class name
+      def extract_container_query(class_name)
+        match = class_name.match(/^@([a-zA-Z0-9_-]+):/)
+        match ? match[1] : nil
+      end
+
+      def container_queries_overlap?(first_container, second_container)
+        # If both have a container query, they overlap
+        return true if first_container && second_container
+
+        # If neither has a container query, they overlap (global)
+        return true if first_container.nil? && second_container.nil?
+
+        # If only one has a container query, treat as non-overlapping
+        false
+      end
+
+      def matcher
+        /^#{GIVELIVELY_TAILWIND_CLASS_PREFIX}/o
+      end
+
+      def valid_property?(property)
+        property && CONTRADICTION_GROUPS.any? { |_, group| group.include?(property) }
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def extract_css_property(class_name)
+        # Remove container query prefix (e.g., @md:)
+        class_without_container = class_name.sub(/^@([a-zA-Z0-9_-]+):/, '')
+        # Remove breakpoint prefixes (including v4 range syntax and max-only syntax)
+        class_without_breakpoint = class_without_container.sub(
+          /^(?:(?:sm|md|lg|xl|2xl)(?::max-(?:sm|md|lg|xl|2xl))?:|max-(?:sm|md|lg|xl|2xl):)+/,
+          ''
+        )
+
+        patterns = [
+          /^(w|h)-/,
+          /^(max-w|max-h)-/,
+          /^(min-w|min-h)-/,
+          /^(m[trblxy]?)-/,
+          /^(p[trblxy]?)-/,
+          /^(block|hidden|flex|inline|inline-block|inline-flex|grid|inline-grid|table)$/,
+          /^(static|relative|absolute|fixed|sticky)$/,
+          /^(text-(?:left|center|right|justify))$/,
+          /^(flex-(?:row|row-reverse|col|col-reverse))$/,
+          /^(justify-(?:start|end|center|between|around|evenly))$/,
+          /^(items-(?:start|end|center|baseline|stretch))$/,
+          /^(place-content-(?:center|start|end|between|around|evenly))$/,
+          /^(place-items-(?:start|end|center|baseline|stretch))$/,
+          /^(place-self-(?:auto|start|end|center|stretch))$/,
+          /^(content-(?:center|start|end|between|around|evenly))$/,
+          /^(self-(?:auto|start|end|center|stretch|baseline))$/,
+          /^(justify-items-(?:start|end|center|stretch))$/,
+          /^(justify-self-(?:auto|start|end|center|stretch))$/,
+          /^(text-(?:xs|sm|base|lg|xl|2xl|3xl|4xl|5xl|6xl))$/,
+          /^(font-(?:thin|extralight|light|normal|medium|semibold|bold|extrabold|black))$/,
+          /^(italic|not-italic)$/,
+          /^(tracking-(?:tighter|tight|normal|wide|wider|widest))$/,
+          /^(leading-(?:none|tight|snug|normal|relaxed|loose))$/,
+          /^(underline|line-through|no-underline)$/,
+          /^(uppercase|lowercase|capitalize|normal-case)$/,
+          /^(decoration-(?:solid|dashed|dotted|double|wavy))$/,
+          /^(break-(?:normal|words|all))$/,
+          /^(align-(?:baseline|top|middle|bottom|text-top|text-bottom))$/,
+          /^(truncate|overflow-(?:ellipsis|clip))$/,
+          /^(overflow-(?:auto|hidden|visible|scroll))$/,
+          /^(visible|invisible|collapse)$/,
+          /^(border-(?:solid|dashed|dotted|double|none))$/,
+          /^(shadow(?:-(?:sm|md|lg|xl|2xl|inner|none))?)$/
+        ]
+
+        patterns.each do |pattern|
+          match = class_without_breakpoint.match(pattern)
+          return match[1] if match
+        end
+
+        nil
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def extract_breakpoint_range(class_name)
+        # Extract breakpoint range (e.g., 'md', 'lg:max-xl', 'sm:max-md')
+        # Returns a hash with :min and :max keys, or nil if no breakpoint
+
+        # Match Tailwind v4 range syntax: breakpoint:max-breakpoint: or just breakpoint:
+        range_match = class_name.match(/^(sm|md|lg|xl|2xl)(?::max-(sm|md|lg|xl|2xl))?:/)
+        return nil unless range_match
+
+        min_breakpoint = range_match[1]
+        max_breakpoint = range_match[2]
+
+        {
+          min: min_breakpoint,
+          max: max_breakpoint
+        }
+      end
+
+      def breakpoint_ranges_overlap?(first_range, second_range)
+        # If either range is nil (no breakpoint), they're considered the same (base styles)
+        return true if first_range.nil? && second_range.nil?
+        return false if first_range.nil? || second_range.nil?
+
+        # Get numeric indices for comparison
+        first_min_index = BREAKPOINT_ORDER.index(first_range[:min])
+        first_max_index = max_index(first_range)
+
+        second_min_index = BREAKPOINT_ORDER.index(second_range[:min])
+        second_max_index = max_index(second_range)
+
+        # Check for overlap: ranges overlap if one starts before the other ends
+        !(first_max_index < second_min_index || second_max_index < first_min_index)
+      end
+
+      def max_index(range)
+        return BREAKPOINT_ORDER.index(range[:max]) if range[:max]
+
+        BREAKPOINT_ORDER.length - 1
+      end
+
+      def properties_contradict?(first_prop, second_prop)
+        first_prop_group = CONTRADICTION_GROUPS.select do |_, group|
+          group.include?(first_prop)
+        end.keys
+        second_prop_group = CONTRADICTION_GROUPS.select do |_, group|
+          group.include?(second_prop)
+        end.keys
+
+        return false unless first_prop_group && second_prop_group
+
+        # Check if both properties belong to the same contradicting group
+        first_prop_group.intersect?(second_prop_group)
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/gl_rubocop/helpers/erb_content_helper.rb

@@ -0,0 +1,15 @@
+module GLRubocop
+  module ErbContentHelper
+    def erb_file?
+      processed_source.file_path&.end_with?('.erb', '.html.erb')
+    end
+
+    def read_erb_file
+      return unless processed_source.file_path
+
+      File.read(processed_source.file_path)
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/gl_rubocop/helpers/haml_content_helper.rb

@@ -0,0 +1,14 @@
+module GLRubocop
+  module HamlContentHelper
+    def haml_file?
+      file_path = processed_source.file_path
+      file_path&.end_with?('.html.haml') && File.exist?(file_path)
+    end
+
+    def read_haml_file
+      File.read(processed_source.file_path)
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/gl_rubocop/version.rb

@@ -1,3 +1,3 @@
 module GLRubocop
-  VERSION = '0.2.19'.freeze
+  VERSION = '0.2.20'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gl_rubocop
 version: !ruby/object:Gem::Version
-  version: 0.2.19
+  version: 0.2.20
 platform: ruby
 authors:
 - Give Lively
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-10-30 00:00:00.000000000 Z
+date: 2025-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -155,7 +155,10 @@ files:
 - lib/gl_rubocop/gl_cops/prevent_erb_files.rb
 - lib/gl_rubocop/gl_cops/rails_cache.rb
 - lib/gl_rubocop/gl_cops/sidekiq_inherits_from_sidekiq_job.rb
+- lib/gl_rubocop/gl_cops/tailwind_no_contradicting_class_name.rb
 - lib/gl_rubocop/gl_cops/unique_identifier.rb
+- lib/gl_rubocop/helpers/erb_content_helper.rb
+- lib/gl_rubocop/helpers/haml_content_helper.rb
 - lib/gl_rubocop/version.rb
 homepage: https://github.com/givelively/gl_rubocop
 licenses:
@@ -177,7 +180,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: A shareable configuration of Give Lively's rubocop rules.