primer_view_components 0.0.47 → 0.0.51

data/app/components/primer/truncate.rb

@@ -6,7 +6,7 @@ module Primer
     status :beta
 
     DEFAULT_TAG = :div
-    TAG_OPTIONS = [DEFAULT_TAG, :span, :p].freeze
+    TAG_OPTIONS = [DEFAULT_TAG, :span, :p, :strong].freeze
 
     # @example Default
     #   <div class="col-2">

data/app/components/primer/underline_nav_component.rb

@@ -19,6 +19,7 @@ module Primer
     # Use the tabs to list navigation items. When `with_panel` is set on the parent, a button is rendered for panel navigation. Otherwise,
     # an anchor tag is rendered for page navigation. For more information, refer to <%= link_to_component(Primer::Navigation::TabComponent) %>.
     #
+    # @param panel_id [String] Only applies if `with_panel` is `true`. Unique id of panel.
     # @param selected [Boolean] Whether the tab is selected.
     # @param system_arguments [Hash] <%= link_to_system_arguments_docs %>
     renders_many :tabs, lambda { |selected: false, **system_arguments|
@@ -104,13 +105,13 @@ module Primer
     #
     # @example With panels
     #   <%= render(Primer::UnderlineNavComponent.new(label: "With panels", with_panel: true)) do |component| %>
-    #     <% component.tab(selected: true) do |t| %>
+    #     <% component.tab(selected: true, id: "tab-1", panel_id: "panel-1") do |t| %>
     #       <% t.text { "Item 1" } %>
     #       <% t.panel do %>
     #         Panel 1
     #       <% end %>
     #     <% end %>
-    #     <% component.tab do |t| %>
+    #     <% component.tab(id: "tab-2", panel_id: "panel-2") do |t| %>
     #       <% t.text { "Item 2" } %>
     #       <% t.panel do %>
     #         Panel 2

data/app/lib/primer/octicon/cache.rb

@@ -6,7 +6,7 @@ module Primer
     class Cache
       LOOKUP = {} # rubocop:disable Style/MutableConstant
       # Preload the top 20 used icons.
-      PRELOADED_ICONS = [:alert, :check, :"chevron-down", :clippy, :clock, :"dot-fill", :info, :"kebab-horizontal", :link, :lock, :mail, :pencil, :plus, :question, :repo, :search, :"shield-lock", :star, :trash, :x].freeze
+      PRELOADED_ICONS = [:alert, :check, :"chevron-down", :paste, :clock, :"dot-fill", :info, :"kebab-horizontal", :link, :lock, :mail, :pencil, :plus, :question, :repo, :search, :"shield-lock", :star, :trash, :x].freeze
 
       class << self
         def get_key(symbol:, size:, width: nil, height: nil)

data/lib/primer/classify.rb

@@ -20,8 +20,6 @@ module Primer
     COLOR_KEY = :color
     BG_KEY = :bg
     TEXT_KEYS = %i[font_family font_style font_weight text_align text_transform].freeze
-    WIDTH_KEY = :width
-    HEIGHT_KEY = :height
     BOX_SHADOW_KEY = :box_shadow
     CONTAINER_KEY = :container
 
@@ -94,8 +92,6 @@ module Primer
         BORDER_RADIUS_KEY,
         COLOR_KEY,
         BG_KEY,
-        WIDTH_KEY,
-        HEIGHT_KEY,
         BOX_SHADOW_KEY,
         CONTAINER_KEY
       ]
@@ -202,12 +198,6 @@ module Primer
           memo[:classes] << Primer::Classify::Flex.classes(key, val, breakpoint)
         elsif Primer::Classify::Grid::KEYS.include?(key)
           memo[:classes] << Primer::Classify::Grid.classes(key, val, breakpoint)
-        elsif key == WIDTH_KEY || key == HEIGHT_KEY
-          if val == :fit
-            memo[:classes] << "#{key}-#{val}"
-          else
-            memo[key] = val
-          end
         elsif TEXT_KEYS.include?(key)
           memo[:classes] << "text-#{val.to_s.dasherize}"
         elsif TYPOGRAPHY_KEYS.include?(key)

data/lib/primer/classify/cache.rb

@@ -95,11 +95,6 @@ module Primer
             values: Primer::Classify::Flex::ALIGN_SELF_VALUES
           )
 
