primer_view_components 0.0.48 → 0.0.52

data/lib/primer/classify/utilities.yml

@@ -85,6 +85,22 @@
   - float-md-none
   - float-lg-none
   - float-xl-none
+:w:
+  :fit:
+  - width-fit
+  :full:
+  - width-full
+  :auto:
+  - width-auto
+  - width-sm-auto
+  - width-md-auto
+  - width-lg-auto
+  - width-xl-auto
+:h:
+  :fit:
+  - height-fit
+  :full:
+  - height-full
 :m:
   0:
   - m-0

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.rb

@@ -7,22 +7,21 @@ require "primer/view_components/engine"
 module Primer
   # :nodoc:
   module ViewComponents
-    DEFAULT_STATUSES_PATH = File.expand_path("static")
+    DEFAULT_STATIC_PATH = File.expand_path("static")
     DEFAULT_STATUS_FILE_NAME = "statuses.json"
+    DEFAULT_CONSTANTS_FILE_NAME = "constants.json"
 
     # generate_statuses returns a hash mapping component name to
     # the component's status sorted alphabetically by the component name.
     def self.generate_statuses
-      statuses = Primer::Component.descendants.each_with_object({}) do |component, mem|
+      Primer::Component.descendants.sort_by(&:name).each_with_object({}) do |component, mem|
         mem[component.to_s] = component.status.to_s
       end
-
-      statuses.sort_by { |k, _v| k }.to_h
     end
 
     # dump_statuses generates the status hash and then serializes
     # it as json at the given path
-    def self.dump_statuses(path: DEFAULT_STATUSES_PATH)
+    def self.dump_statuses(path: DEFAULT_STATIC_PATH)
       require "json"
 
       statuses = generate_statuses
@@ -35,8 +34,37 @@ module Primer
 
     # read_statuses returns a JSON string matching the output of
     # generate_statuses
-    def self.read_statuses(path: DEFAULT_STATUSES_PATH)
+    def self.read_statuses(path: DEFAULT_STATIC_PATH)
       File.read(File.join(path, DEFAULT_STATUS_FILE_NAME))
     end
+
+    # generate_constants returns a hash mapping component name to
+    # all of its constants.
+    def self.generate_constants
+      Primer::Component.descendants.sort_by(&:name).each_with_object({}) do |component, mem|
+        mem[component.to_s] = component.constants(false).sort.each_with_object({}) do |constant, h|
+          h[constant] = component.const_get(constant)
+        end
+      end
+    end
+
+    # dump_constants generates the constants hash and then serializes
+    # it as json at the given path
+    def self.dump_constants(path: DEFAULT_STATIC_PATH)
+      require "json"
+
+      constants = generate_constants
+
+      File.open(File.join(path, DEFAULT_CONSTANTS_FILE_NAME), "w") do |f|
+        f.write(JSON.pretty_generate(constants))
+        f.write($INPUT_RECORD_SEPARATOR)
+      end
+    end
+
+    # read_constants returns a JSON string matching the output of
+    # generate_constants
+    def self.read_constants(path: DEFAULT_STATIC_PATH)
+      File.read(File.join(path, DEFAULT_CONSTANTS_FILE_NAME))
+    end
   end
 end

data/lib/primer/view_components/constants.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Primer
+  module ViewComponents
+    # A module for constants that are used in the view components.
+    class Constants
+      CONSTANTS = JSON.parse(
+        File.read(
+          File.join(File.dirname(__FILE__), "../../../static/constants.json")
+        )
+      ).freeze
+
+      class << self
+        def get(component:, constant:, invert: true, symbolize: false)
+          values = CONSTANTS.dig(component, constant)
+
+          case values
+          when Hash
+            format_hash(values, invert, symbolize)
+          when Array
+            format_array(values, symbolize)
+          else
+            values
+          end
+        end
+
+        private
+
+        def format_hash(values, invert, symbolize)
+          val = values.invert if invert
+          # remove defaults
+          val = val.except("", nil)
+
+          return val.transform_values { |v| symbolize_value(v) } if symbolize
+
+          val
+        end
+
+        def format_array(values, symbolize)
+          val = values.select(&:present?)
+
+          return val.map { |v| symbolize_value(v) } if symbolize
+
+          val
+        end
+
+        def symbolize_value(value)
+          ":#{value}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+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"
+
+module ERBLint
+  module Linters
+    module ArgumentMappers
+      # Provides the base interface to implement an `ArgumentMapper`.
+      # Override attribute_to_args in a child class to customize its mapping behavior.
+      class Base
+        DEFAULT_TAG = nil
+        ATTRIBUTES = [].freeze
+
+        def initialize(tag)
+          @tag = tag
+        end
+
+        def to_s
+          to_args.map { |k, v| "#{k}: #{v}" }.join(", ")
+        end
+
+        def to_args
+          args = {}
+
+          args[:tag] = ":#{@tag.name}" unless self.class::DEFAULT_TAG.nil? || @tag.name == self.class::DEFAULT_TAG
+
+          @tag.attributes.each do |attribute|
+            attr_name = attribute.name
+
+            if self.class::ATTRIBUTES.include?(attr_name)
+              args.merge!(attribute_to_args(attribute))
+            elsif attr_name == "class"
+              args.merge!(map_classes(attribute))
+            else
+              # Assume the attribute is a system argument.
+              args.merge!(SystemArguments.new(attribute).to_args)
+            end
+          end
+
+          args
+        end
+
+        def attribute_to_args(attribute); end
+
+        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])
+
+          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, 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)
+          { classes: classes&.split(" ") || [] }
+        end
+
+        def system_arguments_to_args(classes)
+          system_arguments = Primer::Classify::Utilities.classes_to_hash(classes)
+
+          # need to transform symbols to strings with leading `:`
+          system_arguments.transform_values do |v|
+            v.is_a?(Symbol) ? ":#{v}" : v
+          end
+        end
+
+        private
+
+        def erb_helper
+          @erb_helper ||= Helpers::ErbBlock.new
+        end
+      end
+    end
+  end
+end

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

