yattho_view_components 0.0.1

data/lib/yattho/view_components/linters/argument_mappers/button.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ERBLint
+  module Linters
+    module ArgumentMappers
+      # Maps classes in a button element to arguments for the Button component.
+      class Button < Base
+        SCHEME_MAPPINGS = Yattho::ViewComponents::Constants.get(
+          component: "Yattho::ButtonComponent",
+          constant: "SCHEME_MAPPINGS",
+          symbolize: true
+        ).freeze
+
+        SIZE_MAPPINGS = Yattho::ViewComponents::Constants.get(
+          component: "Yattho::ButtonComponent",
+          constant: "SIZE_MAPPINGS",
+          symbolize: true
+        ).freeze
+
+        TYPE_OPTIONS = Yattho::ViewComponents::Constants.get(
+          component: "Yattho::Beta::BaseButton",
+          constant: "TYPE_OPTIONS"
+        ).freeze
+
+        DEFAULT_TAG = Yattho::ViewComponents::Constants.get(
+          component: "Yattho::Beta::BaseButton",
+          constant: "DEFAULT_TAG"
+        ).freeze
+
+        ATTRIBUTES = %w[disabled type href name value tabindex].freeze
+
+        def attribute_to_args(attribute)
+          attr_name = attribute.name
+
+          case attr_name
+          when "disabled"
+            { disabled: true }
+          when "type"
+            # button is the default type, so we don't need to do anything.
+            return {} if attribute.value == "button"
+
+            unless TYPE_OPTIONS.include?(attribute.value)
+              raise ConversionError,
+                    "Button component does not support type \"#{attribute.value}\""
+            end
+
+            { type: ":#{attribute.value}" }
+          else
+            { attr_name.to_sym => erb_helper.convert(attribute) }
+          end
+        end
+
+        def classes_to_args(classes)
+          classes.each_with_object({ classes: [] }) do |class_name, acc|
+            next if class_name == "btn"
+
+            if SCHEME_MAPPINGS[class_name] && acc[:scheme].nil?
+              acc[:scheme] = SCHEME_MAPPINGS[class_name]
+            elsif SIZE_MAPPINGS[class_name] && acc[:size].nil?
+              acc[:size] = SIZE_MAPPINGS[class_name]
+            elsif class_name == "btn-block"
+              acc[:block] = true
+            elsif class_name == "BtnGroup-item"
+              acc[:group_item] = true
+            else
+              acc[:classes] << class_name
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yattho/view_components/linters/argument_mappers/clipboard_copy.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ERBLint
+  module Linters
+    module ArgumentMappers
+      # Maps attributes in the clipboard-copy element to arguments for the ClipboardCopy component.
+      class ClipboardCopy < Base
+        DEFAULT_TAG = "clipboard-copy"
+        ATTRIBUTES = %w[role tabindex for value id style].freeze
+
+        def attribute_to_args(attribute)
+          attr_name = attribute.name
+
+          { attr_name.to_sym => erb_helper.convert(attribute) }
+        end
+      end
+    end
+  end
+end

data/lib/yattho/view_components/linters/argument_mappers/close_button.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ERBLint
+  module Linters
+    module ArgumentMappers
+      # Maps classes in a close-button element to arguments for the CloseButton component.
+      class CloseButton < Base
+        ATTRIBUTES = %w[type].freeze
+
+        TYPE_OPTIONS = Yattho::ViewComponents::Constants.get(
+          component: "Yattho::Beta::CloseButton",
+          constant: "TYPE_OPTIONS"
+        ).freeze
+
+        DEFAULT_TYPE = Yattho::ViewComponents::Constants.get(
+          component: "Yattho::Beta::CloseButton",
+          constant: "DEFAULT_TYPE"
+        ).freeze
+
+        DEFAULT_CLASS = "close-button"
+
+        def attribute_to_args(attribute)
+          # button is the default type, so we don't need to do anything.
+          return {} if attribute.value == DEFAULT_TYPE
+
+          unless TYPE_OPTIONS.include?(attribute.value)
+            raise ConversionError,
+                  "CloseButton component does not support type \"#{attribute.value}\""
+          end
+
+          { type: ":#{attribute.value}" }
+        end
+
+        def classes_to_args(classes)
+          classes.each_with_object({ classes: [] }) do |class_name, acc|
+            next if class_name == DEFAULT_CLASS
+
+            acc[:classes] << class_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yattho/view_components/linters/argument_mappers/conversion_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ERBLint
+  module Linters
+    module ArgumentMappers
+      # Error when converting arguments.
+      class ConversionError < StandardError; end
+    end
+  end
+end