-          preload(
-            keys: [Primer::Classify::WIDTH_KEY, Primer::Classify::HEIGHT_KEY],
-            values: [:fit]
-          )
-
           preload(
             keys: Primer::Classify::BOX_SHADOW_KEY,
             values: [true, :small, :medium, :large, :extra_large, :none]

data/lib/primer/classify/utilities.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "yaml"
+
 # :nodoc:
 module Primer
   class Classify
@@ -16,6 +18,17 @@ module Primer
       # rubocop:enable Security/YAMLLoad
       BREAKPOINTS = ["", "-sm", "-md", "-lg", "-xl"].freeze
 
+      # Replacements for some classnames that end up being a different argument key
+      REPLACEMENT_KEYS = {
+        "^anim" => "animation",
+        "^v-align" => "vertical_align",
+        "^d" => "display",
+        "^wb" => "word_break",
+        "^v" => "visibility",
+        "^width" => "w",
+        "^height" => "h"
+      }.freeze
+
       class << self
         def classname(key, val, breakpoint = "")
           if (valid = validate(key, val, breakpoint))
@@ -104,23 +117,33 @@ module Primer
         private
 
         def find_selector(selector)
-          # Search each key/value_hash pair, eg. key `:mr` and value_hash `{ 0 => [ "mr-0", "mr-sm-0", "mr-md-0", "mr-lg-0", "mr-xl-0" ] }`
-          UTILITIES.each do |key, value_hash|
-            # Each value hash will also contain an array of classnames for breakpoints
-            # Key argument `0`, classes `[ "mr-0", "mr-sm-0", "mr-md-0", "mr-lg-0", "mr-xl-0" ]`
-            value_hash.each do |key_argument, classnames|
-              # Skip each value hash until we get one with the selector
-              next unless classnames.include?(selector)
-
-              # Return [:mr, 0, 1]
-              # has index of classname, so we can match it up with responsvie array `mr: [nil, 0]`
-              return [key, key_argument, classnames.index(selector)]
-            end
+          key = infer_selector_key(selector)
+          value_hash = UTILITIES[key]
+
+          return nil if value_hash.blank?
+
+          # Each value hash will also contain an array of classnames for breakpoints
+          # Key argument `0`, classes `[ "mr-0", "mr-sm-0", "mr-md-0", "mr-lg-0", "mr-xl-0" ]`
+          value_hash.each do |key_argument, classnames|
+            # Skip each value hash until we get one with the selector
+            next unless classnames.include?(selector)
+
+            # Return [:mr, 0, 1]
+            # has index of classname, so we can match it up with responsvie array `mr: [nil, 0]`
+            return [key, key_argument, classnames.index(selector)]
           end
 
           nil
         end
 
+        def infer_selector_key(selector)
+          REPLACEMENT_KEYS.each do |k, v|
+            return v.to_sym if selector.match?(Regexp.new(k))
+          end
+
+          selector.split("-").first.to_sym
+        end
+
         def validate(key, val, breakpoint)
           unless supported_key?(key)
             raise ArgumentError, "#{key} is not a valid Primer utility key" unless ENV["RAILS_ENV"] == "production"

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/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,74 @@
+# frozen_string_literal: true
+
+require "primer/view_components/constants"
+require "primer/classify/utilities"
+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)
+          system_arguments = system_arguments_to_args(classes.value)
+          args = classes_to_args(system_arguments[:classes])
+
+          args.merge(system_arguments.except(:classes))
+        end
+
+        # Override this with your component's mappings
+        def classes_to_args(classes)
+          raise ConversionError, "Cannot convert classes `#{classes}`" if classes.present?
+
+          {}
+        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
+      end
+    end
+  end
+end

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

@@ -1,66 +1,54 @@
 # 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
+        require "pry"
 
-        VARIANT_MAPPINGS = {
-          "btn-sm" => ":small",
-          "btn-large" => ":large"
-        }.freeze
+        SCHEME_MAPPINGS = Primer::ViewComponents::Constants.get(
+          component: "Primer::ButtonComponent",
+          constant: "SCHEME_MAPPINGS",
+          symbolize: true
+        ).freeze
 
-        TYPE_OPTIONS = %w[button reset submit].freeze
+        VARIANT_MAPPINGS = Primer::ViewComponents::Constants.get(
+          component: "Primer::ButtonComponent",
+          constant: "VARIANT_MAPPINGS",
+          symbolize: true
+        ).freeze
 
-        def initialize(tag)
-          @tag = tag
-        end
-
-        def to_s
-          to_args.map { |k, v| "#{k}: #{v}" }.join(", ")
-        end
-
-        def to_args
-          args = {}
+        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
 
-          args[:tag] = ":#{@tag.name}" unless @tag.name == "button"
+        ATTRIBUTES = %w[disabled type].freeze
 
-          @tag.attributes.each do |attribute|
-            attr_name = attribute.name
+        def attribute_to_args(attribute)
+          attr_name = attribute.name
 
-            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"
+          if attr_name == "disabled"
+            { disabled: true }
+          elsif attr_name == "type"
+            # button is the default type, so we don't need to do anything.
+            return {} 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({}) do |class_name, acc|
             next if class_name == "btn"
 
             if SCHEME_MAPPINGS[class_name] && acc[:scheme].nil?