@@ -1,66 +1,53 @@
 # frozen_string_literal: true
 
-require_relative "conversion_error"
-require_relative "system_arguments"
+require_relative "base"
 
 module ERBLint
   module Linters
     module ArgumentMappers
       # Maps classes in a button element to arguments for the Button component.
-      class Button
-        SCHEME_MAPPINGS = {
-          "btn-primary" => ":primary",
-          "btn-danger" => ":danger",
-          "btn-outline" => ":outline",
-          "btn-invisible" => ":invisible",
-          "btn-link" => ":link"
-        }.freeze
+      class Button < Base
+        SCHEME_MAPPINGS = Primer::ViewComponents::Constants.get(
+          component: "Primer::ButtonComponent",
+          constant: "SCHEME_MAPPINGS",
+          symbolize: true
+        ).freeze
 
-        VARIANT_MAPPINGS = {
-          "btn-sm" => ":small",
-          "btn-large" => ":large"
-        }.freeze
+        VARIANT_MAPPINGS = Primer::ViewComponents::Constants.get(
+          component: "Primer::ButtonComponent",
+          constant: "VARIANT_MAPPINGS",
+          symbolize: true
+        ).freeze
 
-        TYPE_OPTIONS = %w[button reset submit].freeze
+        TYPE_OPTIONS = Primer::ViewComponents::Constants.get(
+          component: "Primer::BaseButton",
+          constant: "TYPE_OPTIONS"
+        ).freeze
+        DEFAULT_TAG = Primer::ViewComponents::Constants.get(
+          component: "Primer::BaseButton",
+          constant: "DEFAULT_TAG"
+        ).freeze
 
-        def initialize(tag)
-          @tag = tag
-        end
-
-        def to_s
-          to_args.map { |k, v| "#{k}: #{v}" }.join(", ")
-        end
-
-        def to_args
-          args = {}
+        ATTRIBUTES = %w[disabled type].freeze
 
-          args[:tag] = ":#{@tag.name}" unless @tag.name == "button"
+        def attribute_to_args(attribute)
+          attr_name = attribute.name
 
-          @tag.attributes.each do |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"
 
-            if attr_name == "class"
-              args = args.merge(classes_to_args(attribute))
-            elsif attr_name == "disabled"
-              args[:disabled] = true
-            elsif attr_name == "type"
-              # button is the default type, so we don't need to do anything.
-              next if attribute.value == "button"
+            raise ConversionError, "Button component does not support type \"#{attribute.value}\"" unless TYPE_OPTIONS.include?(attribute.value)
 
-              raise ConversionError, "Button component does not support type \"#{attribute.value}\"" unless TYPE_OPTIONS.include?(attribute.value)
-
-              args[:type] = ":#{attribute.value}"
-            else
-              # Assume the attribute is a system argument.
-              args.merge!(SystemArguments.new(attribute).to_args)
-            end
+            { type: ":#{attribute.value}" }
           end
-
-          args
         end
 
         def classes_to_args(classes)
-          classes.value.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?
@@ -72,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

@@ -0,0 +1,19 @@
+# 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[value].freeze
+
+        def attribute_to_args(attribute)
+          { value: erb_helper.convert(attribute) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# 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
+
+            # wrap the result in `""` so it is printed as a string
+            "\"#{attribute.value.gsub('<%=', '#{').gsub('%>', '}')}\""
+          end
+        end
+      end
+    end
+  end
+end