yattho_view_components 0.0.1

data/lib/rubocop/cop/yattho/deprecated_arguments.rb

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+# :nocov:
+module RuboCop
+  module Cop
+    module Yattho
+      # This cop ensures that components don't use deprecated arguments
+      #
+      # bad
+      # Component.new(foo: :deprecated)
+      #
+      # good
+      # Component.new(foo: :bar)
+      class DeprecatedArguments < BaseCop
+        INVALID_MESSAGE = <<~STR
+          Avoid using deprecated arguments: https://yattho.com/view-components/deprecated.
+        STR
+
+        # This is a hash of deprecated arguments and their replacements.
+        #
+        #   * The top level key is the argument.
+        #   * The second level key is the value.
+        #   * The second level value is a string of the full replacement. e.g. "new_argument: :new_value"
+        #     If the value is nil, then there is no replacement.
+        #
+        # e.g.
+        # DEPRECATED = {
+        #   argument: {
+        #     value: "new_argument: :new_value"
+        #   }
+        # }
+        #
+        DEPRECATED = {
+          bg: {
+            white: "bg: :primary",
+            gray_light: "bg: :secondary",
+            gray: "bg: :tertiary",
+            gray_dark: "bg: :canvas_inverse",
+            blue_light: "bg: :info",
+            blue: "bg: :info_inverse",
+            green_light: "bg: :success",
+            green: "bg: :success_inverse",
+            yellow_light: "bg: :warning",
+            yellow: "bg: :warning_inverse",
+            red_light: "bg: :danger",
+            red: "bg: :danger_inverse",
+            canvas: "bg: :default",
+            canvas_inverse: "bg: :emphasis",
+            canvas_inset: "bg: :inset",
+            primary: "bg: :default",
+            secondary: "bg: :subtle",
+            tertiary: "bg: :subtle",
+            info: "bg: :accent",
+            info_inverse: "bg: :accent_emphasis",
+            danger_inverse: "bg: :danger_emphasis",
+            success_inverse: "bg: :success_emphasis",
+            warning: "bg: :attention",
+            warning_inverse: "bg: :attention_emphasis",
+            gray_0: nil,
+            gray_1: nil,
+            gray_2: nil,
+            gray_3: nil,
+            gray_4: nil,
+            gray_5: nil,
+            gray_6: nil,
+            gray_7: nil,
+            gray_8: nil,
+            gray_9: nil,
+            blue_0: nil,
+            blue_1: nil,
+            blue_2: nil,
+            blue_3: nil,
+            blue_4: nil,
+            blue_5: nil,
+            blue_6: nil,
+            blue_7: nil,
+            blue_8: nil,
+            blue_9: nil,
+            green_0: nil,
+            green_1: nil,
+            green_2: nil,
+            green_3: nil,
+            green_4: nil,
+            green_5: nil,
+            green_6: nil,
+            green_7: nil,
+            green_8: nil,
+            green_9: nil,
+            yellow_0: nil,
+            yellow_1: nil,
+            yellow_2: nil,
+            yellow_3: nil,
+            yellow_4: nil,
+            yellow_5: nil,
+            yellow_6: nil,
+            yellow_7: nil,
+            yellow_8: nil,
+            yellow_9: nil,
+            red_0: nil,
+            red_1: nil,
+            red_2: nil,
+            red_3: nil,
+            red_4: nil,
+            red_5: nil,
+            red_6: nil,
+            red_7: nil,
+            red_8: nil,
+            red_9: nil,
+            purple_0: nil,
+            purple_1: nil,
+            purple_2: nil,
+            purple_3: nil,
+            purple_4: nil,
+            purple_5: nil,
+            purple_6: nil,
+            purple_7: nil,
+            purple_8: nil,
+            purple_9: nil,
+            pink_0: nil,
+            pink_1: nil,
+            pink_2: nil,
+            pink_3: nil,
+            pink_4: nil,
+            pink_5: nil,
+            pink_6: nil,
+            pink_7: nil,
+            pink_8: nil,
+            pink_9: nil,
+            orange_0: nil,
+            orange_1: nil,
+            orange_2: nil,
+            orange_3: nil,
+            orange_4: nil,
+            orange_5: nil,
+            orange_6: nil,
+            orange_7: nil,
+            orange_8: nil,
+            orange_9: nil,
+            purple_light: nil,
+            purple: nil,
+            yellow_dark: nil,
+            orange: nil,
+            pink: nil
+          },
+          border_color: {
+            gray: "border_color: :primary",
+            gray_light: "border_color: :secondary",
+            gray_dark: "border_color: :tertiary",
+            blue: "border_color: :info",
+            green: "border_color: :success",
+            yellow: "border_color: :warning",
+            red: "border_color: :danger",
+            white: "border_color: :inverse",
+            primary: "border_color: :default",
+            secondary: "border_color: :muted",
+            tertiary: "border_color: :default",
+            inverse: nil,
+            info: "border_color: :accent_emphasis",
+            warning: "border_color: :attention_emphasis"
+          },
+          color: {
+            text_primary: "color: :default",
+            text_secondary: "color: :muted",
+            text_tertiary: "color: :muted",
+            text_link: "color: :accent",
+            text_success: "color: :success",
+            text_warning: "color: :attention",
+            text_danger: "color: :danger",
+            text_inverse: "color: :on_emphasis",
+            text_white: "color: :on_emphasis",
+            icon_primary: "color: :default",
+            icon_secondary: "color: :muted",
+            icon_tertiary: "color: :muted",
+            icon_info: "color: :accent",
+            icon_danger: "color: :danger",
+            icon_success: "color: :success",
+            icon_warning: "color: :attention",
+            blue: "color: :text_link",
+            gray_dark: "color: :text_primary",
+            gray: "color: :text_secondary",
+            gray_light: "color: :text_tertiary",
+            green: "color: :text_success",
+            yellow: "color: :text_warning",
+            red: "color: :text_danger",
+            gray_0: nil,
+            gray_1: nil,
+            gray_2: nil,
+            gray_3: nil,
+            gray_4: nil,
+            gray_5: nil,
+            gray_6: nil,
+            gray_7: nil,
+            gray_8: nil,
+            gray_9: nil,
+            blue_0: nil,
+            blue_1: nil,
+            blue_2: nil,
+            blue_3: nil,
+            blue_4: nil,
+            blue_5: nil,
+            blue_6: nil,
+            blue_7: nil,
+            blue_8: nil,
+            blue_9: nil,
+            green_0: nil,
+            green_1: nil,
+            green_2: nil,
+            green_3: nil,
+            green_4: nil,
+            green_5: nil,
+            green_6: nil,
+            green_7: nil,
+            green_8: nil,
+            green_9: nil,
+            yellow_0: nil,
+            yellow_1: nil,
+            yellow_2: nil,
+            yellow_3: nil,
+            yellow_4: nil,
+            yellow_5: nil,
+            yellow_6: nil,
+            yellow_7: nil,
+            yellow_8: nil,
+            yellow_9: nil,
+            red_0: nil,
+            red_1: nil,
+            red_2: nil,
+            red_3: nil,
+            red_4: nil,
+            red_5: nil,
+            red_6: nil,
+            red_7: nil,
+            red_8: nil,
+            red_9: nil,
+            purple_0: nil,
+            purple_1: nil,
+            purple_2: nil,
+            purple_3: nil,
+            purple_4: nil,
+            purple_5: nil,
+            purple_6: nil,
+            purple_7: nil,
+            purple_8: nil,
+            purple_9: nil,
+            pink_0: nil,
+            pink_1: nil,
+            pink_2: nil,
+            pink_3: nil,
+            pink_4: nil,
+            pink_5: nil,
+            pink_6: nil,
+            pink_7: nil,
+            pink_8: nil,
+            pink_9: nil,
+            orange_0: nil,
+            orange_1: nil,
+            orange_2: nil,
+            orange_3: nil,
+            orange_4: nil,
+            orange_5: nil,
+            orange_6: nil,
+            orange_7: nil,
+            orange_8: nil,
+            orange_9: nil
+          }
+        }.freeze
+
+        def on_send(node)
+          return unless valid_node?(node)
+          return unless node.arguments?
+
+          # we are looking for hash arguments and they are always last
+          kwargs = node.arguments.last
+
+          return unless kwargs.type == :hash
+
+          kwargs.pairs.each do |pair|
+            # Skip if we're not dealing with a symbol key
+            next if pair.key.type != :sym
+
+            key, value = extract_kv_from(pair)
+            next unless DEPRECATED.key?(key) && DEPRECATED[key].key?(value)
+
+            add_offense(pair, message: INVALID_MESSAGE)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            key, value = extract_kv_from(node)
+            replacement = DEPRECATED[key][value]
+            corrector.replace(node, replacement) if replacement.present?
+          end
+        end
+
+        def extract_kv_from(pair)
+          key = pair.key.value
+
+          # rubocop:disable Lint/BooleanSymbol
+          value = case pair.value.type
+                  when :sym, :str
+                    pair.value.value.to_sym
+                  when :false, :true
+                    pair.value.type == :true
+                  else
+                    return []
+                  end
+          # rubocop:enable Lint/BooleanSymbol
+
+          [key, value]
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/yattho/deprecated_button_arguments.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+# :nocov:
+module RuboCop
+  module Cop
+    module Yattho
+      # This cop ensures that `ButtonComponent` doesn't use deprecated arguments.
+      #
+      # bad
+      # ButtonComponent.new(variant: :small)
+      #
+      # good
+      # ButtonComponent.new(size: :small)
+      class DeprecatedButtonArguments < BaseCop
+        INVALID_MESSAGE = <<~STR
+          `variant` is deprecated. Use `size` instead.
+        STR
+
+        def_node_matcher :button_component?, <<~PATTERN
+          (send (const (const nil? :Yattho) :ButtonComponent) :new ...)
+        PATTERN
+
+        DEPRECATIONS = {
+          variant: :size
+        }.freeze
+
+        def on_send(node)
+          return unless button_component?(node)
+
+          kwargs = node.arguments.last
+
+          return if kwargs.nil?
+
+          pair = kwargs.pairs.find { |x| x.key.value == :variant }
+
+          return if pair.nil?
+
+          add_offense(pair.key, message: INVALID_MESSAGE)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, DEPRECATIONS[node.value])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/yattho/deprecated_components.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require "json"
+require "parser/current"
+require_relative "./../../../yattho/view_components/linters/helpers/deprecated_components_helpers"
+
+module RuboCop
+  module Cop
+    module Yattho
+      # This cop ensures that components marked as "deprecated" in `static/statuses.json` are discouraged from use.
+      #
+      # bad
+      # Yattho::BlankslateComponent.new(:foo)
+      #
+      # good
+      # Yattho::Beta::Blankslate.new(:foo)
+      #
+      # bad
+      # Yattho::Tooltip.new(:foo)
+      #
+      # good
+      # Yattho::Alpha::Tooltip.new(:foo)
+      class DeprecatedComponents < BaseCop
+        include ERBLint::Linters::Helpers::DeprecatedComponentsHelpers
+
+        def on_send(node)
+          return unless node.source.include?("Yattho::")
+
+          deprecated_components.each do |component|
+            pattern = NodePattern.new("(send #{pattern(component)} :new ...)")
+            add_offense(node, message: message(component)) if pattern.match(node)
+          end
+        end
+
+        private
+
+        # Converts a string to acceptable rubocop-ast pattern syntax
+        def pattern(component)
+          Parser::CurrentRuby.parse(component)
+                             .to_s
+                             .gsub("nil", "nil?")
+                             .delete("\n")
+                             .gsub("  ", " ")
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/yattho/deprecated_label_schemes.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+# :nocov:
+module RuboCop
+  module Cop
+    module Yattho
+      # This cop ensures that components don't use deprecated `Label` schemes.
+      #
+      # bad
+      # Yattho::Beta::Label.new(scheme: :info)
+      #
+      # good
+      # Yattho::Beta::Label.new(scheme: :accent)
+      class DeprecatedLabelSchemes < BaseCop
+        INVALID_MESSAGE = <<~STR
+          Avoid using deprecated schemes: https://yattho.com/view-components/deprecated#labelcomponent.
+        STR
+
+        # This is a hash of deprecated schemes and their replacements.
+        DEPRECATIONS = {
+          info: ":accent",
+          warning: ":attention",
+          orange: ":severe",
+          purple: ":done"
+        }.freeze
+
+        def on_send(node)
+          return unless label_node?(node)
+          return unless node.arguments?
+
+          # we are looking for hash arguments and they are always last
+          kwargs = node.arguments.last
+
+          return unless kwargs.type == :hash
+
+          kwargs.pairs.each do |pair|
+            # Skip if we're not dealing with a symbol
+            next if pair.key.type != :sym
+            next unless pair.value.type == :sym || pair.value.type == :str
+
+            value = pair.value.value.to_sym
+
+            next unless DEPRECATIONS.key?(value)
+
+            add_offense(pair.value, message: INVALID_MESSAGE)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            replacement = DEPRECATIONS[node.value.to_sym]
+            corrector.replace(node, replacement)
+          end
+        end
+
+        private
+
+        def label_node?(node)
+          return if node.nil?
+
+          node.method_name == :new && !node.receiver.nil? && node.receiver.const_name == "Yattho::Beta::Label"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/yattho/deprecated_label_variants.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+# :nocov:
+module RuboCop
+  module Cop
+    module Yattho
+      # This cop ensures that `LabelComponent`s don't use the old `variant` argument.
+      #
+      # bad
+      # Yattho::Beta::Label.new(variant: :large)
+      #
+      # good
+      # Yattho::Beta::Label.new(size: :large)
+      #
+      # bad
+      # Yattho::Beta::Label.new(variant: :inline)
+      #
+      # good
+      # Yattho::Beta::Label.new(inline: true)
+      class DeprecatedLabelVariants < BaseCop
+        def on_send(node)
+          return unless label_node?(node)
+          return unless node.arguments?
+
+          # we are looking for hash arguments and they are always last
+          kwargs = node.arguments.last
+
+          return unless kwargs.type == :hash
+
+          kwargs.pairs.each do |pair|
+            # skip if we're not dealing with a symbol or string
+            next if pair.key.type != :sym
+            next unless pair.value.type == :sym || pair.value.type == :str
+            next if pair.key.value != :variant
+
+            case pair.value.value
+            when :large, "large"
+              add_offense(pair,
+                          message: "Avoid using `variant: :large` with `LabelComponent`. Use `size: :large` instead.")
+            when :inline, "inline"
+              add_offense(pair,
+                          message: "Avoid using `variant: :inline` with `LabelComponent`. Use `inline: true` instead.")
+            end
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            replacement =
+              case node.value.value
+              when :large, "large"
+                "size: :large"
+              when :inline, "inline"
+                "inline: true"
+              end
+
+            corrector.replace(node, replacement)
+          end
+        end
+
+        private
+
+        def label_node?(node)
+          return if node.nil?
+
+          node.method_name == :new && !node.receiver.nil? && node.receiver.const_name == "Yattho::Beta::Label"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/yattho/deprecated_layout_component.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Yattho
+      # This cop ensures that the deprecated `Yattho::LayoutComponent` isn't used.
+      #
+      # bad
+      # Yattho::LayoutComponent.new(foo: :deprecated)
+      #
+      # good
+      # Yattho::Alpha::Layout.new(foo: :deprecated)
+      class DeprecatedLayoutComponent < BaseCop
+        MSG = "Please try Yattho::Alpha::Layout instead."
+
+        def_node_matcher :legacy_component?, <<~PATTERN
+          (send (const (const nil? :Yattho) :LayoutComponent) :new ...)
+        PATTERN
+
+        def on_send(node)
+          return unless legacy_component?(node)
+
+          add_offense(node, message: MSG)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/yattho/no_tag_memoize.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+# :nocov:
+module RuboCop
+  module Cop
+    module Yattho
+      # This cop ensures that tags are not set with ||=
+      #
+      # bad
+      # @system_arguments[:tag] ||= :h1
+      #
+      # good
+      # @system_arguments[:tag] = fetch_or_fallback(TAG_OPTIONS, tag, DEFAULT_TAG)
+      #
+      # good
+      # @system_arguments[:tag] = :h2
+      class NoTagMemoize < RuboCop::Cop::Cop
+        INVALID_MESSAGE = <<~STR
+          Avoid `[:tag] ||=`. Instead, try one of the following:
+            - Don't allow consumers to update the tag by having a fixed tag (e.g. `system_arguments[:tag] = :div`)
+            - Use the `fetch_or_fallback` helper to only allow a tag from a restricted list.
+        STR
+
+        def_node_search :tag_memoized?, <<~PATTERN
+          (or-asgn
+            (send
+              _
+              _
+              (sym :tag)
+            )
+            _
+          )
+        PATTERN
+
+        def on_or_asgn(node)
+          add_offense(node, message: INVALID_MESSAGE) if tag_memoized?(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/yattho/system_argument_instead_of_class.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require "yattho/classify/utilities"
+
+# :nocov:
+module RuboCop
+  module Cop
+    module Yattho
+      # This cop ensures that components use System Arguments instead of CSS classes.
+      #
+      # bad
+      # Component.new(classes: "mr-1")
+      #
+      # good
+      # Component.new(mr: 1)
+      class SystemArgumentInsteadOfClass < BaseCop
+        INVALID_MESSAGE = <<~STR
+          Avoid using CSS classes when you can use System Arguments: https://yattho.com/view-components/system-arguments.
+        STR
+
+        def on_send(node)
+          return unless valid_node?(node)
+          return unless node.arguments?
+
+          # we are looking for hash arguments and they are always last
+          kwargs = node.arguments.last
+
+          return unless kwargs.type == :hash
+
+          # find classes pair
+          classes_arg = kwargs.pairs.find { |kwarg| kwarg.key.value == :classes }
+
+          return if classes_arg.nil?
+          return unless classes_arg.value.type == :str
+
+          # get actual classes
+          classes = classes_arg.value.value
+
+          system_arguments = ::Yattho::Classify::Utilities.classes_to_hash(classes)
+
+          # no classes are fixable
+          return if system_arguments[:classes] == classes
+
+          add_offense(classes_arg, message: INVALID_MESSAGE)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            args = ::Yattho::Classify::Utilities.classes_to_args(node.value.value)
+            corrector.replace(node.loc.expression, args)
+          end
+        end
+      end
+    end
+  end
+end