primer_view_components 0.0.51 → 0.0.52

data/lib/primer/classify/flex.rb

@@ -89,7 +89,7 @@ module Primer
         def justify_content(value, breakpoint)
           val = fetch_or_fallback(JUSTIFY_CONTENT_VALUES, value)
 
-          formatted_value = val.to_s.gsub(/(flex\_|space\_)/, "")
+          formatted_value = val.to_s.gsub(/(flex_|space_)/, "")
           "flex#{breakpoint}-justify-#{formatted_value}"
         end
 

data/lib/primer/classify/functional_colors.rb

@@ -24,9 +24,9 @@ module Primer
           value:,
           mappings:,
           non_functional_prefix:,
+          functional_options:,
           functional_prefix: "",
           number_prefix: "",
-          functional_options:,
           options_without_mappigs: []
         )
           sym_value = value.to_sym

data/lib/primer/classify/utilities.rb

@@ -85,7 +85,7 @@ module Primer
           return { classes: classes } if ENV["RAILS_ENV"] == "production"
 
           obj = {}
-          classes = classes.split(" ")
+          classes = classes.split
           # Loop through all classes supplied and reject ones we find a match for
           # So when we're at the end of the loop we have classes left with any non-system classes.
           classes.reject! do |classname|
@@ -114,6 +114,21 @@ module Primer
           obj
         end
 
+        def classes_to_args(classes)
+          classes_to_hash(classes).map do |key, value|
+            val = case value
+                  when Symbol
+                    ":#{value}"
+                  when String
+                    value.to_json
+                  else
+                    value
+                  end
+
+            "#{key}: #{val}"
+          end.join(", ")
+        end
+
         private
 
         def find_selector(selector)

data/lib/primer/classify/validation.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "utilities"
+
+module Primer
+  class Classify
+    # :nodoc:
+    class Validation
+      INVALID_CLASS_NAME_PREFIXES = /bg-|color-|text-|box-shadow-|text-|box_shadow-/.freeze
+
+      class << self
+        def invalid?(class_name)
+          class_name.start_with?(INVALID_CLASS_NAME_PREFIXES) || Primer::Classify::Utilities.supported_selector?(class_name)
+        end
+      end
+    end
+  end
+end

data/lib/primer/view_components/linters/argument_mappers/base.rb

@@ -2,6 +2,7 @@
 
 require "primer/view_components/constants"
 require "primer/classify/utilities"
+require "primer/classify/validation"
 require_relative "conversion_error"
 require_relative "system_arguments"
 require_relative "helpers/erb_block"
@@ -46,18 +47,37 @@ module ERBLint
 
         def attribute_to_args(attribute); end
 
-        def map_classes(classes)
-          system_arguments = system_arguments_to_args(classes.value)
+        def map_classes(classes_node)
+          erb_helper.raise_if_erb_block(classes_node)
+
+          system_arguments = system_arguments_to_args(classes_node.value)
           args = classes_to_args(system_arguments[:classes])
 
-          args.merge(system_arguments.except(:classes))
+          invalid_classes = args[:classes].select { |class_name| Primer::Classify::Validation.invalid?(class_name) }
+
+          raise ConversionError, "Cannot convert #{'class'.pluralize(invalid_classes.size)} #{invalid_classes.join(',')}" if invalid_classes.present?
+
+          # Using splat to order the arguments in Component's args -> System Args -> custom classes
+          res = {
+            **args.except(:classes),
+            **system_arguments.except(:classes)
+          }
+
+          if args[:classes].present?
+            res = {
+              **res,
+              classes: args[:classes].join(" ").to_json
+            }
+          end
+
+          res
         end
 
-        # Override this with your component's mappings
+        # Override this with your component's mappings, it should return a hash with the component's arguments,
+        # including a `classes` key that will contain all classes that the mapper couldn't handle.
+        # @returns { classes: Array, ... }
         def classes_to_args(classes)
-          raise ConversionError, "Cannot convert classes `#{classes}`" if classes.present?
-
-          {}
+          { classes: classes&.split(" ") || [] }
         end
 
         def system_arguments_to_args(classes)
