primer_view_components 0.0.50 → 0.0.54

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

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
+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 < Linter
-      include Helpers
+    class LabelComponentMigrationCounter < BaseLinter
       include Autocorrectable
 
       TAGS = Primer::ViewComponents::Constants.get(

data/lib/primer/view_components/version.rb

@@ -5,7 +5,7 @@ module Primer
     module VERSION
       MAJOR = 0
       MINOR = 0
-      PATCH = 50
+      PATCH = 54
 
       STRING = [MAJOR, MINOR, PATCH].join(".")
     end

data/lib/rubocop/config/default.yml

@@ -10,3 +10,8 @@ Primer/SystemArgumentInsteadOfClass:
 Primer/NoTagMemoize:
   Enabled: false
 
+Primer/PrimerOcticon:
+  Enabled: true
+
+Primer/DeprecatedArguments:
+  Enabled: true

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

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require "primer/view_components/statuses"
+require_relative "../../../../app/lib/primer/view_helper"
+
+# :nocov:
+module RuboCop
+  module Cop
+    module Primer
+      # This cop ensures that components don't use deprecated arguments
+      #
+      # bad
+      # Component.new(foo: :deprecated)
+      #
+      # good
+      # Component.new(foo: :bar)
+      class DeprecatedArguments < RuboCop::Cop::Cop
+        INVALID_MESSAGE = <<~STR
+          Avoid using deprecated arguments: https://primer.style/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 seceond 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",
+            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
+          },
+          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"
+          },
+          color: {
+            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
+            next if pair.key.type != :sym
+            next unless pair.value.type == :sym || pair.value.type == :str
+
+            key = pair.key.value
+            value = pair.value.value.to_sym
+
+            next unless DEPRECATED.key?(key) && DEPRECATED[key].key?(value)
+
+            add_offense(pair, message: INVALID_MESSAGE)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            replacement = DEPRECATED[node.key.value][node.value.value.to_sym]
+            corrector.replace(node, replacement) if replacement.present?
+          end
+        end
+
+        private
+
+        # We only verify SystemArguments if it's a `.new` call on a component or
+        # a ViewHleper call.
+        def valid_node?(node)
+          view_helpers.include?(node.method_name) || (node.method_name == :new && ::Primer::ViewComponents::STATUSES.key?(node.receiver.const_name))
+        end
+
+        def view_helpers
+          ::Primer::ViewHelper::HELPERS.keys.map { |key| "primer_#{key}".to_sym }
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,7 @@
 
 require "rubocop"
 
+# :nocov:
 module RuboCop
   module Cop
     module Primer

data/lib/rubocop/cop/primer/primer_octicon.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require "primer/classify/utilities"
+require "primer/classify/validation"
+
+# :nocov:
+module RuboCop
+  module Cop
+    module Primer
+      # This cop ensures that components use System Arguments instead of CSS classes.
+      #
+      # bad
+      # octicon(:icon)
+      # octicon("icon")
+      # octicon("icon-with-daashes")
+      # octicon(@ivar)
+      # octicon(condition > "icon" : "other-icon")
+      #
+      # good
+      # primer_octicon(:icon)
+      # primer_octicon(:"icon-with-daashes")
+      # primer_octicon(@ivar)
+      # primer_octicon(condition > "icon" : "other-icon")
+      class PrimerOcticon < RuboCop::Cop::Cop
+        INVALID_MESSAGE = <<~STR
+          Replace the octicon helper with primer_octicon. See https://primer.style/view-components/components/octicon for details.
+        STR
+
+        SIZE_ATTRIBUTES = %w[height width size].freeze
+        STRING_ATTRIBUTES = %w[aria- data-].freeze
+        VALID_ATTRIBUTES = [*SIZE_ATTRIBUTES, *STRING_ATTRIBUTES, "class"].freeze
+
+        STRING_ATTRIBUTE_REGEX = Regexp.union(STRING_ATTRIBUTES).freeze
+        ATTRIBUTE_REGEX = Regexp.union(VALID_ATTRIBUTES).freeze
+        INVALID_ATTRIBUTE = -1
+
+        def on_send(node)
+          return unless node.method_name == :octicon
+          return unless node.arguments?
+
+          kwargs = kwargs(node)
+
+          return unless kwargs.type == :hash
+
+          attributes = kwargs.keys.map(&:value)
+
+          # Don't convert unknown attributes
+          return unless attributes.all? { |attribute| attribute.match?(ATTRIBUTE_REGEX) }
+          # Can't convert size
+          return if octicon_size_attributes(kwargs) == INVALID_ATTRIBUTE
+
+          # find class pair
+          classes = classes(kwargs)
+
+          return if classes == INVALID_ATTRIBUTE
+
+          # check if classes are convertible
+          if classes.present?
+            system_arguments = ::Primer::Classify::Utilities.classes_to_hash(classes)
+            invalid_classes = (system_arguments[:classes]&.split(" ") || []).select { |class_name| ::Primer::Classify::Validation.invalid?(class_name) }
+
+            # Uses system argument that can't be converted
+            return if invalid_classes.present?
+          end
+
+          add_offense(node, message: INVALID_MESSAGE)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            kwargs = kwargs(node)
+
+            # Converting arguments for the component
+            classes = classes(kwargs)
+            size_attributes = transform_sizes(kwargs)
+            args = arguments_as_string(node, size_attributes, classes)
+
+            corrector.replace(node.loc.expression, "primer_octicon(#{args})")
+          end
+        end
+
+        private
+
+        def transform_sizes(kwargs)
+          attributes = octicon_size_attributes(kwargs)
+
+          attributes.transform_values do |size|
+            if size.between?(10, 16)
+              ""
+            elsif size.between?(22, 26)
+              ":medium"
+            else
+              size
+            end
+          end
+        end
+
+        def octicon_size_attributes(kwargs)
+          kwargs.pairs.each_with_object({}) do |pair, h|
+            next unless SIZE_ATTRIBUTES.include?(pair.key.value.to_s)
+
+            # We only support string or int values.
+            case pair.value.type
+            when :int
+              h[pair.key.value] = pair.value.source.to_i
+            when :str
+              h[pair.key.value] = pair.value.value.to_i
+            else
+              return INVALID_ATTRIBUTE
+            end
+          end
+        end
+
+        def classes(kwargs)
+          # find class pair
+          class_arg = kwargs.pairs.find { |kwarg| kwarg.key.value == :class }
+
+          return if class_arg.blank?
+          return INVALID_ATTRIBUTE unless class_arg.value.type == :str
+
+          class_arg.value.value
+        end
+
+        def arguments_as_string(node, size_attributes, classes)
+          args = icon(node.arguments.first)
+          size_args = size_attributes_to_string(size_attributes)
+          string_args = string_args_to_string(node)
+
+          args = "#{args}, #{size_attributes_to_string(size_attributes)}" if size_args.present?
+          args = "#{args}, #{::Primer::Classify::Utilities.classes_to_args(classes)}" if classes.present?
+          args = "#{args}, #{string_args}" if string_args.present?
+
+          args
+        end
+
+        def size_attributes_to_string(size_attributes)
+          # No arguments if they map to the default size
+          return if size_attributes.blank? || size_attributes.values.all?(&:blank?)
+          # Return mapped argument to `size`
+          return "size: :medium" if size_attributes.values.any?(":medium")
+
+          size_attributes.map do |key, value|
+            "#{key}: #{value}"
+          end.join(", ")
+        end
+
+        def string_args_to_string(node)
+          kwargs = kwargs(node)
+
+          args = kwargs.pairs.each_with_object([]) do |pair, acc|
+            next unless pair.key.value.to_s.match?(STRING_ATTRIBUTE_REGEX)
+
+            key =  pair.key.value.to_s == "data-test-selector" ? "test_selector" : "\"#{pair.key.value}\""
+            acc << "#{key}: #{pair.value.source}"
+          end
+
+          args.join(",")
+        end
+
+        def kwargs(node)
+          return node.arguments.last if node.arguments.size > 1
+
+          OpenStruct.new(keys: [], pairs: [], type: :hash)
+        end
+
+        def icon(node)
+          return node.source unless node.type == :str
+          return ":#{node.value}" unless node.value.include?("-")
+
+          # If the icon contains `-` we need to cast the string as a symbole
+          # E.g: `arrow-down` becomes `:"arrow-down"`
+          ":#{node.source}"
+        end
+      end
+    end
+  end
+end