data/lib/yattho/view_components/linters/argument_mappers/flash.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ERBLint
+  module Linters
+    module ArgumentMappers
+      # Maps classes in a flash element to arguments for the Flash component.
+      class Flash < Base
+        SCHEME_MAPPINGS = {
+          "flash-success" => ":success",
+          "flash-warn" => ":warning",
+          "flash-error" => ":danger"
+        }.freeze
+
+        def classes_to_args(classes)
+          classes.each_with_object({ classes: [] }) do |class_name, acc|
+            next if class_name == "flash"
+
+            if SCHEME_MAPPINGS[class_name] && acc[:scheme].nil?
+              acc[:scheme] = SCHEME_MAPPINGS[class_name]
+            elsif class_name == "flash-full"
+              acc[:full] = true
+            else
+              acc[:classes] << class_name
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yattho/view_components/linters/argument_mappers/helpers/erb_block.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "../conversion_error"
+
+module ERBLint
+  module Linters
+    module ArgumentMappers
+      module Helpers
+        # provides helpers to identify and deal with ERB blocks.
+        class ErbBlock
+          INTERPOLATION_REGEX = /^<%=(?<rb>.*)%>$/.freeze
+
+          def raise_if_erb_block(attribute)
+            raise_error(attribute) if any?(attribute)
+          end
+
+          def convert(attribute)
+            raise_error(attribute) unless interpolation?(attribute)
+
+            if any?(attribute)
+              convert_interpolation(attribute)
+            else
+              attribute.value.to_json
+            end
+          end
+
+          private
+
+          def interpolation?(attribute)
+            erb_blocks(attribute).all? do |erb|
+              # If the blocks does not have an indicator, it's not an interpolation.
+              erb.children.to_a.compact.any? { |node| node.type == :indicator }
+            end
+          end
+
+          def raise_error(attribute)
+            raise ERBLint::Linters::ArgumentMappers::ConversionError,
+                  "Cannot convert attribute \"#{attribute.name}\" because its value contains an erb block"
+          end
+
+          def any?(attribute)
+            erb_blocks(attribute).any?
+          end
+
+          def basic?(attribute)
+            return false if erb_blocks(attribute).size != 1
+
+            attribute.value.match?(INTERPOLATION_REGEX)
+          end
+
+          def erb_blocks(attribute)
+            (attribute.value_node&.children || []).select { |n| n.try(:type) == :erb }
+          end
+
+          def convert_interpolation(attribute)
+            if basic?(attribute)
+              m = attribute.value.match(INTERPOLATION_REGEX)
+              return m[:rb].strip
+            end
+
+            # we use `source` instead of `value` because it does not convert encoded HTML entities.
+            attribute.value_node.loc.source.gsub("<%=", '#{').gsub("%>", "}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yattho/view_components/linters/argument_mappers/label.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ERBLint
+  module Linters
+    module ArgumentMappers
+      # Maps classes in a label element to arguments for the Label component.
+      class Label < Base
+        SCHEME_MAPPINGS = Yattho::ViewComponents::Constants.get(
+          component: "Yattho::Beta::Label",
+          constant: "SCHEME_MAPPINGS",
+          symbolize: true
+        ).freeze
+
+        SIZE_MAPPINGS = Yattho::ViewComponents::Constants.get(
+          component: "Yattho::Beta::Label",
+          constant: "SIZE_MAPPINGS",
+          symbolize: true
+        ).freeze
+
+        DEFAULT_TAG = Yattho::ViewComponents::Constants.get(
+          component: "Yattho::Beta::Label",
+          constant: "DEFAULT_TAG"
+        ).freeze
+
+        INLINE_CLASS = Yattho::ViewComponents::Constants.get(
+          component: "Yattho::Beta::Label",
+          constant: "INLINE_CLASS"
+        ).freeze
+
+        ATTRIBUTES = %w[title].freeze
+
+        def attribute_to_args(attribute)
+          { title: erb_helper.convert(attribute) }
+        end
+
+        def classes_to_args(classes)
+          classes.each_with_object({ classes: [] }) do |class_name, acc|
+            next if class_name == "Label"
+
+            if SCHEME_MAPPINGS[class_name] && acc[:scheme].nil?
+              acc[:scheme] = SCHEME_MAPPINGS[class_name]
+            elsif SIZE_MAPPINGS[class_name] && acc[:size].nil?
+              acc[:size] = SIZE_MAPPINGS[class_name]
+            elsif class_name == INLINE_CLASS && acc[:inline].nil?
+              acc[:inline] = true
+            else
+              acc[:classes] << class_name
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yattho/view_components/linters/argument_mappers/system_arguments.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "conversion_error"
+require_relative "helpers/erb_block"
+
+module ERBLint
+  module Linters
+    module ArgumentMappers
+      # Maps element attributes to system arguments.
+      class SystemArguments
+        STRING_PARAMETERS = %w[aria- data-].freeze
+        TEST_SELECTOR_REGEX = /test_selector\((?<selector>.+)\)$/.freeze
+
+        attr_reader :attribute, :erb_helper
+
+        def initialize(attribute)
+          @attribute = attribute
+          @erb_helper = Helpers::ErbBlock.new
+        end
+
+        def to_args
+          if attribute.erb?
+            _, _, code_node = *attribute.node
+
+            raise ConversionError, "Cannot convert erb block" if code_node.nil?
+
+            code = code_node.loc.source.strip
+            m = code.match(TEST_SELECTOR_REGEX)
+
+            raise ConversionError, "Cannot convert erb block" if m.blank?
+
+            { test_selector: m[:selector].tr("'", '"') }
+          elsif attr_name == "data-test-selector"
+            { test_selector: erb_helper.convert(attribute) }
+          elsif attr_name.start_with?(*STRING_PARAMETERS)
+            { "\"#{attr_name}\"" => erb_helper.convert(attribute) }
+          else
+            raise ConversionError, "Cannot convert attribute \"#{attr_name}\""
+          end
+        end
+
+        def attr_name
+          attribute.name
+        end
+      end
+    end
+  end
+end

data/lib/yattho/view_components/linters/autocorrectable.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "argument_mappers/conversion_error"
+
+module ERBLint
+  module Linters
+    # Provides the autocorrection functionality for the linter. Once included, you should define the following constants:
+    # * `ARGUMENT_MAPPER` - required - The class responsible for transforming classes and attributes into arguments for the component.
+    # * `COMPONENT` - required - The component name for the linter. It will be used to generate the correction.
+    module Autocorrectable
+      def map_arguments(tag, _tag_tree)
+        self.class::ARGUMENT_MAPPER.new(tag).to_s
+      rescue ArgumentMappers::ConversionError
+        nil
+      end
+
+      def correction(args)
+        return nil if args.nil?
+
+        correction = "<%= render #{self.class::COMPONENT}.new"
+        correction += "(#{args})" if args.present?
+        "#{correction} do %>"
+      end
+
+      def message(args, processed_source)
+        return self.class::MESSAGE if args.nil?
+
+        "#{self.class::MESSAGE}\nTry using:\n\n#{correction(args)}\n\nYou can also run erblint in autocorrect mode:\n\nbundle exec erblint -a #{processed_source.filename}\n"
+      end
+    end
+  end
+end

data/lib/yattho/view_components/linters/base_linter.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require "json"
+require "openssl"
+require "yattho/view_components/constants"
+
+require_relative "tag_tree_helpers"
+
+# :nocov:
+
+module ERBLint
+  module Linters
+    # Provides the basic linter logic. When inherited, you should define:
+    # * `TAGS` - required - The HTML tags that the component supports. It will be used by the linter to match elements.
+    # * `MESSAGE` - required - The message shown when there's an offense.
+    # * `CLASSES` - optional - The CSS classes that the component needs. The linter will only match elements with one of those classes.
+    # * `REQUIRED_ARGUMENTS` - optional - A list of HTML attributes that are required by the component.
+    class BaseLinter < Linter
+      include TagTreeHelpers
+
+      DUMP_FILE = ".erblint-counter-ignore.json"
+      DISALLOWED_CLASSES = [].freeze
+      CLASSES = [].freeze
+      REQUIRED_ARGUMENTS = [].freeze
+
+      class ConfigSchema < LinterConfig
+        property :override_ignores_if_correctable, accepts: [true, false], default: false,
+                                                   reader: :override_ignores_if_correctable?
+      end
+
+      def self.inherited(base)
+        super
+        base.include(ERBLint::LinterRegistry)
+        base.config_schema = ConfigSchema
+      end
+
+      def run(processed_source)
+        @total_offenses = 0
+        @offenses_not_corrected = 0
+        (tags, tag_tree) = build_tag_tree(processed_source)
+
+        tags.each do |tag|
+          next if tag.closing?
+          next unless self.class::TAGS&.include?(tag.name)
+
+          classes = tag.attributes["class"]&.value&.split(" ") || []
+          tag_tree[tag][:offense] = false
+
+          next if (classes & self.class::DISALLOWED_CLASSES).any?
+          next unless self.class::CLASSES.blank? || (classes & self.class::CLASSES).any?
+
+          args = map_arguments(tag, tag_tree[tag])
+          correction = correction(args)
+
+          attributes = tag.attributes.each.map(&:name).join(" ")
+          matches_required_attributes = self.class::REQUIRED_ARGUMENTS.blank? || self.class::REQUIRED_ARGUMENTS.all? do |arg|
+            attributes.match?(arg)
+          end
+
+          tag_tree[tag][:offense] = true
+          tag_tree[tag][:correctable] = matches_required_attributes && !correction.nil?
+          tag_tree[tag][:message] = message(args, processed_source)
+          tag_tree[tag][:correction] = correction
+        end
+
+        tag_tree.each do |tag, h|
+          next unless h[:offense]
+
+          @total_offenses += 1
+          # We always fix the offenses using blocks. The closing tag corresponds to `<% end %>`.
+          if h[:correctable]
+            add_correction(tag, h)
+          else
+            @offenses_not_corrected += 1
+            generate_offense(self.class, processed_source, tag, h[:message])
+          end
+        end
+
+        counter_correct?(processed_source)
+
+        dump_data(processed_source) if ENV["DUMP_LINT_DATA"] == "1"
+      end
+
+      def autocorrect(processed_source, offense)
+        return unless offense.context
+
+        lambda do |corrector|
+          if offense.context.include?(counter_disable)
+            correct_counter(corrector, processed_source, offense)
+          else
+            corrector.replace(offense.source_range, offense.context)
+          end
+        end
+      end
+
+      private
+
+      def add_correction(tag, tag_tree)
+        add_offense(tag.loc, tag_tree[:message], tag_tree[:correction])
+        add_offense(tag_tree[:closing].loc, tag_tree[:message], "<% end %>")
+      end
+
+      # Override this function to convert the HTML element attributes to argument for a component.
+      #
+      # @return [Hash] if possible to map all attributes to arguments.
+      # @return [Nil] if cannot map to arguments.
+      def map_arguments(_tag, _tag_tree)
+        nil
+      end
+
+      # Override this function to define how to autocorrect an element to a component.
+      #
+      # @return [String] with the text to replace the HTML element if possible to correct.
+      # @return [Nil] if cannot correct element.
+      def correction(_tag)
+        nil
+      end
+
+      # Override this function to customize the linter message.
+      #
+      # @return [String] message to show on linter error.
+      def message(_tag, _processed_source)
+        self.class::MESSAGE
+      end
+
+      def counter_disable
+        "erblint:counter #{self.class.name.demodulize}"
+      end
+
+      def correct_counter(corrector, processed_source, offense)
+        if processed_source.file_content.include?(counter_disable)
+          # update the counter if exists
+          corrector.replace(offense.source_range, offense.context)
+        else
+          # add comment with counter if none
+          corrector.insert_before(processed_source.source_buffer.source_range, "#{offense.context}\n")
+        end
+      end
+
+      def tags(processed_source)
+        processed_source.parser.nodes_with_type(:tag).map { |tag_node| BetterHtml::Tree::Tag.from_node(tag_node) }
+      end
+
+      def counter_correct?(processed_source)
+        comment_node = nil
+        expected_count = 0
+        rule_name = self.class.name.match(/:?:?(\w+)\Z/)[1]
+
+        processed_source.parser.ast.descendants(:erb).each do |node|
+          indicator_node, _, code_node, = *node
+          indicator = indicator_node&.loc&.source
+          comment = code_node&.loc&.source&.strip
+
+          if indicator == "#" && comment.start_with?("erblint:count") && comment.match(rule_name)
+            comment_node = node
+            expected_count = comment.match(/\s(\d+)\s?$/)[1].to_i
+          end
+        end
+
+        # Unless explicitly set, we don't want to mark correctable offenses if the counter is correct.
+        if !@config.override_ignores_if_correctable? && expected_count == @total_offenses
+          clear_offenses
+          return
+        end
+
+        if @offenses_not_corrected.zero?
+          # have to adjust to get `\n` so we delete the whole line
+          if comment_node
+            add_offense(processed_source.to_source_range(comment_node.loc.adjust(end_pos: 1)),
+                        "Unused erblint:count comment for #{rule_name}", "")
+          end
+          return
+        end
+
+        first_offense = @offenses[0]
+
+        if comment_node.nil?
+          add_offense(processed_source.to_source_range(first_offense.source_range),
+                      "#{rule_name}: If you must, add <%# erblint:counter #{rule_name} #{@offenses_not_corrected} %> to bypass this check.", "<%# erblint:counter #{rule_name} #{@offenses_not_corrected} %>")
+        elsif expected_count != @offenses_not_corrected
+          add_offense(processed_source.to_source_range(comment_node.loc),
+                      "Incorrect erblint:counter number for #{rule_name}. Expected: #{expected_count}, actual: #{@offenses_not_corrected}.", "<%# erblint:counter #{rule_name} #{@offenses_not_corrected} %>")
+        # the only offenses remaining are not autocorrectable, so we can ignore them
+        elsif expected_count == @offenses_not_corrected && @offenses.size == @offenses_not_corrected
+          clear_offenses
+        end
+      end
+
+      def generate_offense(klass, processed_source, tag, message = nil, replacement = nil)
+        message ||= klass::MESSAGE
+        klass_name = klass.name.demodulize
+        offense = ["#{klass_name}:#{message}", tag.node.loc.source].join("\n")
+        add_offense(processed_source.to_source_range(tag.loc), offense, replacement)
+      end
+
+      def dump_data(processed_source)
+        return if @total_offenses.zero?
+
+        data = File.exist?(DUMP_FILE) ? JSON.parse(File.read(DUMP_FILE)) : {}
+
+        data[processed_source.filename] ||= {}
+        data[processed_source.filename][self.class.name.demodulize] = @total_offenses
+
+        File.write(DUMP_FILE, JSON.pretty_generate(data))
+      end
+    end
+  end
+end