@@ -68,6 +88,12 @@ module ERBLint
             v.is_a?(Symbol) ? ":#{v}" : v
           end
         end
+
+        private
+
+        def erb_helper
+          @erb_helper ||= Helpers::ErbBlock.new
+        end
       end
     end
   end

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

@@ -7,8 +7,6 @@ module ERBLint
     module ArgumentMappers
       # Maps classes in a button element to arguments for the Button component.
       class Button < Base
-        require "pry"
-
         SCHEME_MAPPINGS = Primer::ViewComponents::Constants.get(
           component: "Primer::ButtonComponent",
           constant: "SCHEME_MAPPINGS",
@@ -35,9 +33,10 @@ module ERBLint
         def attribute_to_args(attribute)
           attr_name = attribute.name
 
-          if attr_name == "disabled"
+          case attr_name
+          when "disabled"
             { disabled: true }
-          elsif attr_name == "type"
+          when "type"
             # button is the default type, so we don't need to do anything.
             return {} if attribute.value == "button"
 
@@ -48,7 +47,7 @@ module ERBLint
         end
 
         def classes_to_args(classes)
-          classes.split(" ").each_with_object({}) do |class_name, acc|
+          classes.split.each_with_object({ classes: [] }) do |class_name, acc|
             next if class_name == "btn"
 
             if SCHEME_MAPPINGS[class_name] && acc[:scheme].nil?
@@ -60,7 +59,7 @@ module ERBLint
             elsif class_name == "BtnGroup-item"
               acc[:group_item] = true
             else
-              raise ConversionError, "Cannot convert class \"#{class_name}\""
+              acc[:classes] << class_name
             end
           end
         end

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

@@ -11,8 +11,7 @@ module ERBLint
         ATTRIBUTES = %w[value].freeze
 
         def attribute_to_args(attribute)
-          Helpers::ErbBlock.raise_if_erb_block(attribute)
-          { value: attribute.value.to_json }
+          { value: erb_helper.convert(attribute) }
         end
       end
     end

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

@@ -8,15 +8,58 @@ module ERBLint
       module Helpers
         # provides helpers to identify and deal with ERB blocks.
         class ErbBlock
-          class << self
-            def raise_if_erb_block(attribute)
-              raise ERBLint::Linters::ArgumentMappers::ConversionError, "Cannot convert attribute \"#{attribute.name}\" because its value contains an erb block" if any?(attribute)
+          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
 
-            def any?(attribute)
-              attribute.value_node&.children&.any? { |n| n.try(:type) == :erb }
+          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
+
+            # wrap the result in `""` so it is printed as a string
+            "\"#{attribute.value.gsub('<%=', '#{').gsub('%>', '}')}\""
+          end
         end
       end
     end

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

@@ -27,12 +27,11 @@ module ERBLint
         ATTRIBUTES = %w[title].freeze
 
         def attribute_to_args(attribute)
-          Helpers::ErbBlock.raise_if_erb_block(attribute)
-          { title: attribute.value.to_json }
+          { title: erb_helper.convert(attribute) }
         end
 
         def classes_to_args(classes)
-          classes.split(" ").each_with_object({}) do |class_name, acc|
+          classes.split.each_with_object({ classes: [] }) do |class_name, acc|
             next if class_name == "Label"
 
             if SCHEME_MAPPINGS[class_name] && acc[:scheme].nil?
@@ -40,7 +39,7 @@ module ERBLint
             elsif VARIANT_MAPPINGS[class_name] && acc[:variant].nil?
               acc[:variant] = VARIANT_MAPPINGS[class_name]
             else
-              raise ConversionError, "Cannot convert class \"#{class_name}\""
+              acc[:classes] << class_name
             end
           end
         end

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

@@ -11,9 +11,11 @@ module ERBLint
         STRING_PARAMETERS = %w[aria- data-].freeze
         TEST_SELECTOR_REGEX = /test_selector\((?<selector>.+)\)$/.freeze
 
-        attr_reader :attribute
+        attr_reader :attribute, :erb_helper
+
         def initialize(attribute)
           @attribute = attribute
+          @erb_helper = Helpers::ErbBlock.new
         end
 
         def to_args
@@ -29,13 +31,9 @@ module ERBLint
 
             { test_selector: m[:selector].tr("'", '"') }
           elsif attr_name == "data-test-selector"
-            Helpers::ErbBlock.raise_if_erb_block(attribute)
-
-            { test_selector: attribute.value.to_json }
+            { test_selector: erb_helper.convert(attribute) }
           elsif attr_name.start_with?(*STRING_PARAMETERS)
-            Helpers::ErbBlock.raise_if_erb_block(attribute)
-
-            { "\"#{attr_name}\"" => attribute.value.to_json }
+            { "\"#{attr_name}\"" => erb_helper.convert(attribute) }
           else
             raise ConversionError, "Cannot convert attribute \"#{attr_name}\""
           end

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

@@ -20,10 +20,10 @@ module ERBLint
         "#{correction} do %>"
       end
 
-      def message(args)
+      def message(args, processed_source)
         return self.class::MESSAGE if args.nil?
 
-        "#{self.class::MESSAGE}\n\nTry using:\n\n#{correction(args)}\n\nInstead of:\n"
+        "#{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

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

@@ -12,7 +12,7 @@ module ERBLint
       include Autocorrectable
 
       TAGS = %w[clipboard-copy].freeze
-      CLASSES = %w[].freeze
+      REQUIRED_ARGUMENTS = [/for|value/, "aria-label"].freeze
       MESSAGE = "We are migrating clipboard-copy to use [Primer::ClipboardCopy](https://primer.style/view-components/components/clipboardcopy), please try to use that instead of raw HTML."
       ARGUMENT_MAPPER = ArgumentMappers::ClipboardCopy
       COMPONENT = "Primer::ClipboardCopy"

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

@@ -15,6 +15,8 @@ module ERBLint
       ].freeze
 
       DUMP_FILE = ".erblint-counter-ignore.json"
