yattho_view_components 0.0.1

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/indent"
+require_relative "helpers/rubocop_helpers"
+
+module ERBLint
+  module Linters
+    # Migrates from `Yattho::BlankslateComponent` to `Yattho::Beta::Blankslate`.
+    class BlankslateApiMigration < Linter
+      include ERBLint::LinterRegistry
+      include Helpers::RubocopHelpers
+
+      def run(processed_source)
+        processed_source.ast.descendants(:erb).each do |erb_node|
+          _, _, code_node = *erb_node
+          code = code_node.children.first.strip
+
+          next unless code.include?("Yattho::BlankslateComponent")
+          # Don't fix custom blankslates
+          next if code.end_with?("do", "|")
+
+          line = erb_node.loc.source_line
+          indent = line.split("<%=").first.size
+
+          ast = erb_ast(code)
+          kwargs = ast.arguments.first.arguments.last
+
+          replacement = build_replacement_blankslate(kwargs, indent)
+
+          add_offense(processed_source.to_source_range(erb_node.loc),
+                      "`Yattho::BlankslateComponent` is deprecated. `Yattho::Beta::Blankslate` should be used instead", replacement)
+        end
+      end
+
+      def autocorrect(_, offense)
+        return unless offense.context
+
+        lambda do |corrector|
+          corrector.replace(offense.source_range, offense.context)
+        end
+      end
+
+      private
+
+      def build_blankslate_arguments(kwargs)
+        new_blankslate = {
+          arguments: {},
+          slots: {
+            visual_icon: {},
+            visual_image: {},
+            heading: {
+              tag: ":h2"
+            },
+            description: {},
+            primary_action: {},
+            secondary_action: {}
+          }
+        }
+
+        kwargs&.pairs&.each do |pair|
+          source_value = pair.value.source
+
+          case pair.key.value.to_sym
+          when :title
+            new_blankslate[:slots][:heading][:content] = extract_value(pair.value)
+          when :title_tag
+            new_blankslate[:slots][:heading][:tag] = source_value
+          when :icon
+            new_blankslate[:slots][:visual_icon][:icon] = source_value
+          when :icon_size
+            new_blankslate[:slots][:visual_icon][:size] = source_value
+          when :image_src
+            new_blankslate[:slots][:visual_image][:src] = source_value
+          when :image_alt
+            new_blankslate[:slots][:visual_image][:alt] = source_value
+          when :description
+            new_blankslate[:slots][:description][:content] = extract_value(pair.value)
+          when :button_text
+            new_blankslate[:slots][:primary_action][:content] = extract_value(pair.value)
+          when :button_url
+            new_blankslate[:slots][:primary_action][:href] = source_value
+          when :button_classes
+            new_blankslate[:slots][:primary_action][:classes] = source_value
+          when :link_text
+            new_blankslate[:slots][:secondary_action][:content] = extract_value(pair.value)
+          when :link_url
+            new_blankslate[:slots][:secondary_action][:href] = source_value
+          when :large
+            next # Large does not exist anymore
+          else
+            new_blankslate[:arguments][pair.key.source] = source_value
+          end
+        end
+
+        new_blankslate
+      end
+
+      def build_replacement_blankslate(kwargs, indent)
+        data = build_blankslate_arguments(kwargs)
+        component_args = args_to_s(data[:arguments])
+
+        # If Blankslate has no heading, we don't update it.
+        return if data[:slots][:heading][:content].nil?
+        # If Blankslate sets both image and icon. don't update it.
+        return if data[:slots][:visual_icon].present? && data[:slots][:visual_image].present?
+
+        slots = data[:slots].map do |slot, slot_data|
+          next if slot_data.empty?
+
+          slot_args = args_to_s(slot_data.except(:content))
+          content = slot_data[:content]
+
+          if content
+            <<~HTML.indent(2)
+              <% c.#{slot}#{slot_args} do %>
+                #{content}
+              <% end %>
+            HTML
+          else
+            <<~HTML.indent(2)
+              <% c.#{slot}#{slot_args} %>
+            HTML
+          end
+        end.compact.join("\n").chomp
+
+        # Body needs to match the file indentation.
+        body = <<~HTML.indent(indent).chomp
+          #{slots}
+          <% end %>
+        HTML
+
+        # The render call will always be aligned.
+        "<%= render Yattho::Beta::Blankslate.new#{component_args} do |c| %>\n#{body}"
+      end
+
+      def args_to_s(args)
+        string_args = args.except(:__polymorphic_type).map { |k, v| "#{k}: #{v}" }.join(", ")
+
+        string_args = ":#{args[:__polymorphic_type]}, #{string_args}" if args[:__polymorphic_type]
+
+        return string_args if string_args.blank?
+
+        "(#{string_args})"
+      end
+
+      def extract_value(value)
+        return value.value if value.type == :str
+
+        "<%= #{value.source} %>"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "base_linter"
+
+module ERBLint
+  module Linters
+    # Counts the number of times a HTML Blankslate is used instead of the component.
+    class BlankslateComponentMigrationCounter < BaseLinter
+      MESSAGE = "We are migrating Blankslate to use [Yattho::Beta::Blankslate](https://yattho.com/view-components/components/beta/blankslate), please try to use that instead of raw HTML."
+      CLASSES = %w[blankslate].freeze
+      TAGS = %w[div].freeze
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "base_linter"
+
+module ERBLint
+  module Linters
+    # Counts the number of times a HTML breadcrumbs is used instead of the component.
+    class BreadcrumbsComponentMigrationCounter < BaseLinter
+      MESSAGE = "We are migrating breadcrumbs to use [Yattho::Breadcrumbs](https://yattho.com/view-components/components/beta/breadcrumbs), please try to use that instead of raw HTML."
+      CLASSES = %w[breadcrumb-item breadcrumb-item-selected].freeze
+      TAGS = %w[li].freeze
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "base_linter"
+require_relative "autocorrectable"
+require_relative "argument_mappers/button"
+
+module ERBLint
+  module Linters
+    # Counts the number of times a HTML button is used instead of the component.
+    class ButtonComponentMigrationCounter < BaseLinter
+      include Autocorrectable
+
+      TAGS = Yattho::ViewComponents::Constants.get(
+        component: "Yattho::Beta::BaseButton",
+        constant: "TAG_OPTIONS"
+      ).freeze
+
+      # CloseButton component has preference when this class is seen in conjunction with `btn`.
+      DISALLOWED_CLASSES = %w[close-button].freeze
+      CLASSES = %w[btn btn-link].freeze
+      MESSAGE = "We are migrating buttons to use [Yattho::Beta::Button](https://yattho.com/view-components/components/beta/button), please try to use that instead of raw HTML."
+      ARGUMENT_MAPPER = ArgumentMappers::Button
+      COMPONENT = "Yattho::Beta::Button"
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "base_linter"
+require_relative "autocorrectable"
+require_relative "argument_mappers/clipboard_copy"
+
+module ERBLint
+  module Linters
+    # Counts the number of times a HTML clipboard-copy is used instead of the component.
+    class ClipboardCopyComponentMigrationCounter < BaseLinter
+      include Autocorrectable
+
+      TAGS = %w[clipboard-copy].freeze
+      REQUIRED_ARGUMENTS = [/for|value/, "aria-label"].freeze
+      MESSAGE = "We are migrating clipboard-copy to use [Yattho::Beta::ClipboardCopy](https://yattho.com/view-components/components/clipboardcopy), please try to use that instead of raw HTML."
+      ARGUMENT_MAPPER = ArgumentMappers::ClipboardCopy
+      COMPONENT = "Yattho::Beta::ClipboardCopy"
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "base_linter"
+require_relative "autocorrectable"
+require_relative "argument_mappers/close_button"
+require_relative "helpers/rubocop_helpers"
+
+module ERBLint
+  module Linters
+    # Counts the number of times a HTML clipboard-copy is used instead of the component.
+    class CloseButtonComponentMigrationCounter < BaseLinter
+      include Autocorrectable
+      include Helpers::RubocopHelpers
+
+      TAGS = %w[button].freeze
+      CLASSES = %w[close-button].freeze
+      MESSAGE = "We are migrating close-button to use [Yattho::Beta::CloseButton](https://yattho.com/view-components/components/beta/closebutton), please try to use that instead of raw HTML."
+      ARGUMENT_MAPPER = ArgumentMappers::CloseButton
+      COMPONENT = "Yattho::Beta::CloseButton"
+
+      ALLOWED_OCTICON_ARGS = %w[icon aria-label aria].freeze
+
+      private
+
+      def map_arguments(tag, tag_tree)
+        # We can only autocorrect cases where the tag only has an octicon as content.
+        return if tag_tree[:children].size != 1
+
+        nodes = tag_tree[:children].first.children
+        erb_nodes = nodes.select { |node| node.try(:type) == :erb }
+
+        # Don't correct if there are multiple ERB nodes.
+        return if erb_nodes.size != 1
+
+        _, _, code_node = *erb_nodes.first
+        code = code_node.children.first.strip
+        ast = erb_ast(code)
+
+        # We'll only autocorrect cases where the only content is an octicon.
+        if ast.method_name == :yattho_octicon || ast.method_name == :octicon
+          octicon_kwargs = ast.arguments[1]
+          icon = icon(ast.arguments)
+        elsif ast.method_name == :render && code.include?("Yattho::Beta::Octicon")
+          octicon_kwargs = ast.arguments.first.arguments.last
+          icon = icon(ast.arguments.first.arguments)
+        else
+          return
+        end
+
+        # Don't autocorrect if using a custom icon
+        return unless icon == :x
+        # Don't autocorrect if the octicon has custom arguments
+        return if custom_attributes?(octicon_kwargs)
+
+        octicon_aria_label = aria_label_from_octicon(octicon_kwargs)
+        tag_aria_label = tag.attributes.each.find { |a| a.name == "aria-label" }
+
+        # Can't autocorrect if there is no aria-label.
+        return if octicon_aria_label.blank? && tag_aria_label.blank?
+
+        args = ARGUMENT_MAPPER.new(tag).to_s
+
+        # Argument mapper will add the `aria-label` if the tag has it.
+        return args if tag_aria_label.present?
+
+        aria_label_arg = "\"aria-label\": #{octicon_aria_label}"
+
+        return aria_label_arg if args.blank?
+
+        "#{args}, #{aria_label_arg}"
+      rescue ArgumentMappers::ConversionError
+        nil
+      end
+
+      # Overriding the basic correction since this component does not uses content blocks.
+      def correction(args)
+        return if args.nil?
+
+        correction = "<%= render #{self.class::COMPONENT}.new"
+        correction += "(#{args})" if args.present?
+        "#{correction} %>"
+      end
+
+      # Overriding the basic correction since this component will rewrite the whole tag block.
+      def add_correction(tag, tag_tree)
+        offense_loc = tag.loc.with(end_pos: tag_tree[:closing].loc.to_range.last)
+        add_offense(offense_loc, tag_tree[:message], tag_tree[:correction])
+      end
+
+      # Extracts the aria-label value from the octicon kwargs.
+      # It can either be in `"aria-label": "value"`` or `aria: { label: "value" } }`.
+      def aria_label_from_octicon(kwargs)
+        return if kwargs.blank? || kwargs.type != :hash || kwargs.pairs.blank?
+
+        aria_label = kwargs.pairs.find { |x| x.key.value == :'aria-label' }
+
+        return aria_label.value.source if aria_label
+
+        aria_hash = kwargs.pairs.find { |x| x.key.value == :aria }
+
+        return if aria_hash.blank?
+
+        aria_label = aria_hash.value.pairs.find { |x| x.key.value == :label }
+
+        aria_label&.value&.source
+      end
+
+      def custom_attributes?(kwargs)
+        return false if kwargs.blank? || kwargs.type != :hash || kwargs.pairs.blank?
+
+        (kwargs.keys.map { |key| key.value.to_s } - ALLOWED_OCTICON_ARGS).present?
+      end
+
+      def icon(args)
+        return args.first.value.to_sym if args.first.type == :sym || args.first.type == :str
+
+        args.last.pairs.find { |x| x.key.value == :icon }.value.value.to_sym
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "helpers/deprecated_components_helpers"
+require_relative "severity_schema"
+
+require "erblint-github/linters/custom_helpers"
+
+module ERBLint
+  module Linters
+    # Lints against deprecated components
+    class DeprecatedComponentsCounter < Linter
+      include CustomHelpers
+      include ERBLint::LinterRegistry
+      include Helpers::DeprecatedComponentsHelpers
+
+      self.config_schema = SeveritySchema
+
+      def run(processed_source)
+        processed_source.ast.descendants(:erb).each do |erb_node|
+          _, _, code_node = *erb_node
+          code = code_node.children.first.strip
+
+          next unless code.include?("Yattho::")
+
+          deprecated_components.each do |component|
+            next unless code.include?(component)
+
+            add_offense(erb_node.loc, message(component))
+          end
+        end
+
+        counter_correct?(processed_source)
+      end
+
+      def autocorrect(processed_source, offense)
+        return unless offense.context
+
+        lambda do |corrector|
+          if processed_source.file_content.include?("erblint:counter #{self.class.name.gsub('ERBLint::Linters::', '')}")
+            # 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
+      end
+
+      # this override is necessary because of the github/erblint-github `CustomHelpers`
+      # module. `counter_correct?` is provided by this module, and calls `add_offense`
+      # directly. there is no simple way to modify this without updating the gem and
+      # creating what would likely be an API that is non-standard and/or difficult to use
+      #
+      # https://github.com/github/erblint-github/blob/main/lib/erblint-github/linters/custom_helpers.rb
+      def add_offense(source_range, message, context = nil, severity = nil)
+        super(source_range, message, context, severity || @config.severity)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "pathname"
+require_relative "helpers/rubocop_helpers"
+
+module ERBLint
+  module Linters
+    # Finds usages of ActionList CSS classes.
+    class DisallowActionList < Linter
+      include ERBLint::LinterRegistry
+      include TagTreeHelpers
+
+      class ConfigSchema < LinterConfig
+        property :ignore_files, accepts: array_of?(String), default: -> { [] }
+      end
+      self.config_schema = ConfigSchema
+
+      def run(processed_source)
+        return if ignored?(processed_source.filename)
+
+        class_regex = /ActionList[\w-]*/
+        tags, * = build_tag_tree(processed_source)
+
+        tags.each do |tag|
+          next if tag.closing?
+
+          classes =
+            if (class_attrib = tag.attributes["class"])
+              loc = class_attrib.value_node.loc
+              loc.source_buffer.source[loc.begin_pos...loc.end_pos]
+            else
+              ""
+            end
+
+          indices = [].tap do |results|
+            classes.scan(class_regex) do
+              results << Regexp.last_match.offset(0)
+            end
+          end
+
+          next if indices.empty?
+
+          indices.each do |(start_idx, end_idx)|
+            new_loc = class_attrib.value_node.loc.with(
+              begin_pos: class_attrib.value_node.loc.begin_pos + start_idx,
+              end_pos: class_attrib.value_node.loc.begin_pos + end_idx
+            )
+
+            add_offense(
+              new_loc,
+              "ActionList classes are only designed to be used by Yattho View Components and " \
+              "should be considered private. Please reach out in the #yattho-rails Slack channel."
+            )
+          end
+        end
+      end
+
+      private
+
+      def ignored?(filename)
+        filename = Pathname(filename)
+
+        begin
+          filename = filename.relative_path_from(Pathname(Dir.getwd))
+        rescue ArgumentError
+          # raised if the filename does not have Dir.getwd as a prefix
+        end
+
+        @config.ignore_files.any? { |pattern| filename.fnmatch?(pattern) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "base_linter"
+require_relative "autocorrectable"
+require_relative "argument_mappers/flash"
+
+module ERBLint
+  module Linters
+    # Counts the number of times a HTML flash is used instead of the component.
+    class FlashMigrationCounter < BaseLinter
+      include Autocorrectable
+
+      TAGS = %w[div].freeze
+      CLASSES = %w[flash].freeze
+      MESSAGE = "We are migrating flashes to use [Yattho::Beta::Flash](https://yattho.com/view-components/components/beta/flash), please try to use that instead of raw HTML."
+      ARGUMENT_MAPPER = ArgumentMappers::Flash
+      COMPONENT = "Yattho::Beta::Flash"
+
+      def map_arguments(tag, tag_tree)
+        # We can only autocorrect elements with simple text as content.
+        return nil if tag_tree[:children].size != 1
+        # Hash children indicates that there are tags in the content.
+        return nil if tag_tree[:children].first.is_a?(Hash)
+
+        content = tag_tree[:children].first
+
+        # Don't accept content with ERB blocks
+        return nil if content.type != :text || content.children&.any? { |n| n.try(:type) == :erb }
+
+        ARGUMENT_MAPPER.new(tag).to_s
+      rescue ArgumentMappers::ConversionError
+        nil
+      end
+    end
+  end
+end

data/lib/yattho/view_components/linters/helpers/deprecated_components_helpers.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "yattho/deprecations"
+
+module ERBLint
+  module Linters
+    module Helpers
+      # Helpers to share between DeprecatedComponents ERB lint and Rubocop cop
+      module DeprecatedComponentsHelpers
+        def message(component_name)
+          Yattho::Deprecations.deprecation_message(component_name)
+        end
+
+        def deprecated_components
+          Yattho::Deprecations.deprecated_components
+        end
+      end
+    end
+  end
+end

data/lib/yattho/view_components/linters/helpers/rubocop_helpers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ERBLint
+  module Linters
+    module Helpers
+      # Provides helpers related to RuboCop.
+      module RubocopHelpers
+        def erb_ast(code)
+          RuboCop::AST::ProcessedSource.new(code, RUBY_VERSION.to_f).ast
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "base_linter"
+require_relative "autocorrectable"
+require_relative "argument_mappers/label"
+
+module ERBLint
+  module Linters
+    # Counts the number of times a HTML label is used instead of the component.
+    class LabelComponentMigrationCounter < BaseLinter
+      include Autocorrectable
+
+      TAGS = Yattho::ViewComponents::Constants.get(
+        component: "Yattho::Beta::Label",
+        constant: "TAG_OPTIONS"
+      ).freeze
+
+      CLASSES = %w[Label].freeze
+      MESSAGE = "We are migrating labels to use [Yattho::Beta::Label](https://yattho.com/view-components/components/label), please try to use that instead of raw HTML."
+      ARGUMENT_MAPPER = ArgumentMappers::Label
+      COMPONENT = "Yattho::Beta::Label"
+    end
+  end
+end