primer_view_components 0.0.46 → 0.0.50

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|
@@ -38,7 +39,7 @@ module Primer
 
     # Use actions for a call to action.
     #
-    # @param tag [String] (Primer::UnderlineNavComponent::ACTIONS_TAG_DEFAULT) <%= one_of(Primer::UnderlineNavComponent::ACTIONS_TAG_OPTIONS) %>
+    # @param tag [Symbol] (Primer::UnderlineNavComponent::ACTIONS_TAG_DEFAULT) <%= one_of(Primer::UnderlineNavComponent::ACTIONS_TAG_OPTIONS) %>
     # @param system_arguments [Hash] <%= link_to_system_arguments_docs %>
     renders_one :actions, lambda { |tag: ACTIONS_TAG_DEFAULT, **system_arguments|
       system_arguments[:tag] = fetch_or_fallback(ACTIONS_TAG_OPTIONS, tag, ACTIONS_TAG_DEFAULT)
@@ -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

@@ -11,16 +11,6 @@ require_relative "classify/utilities"
 module Primer
   # :nodoc:
   class Classify
-    # Load the utilities.yml file.
-    # Disabling because we want to load symbols, strings, and integers from the .yml file
-    # rubocop:disable Security/YAMLLoad
-    UTILITIES = YAML.load(
-      File.read(
-        File.join(File.dirname(__FILE__), "./classify/utilities.yml")
-      )
-    ).freeze
-    # rubocop:enable Security/YAMLLoad
-
     # Keys where we can simply translate { key: value } into ".key-value"
     CONCAT_KEYS = %i[text box_shadow].freeze
 
@@ -90,7 +80,7 @@ module Primer
     BORDER_RADIUS_KEY = :border_radius
     TYPOGRAPHY_KEYS = [:font_size].freeze
     VALID_KEYS = (
-      UTILITIES.keys +
+      Primer::Classify::Utilities::UTILITIES.keys +
       CONCAT_KEYS +
       BOOLEAN_MAPPINGS.keys +
       BORDER_MARGIN_KEYS +
@@ -180,7 +170,9 @@ module Primer
       def extract_value(memo, key, val, breakpoint)
         return if val.nil? || val == ""
 
-        if Primer::Classify::Utilities.supported_key?(key)
+        if (key == WIDTH_KEY || key == HEIGHT_KEY) && !val.is_a?(Symbol)
+          memo[key] = val
+        elsif Primer::Classify::Utilities.supported_key?(key)
           memo[:classes] << Primer::Classify::Utilities.classname(key, val, breakpoint)
         elsif BOOLEAN_MAPPINGS.key?(key)
           BOOLEAN_MAPPINGS[key][:mappings].each do |m|
@@ -212,12 +204,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,17 +1,39 @@
 # frozen_string_literal: true
 
+require "yaml"
+
 # :nodoc:
 module Primer
   class Classify
     # Handler for PrimerCSS utility classes loaded from utilities.rake
     class Utilities
+      # Load the utilities.yml file.
+      # Disabling because we want to load symbols, strings, and integers from the .yml file
+      # rubocop:disable Security/YAMLLoad
+      UTILITIES = YAML.load(
+        File.read(
+          File.join(File.dirname(__FILE__), "./utilities.yml")
+        )
+      ).freeze
+      # 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"
+      }.freeze
+
       class << self
         def classname(key, val, breakpoint = "")
           if (valid = validate(key, val, breakpoint))
             valid
           else
             # Get selector
-            Primer::Classify::UTILITIES[key][val][Primer::Classify::BREAKPOINTS.index(breakpoint)]
+            UTILITIES[key][val][BREAKPOINTS.index(breakpoint)]
           end
         end
 
@@ -19,14 +41,14 @@ module Primer
         #
         # returns Boolean
         def supported_key?(key)
-          Primer::Classify::UTILITIES[key].present?
+          UTILITIES[key].present?
         end
 
         # Does the Utilitiy class support the given key and value
         #
         # returns Boolean
         def supported_value?(key, val)
-          supported_key?(key) && Primer::Classify::UTILITIES[key][val].present?
+          supported_key?(key) && UTILITIES[key][val].present?
         end
 
         # Does the given selector exist in the utilities file
@@ -34,7 +56,7 @@ module Primer
         # returns Boolean
         def supported_selector?(selector)
           # This method is too slow to run in production
-          return false if Rails.env.production?
+          return false if ENV["RAILS_ENV"] == "production"
 
           find_selector(selector).present?
         end
@@ -43,7 +65,7 @@ module Primer
         #
         # returns Boolean
         def responsive?(key, val)
-          supported_value?(key, val) && Primer::Classify::UTILITIES[key][val].count > 1
+          supported_value?(key, val) && UTILITIES[key][val].count > 1
         end
 
         # Get the options for the given key
@@ -52,13 +74,13 @@ module Primer
         def mappings(key)
           return unless supported_key?(key)
 
-          Primer::Classify::UTILITIES[key].keys
+          UTILITIES[key].keys
         end
 
         # Extract hash from classes ie. "mr-1 mb-2 foo" => { mr: 1, mb: 2, classes: "foo" }
         def classes_to_hash(classes)
           # This method is too slow to run in production
-          return { classes: classes } if Rails.env.production?
+          return { classes: classes } if ENV["RAILS_ENV"] == "production"
 
           obj = {}
           classes = classes.split(" ")
@@ -93,38 +115,48 @@ 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" ] }`
-          Primer::Classify::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 Rails.env.production?
+            raise ArgumentError, "#{key} is not a valid Primer utility key" unless ENV["RAILS_ENV"] == "production"
 
             return ""
           end
 
           unless breakpoint.empty? || responsive?(key, val)
-            raise ArgumentError, "#{key} does not support responsive values" unless Rails.env.production?
+            raise ArgumentError, "#{key} does not support responsive values" unless ENV["RAILS_ENV"] == "production"
 
             return ""
           end
 
           unless supported_value?(key, val)
-            raise ArgumentError, "#{val} is not a valid value for :#{key}. Use one of #{mappings(key)}" unless Rails.env.production?
+            raise ArgumentError, "#{val} is not a valid value for :#{key}. Use one of #{mappings(key)}" unless ENV["RAILS_ENV"] == "production"
 
             return ""
           end

data/lib/primer/classify/utilities.yml

@@ -85,6 +85,22 @@
   - float-md-none
   - float-lg-none
   - float-xl-none
+:width:
+  :fit:
+  - width-fit
+  :full:
+  - width-full
+  :auto:
+  - width-auto
+  - width-sm-auto
+  - width-md-auto
+  - width-lg-auto
+  - width-xl-auto
+:height:
+  :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