+      CLASSES = [].freeze
+      REQUIRED_ARGUMENTS = [].freeze
 
       def self.included(base)
         base.include(ERBLint::LinterRegistry)
@@ -31,7 +33,6 @@ module ERBLint
           next unless self.class::TAGS&.include?(tag.name)
 
           classes = tag.attributes["class"]&.value&.split(" ") || []
-
           tag_tree[tag][:offense] = false
 
           next unless self.class::CLASSES.blank? || (classes & self.class::CLASSES).any?
@@ -39,9 +40,12 @@ module ERBLint
           args = map_arguments(tag)
           correction = correction(args)
 
+          attributes = tag.attributes.each.map(&:name).join(" ")
+          matches_required_attributes = self.class::REQUIRED_ARGUMENTS.blank? || self.class::REQUIRED_ARGUMENTS.all? { |arg| attributes.match?(arg) }
+
           tag_tree[tag][:offense] = true
-          tag_tree[tag][:correctable] = !correction.nil?
-          tag_tree[tag][:message] = message(args)
+          tag_tree[tag][:correctable] = matches_required_attributes && !correction.nil?
+          tag_tree[tag][:message] = message(args, processed_source)
           tag_tree[tag][:correction] = correction
         end
 
@@ -97,7 +101,7 @@ module ERBLint
       # Override this function to customize the linter message.
       #
       # @return [String] message to show on linter error.
-      def message(_tag)
+      def message(_tag, _processed_source)
         self.class::MESSAGE
       end
 

data/lib/primer/view_components/version.rb

@@ -5,7 +5,7 @@ module Primer
     module VERSION
       MAJOR = 0
       MINOR = 0
-      PATCH = 51
+      PATCH = 52
 
       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.rb

@@ -1,4 +1,3 @@
 # frozen_string_literal: true
 
-require "rubocop/cop/primer/no_tag_memoize"
-require "rubocop/cop/primer/system_argument_instead_of_class"
+Dir[File.join(__dir__, "primer", "*.rb")].sort.each { |file| require file }

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

@@ -0,0 +1,173 @@
+# 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 = {
+          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