openproject-primer_view_components 0.6.3

data/lib/primer/static/generate_arguments.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+require "json"
+
+module Primer
+  module Static
+    # :nodoc:
+    module GenerateArguments
+      class << self
+        def call(view_context: self.view_context)
+          Primer::Component.descendants.sort_by(&:name).map do |component|
+            docs = registry.find(component)
+            ref = Primer::Yard::ComponentManifest.ref_for(component)
+
+            args = docs.params.map do |tag|
+              default_value = Primer::Yard::DocsHelper.pretty_default_value(tag, component)
+
+              {
+                "name" => tag.name,
+                "type" => tag.types.join(", "),
+                "default" => default_value,
+                "description" => view_context.render(inline: tag.text.squish)
+              }
+            end
+
+            {
+              "component" => docs.metadata[:title],
+              "status" => component.status.to_s,
+              "a11y_reviewed" => docs.metadata[:a11y_reviewed] == "true",
+              "short_name" => docs.short_name,
+              "source" => ref.source_url,
+              "lookbook" => ref.lookbook_url,
+              "parameters" => args
+            }
+          end
+        end
+
+        private
+
+        def view_context
+          @view_context ||= ApplicationController.new.tap { |c| c.request = ActionDispatch::TestRequest.create }.view_context.tap do |vc|
+            vc.singleton_class.include(Primer::Yard::DocsHelper)
+            vc.singleton_class.include(Primer::ViewHelper)
+          end
+        end
+
+        def registry
+          @registry ||= Primer::Yard::Registry.make
+        end
+      end
+    end
+  end
+end

data/lib/primer/static/generate_audited_at.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# :nocov:
+module Primer
+  module Static
+    # :nodoc:
+    module GenerateAuditedAt
+      class << self
+        def call
+          Primer::Component.descendants.sort_by(&:name).each_with_object({}) do |component, mem|
+            mem[component.to_s] = component.audited_at.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/primer/static/generate_constants.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# :nocov:
+module Primer
+  module Static
+    # :nodoc:
+    module GenerateConstants
+      class << self
+        def call
+          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
+      end
+    end
+  end
+end

data/lib/primer/static/generate_info_arch.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+require "json"
+
+module Primer
+  module Static
+    # :nodoc:
+    module GenerateInfoArch
+      SKIP_METHODS = %i[call before_render].freeze
+
+      class << self
+        def call
+          components = Primer::Component.descendants.sort_by(&:name) - [Primer::BaseComponent]
+
+          component_docs = components.each_with_object({}) do |component, memo|
+            docs = registry.find(component)
+
+            preview_data = previews.find do |preview|
+              preview["component"] == docs.metadata[:title] &&
+                preview["status"] == component.status.to_s
+            end
+
+            arg_data = args.find do |component_args|
+              component_args["component"] == docs.metadata[:title] &&
+                component_args["status"] == component.status.to_s
+            end
+
+            slot_docs = docs.slot_methods.map do |slot_method|
+              param_tags = slot_method.tags(:param)
+
+              {
+                "name" => slot_method.name,
+                # rubocop:disable Style/IfUnlessModifier
+                "description" =>
+                  if slot_method.base_docstring.to_s.present?
+                    view_context.render(inline: slot_method.base_docstring)
+                  end,
+                # rubocop:enable Style/IfUnlessModifier
+                "parameters" => serialize_params(param_tags, component)
+              }
+            end
+
+            mtds = docs.non_slot_methods.select do |mtd|
+              next false if mtd.base_docstring.to_s.blank?
+              next false if SKIP_METHODS.include?(mtd.name)
+
+              method_location, = mtd.files.first
+              class_location, = docs.docs.files.first
+
+              method_location == class_location
+            end
+
+            method_docs = mtds.map do |mtd|
+              param_tags = mtd.tags(:param)
+
+              {
+                "name" => mtd.name,
+                "description" => view_context.render(inline: mtd.base_docstring),
+                "parameters" => serialize_params(param_tags, component)
+              }
+            end
+
+            description =
+              if component == Primer::BaseComponent
+                docs.base_docstring
+              else
+                view_context.render(inline: docs.base_docstring)
+              end
+
+            memo[component] = {
+              "fully_qualified_name" => component.name,
+              "description" => description,
+              "accessibility_docs" => docs.tags(:accessibility)&.first&.text,
+              "is_form_component" => docs.manifest_entry.form_component?,
+              "is_published" => docs.manifest_entry.published?,
+              "requires_js" => docs.manifest_entry.requires_js?,
+              **arg_data,
+              "slots" => slot_docs,
+              "methods" => method_docs,
+              "previews" => (preview_data || {}).fetch("examples", []),
+              "subcomponents" => []
+            }
+          end
+
+          statuses = Primer::Status::Dsl::STATUSES.keys.map(&:to_s).map(&:capitalize)
+
+          Primer::Component.descendants.each do |component|
+            fq_class = component.name.to_s.split("::")
+            fq_class.shift # remove Primer::
+            status = fq_class.shift if statuses.include?(fq_class.first) # remove Status::
+
+            parent, *child = *fq_class
+
+            next if child.empty?
+
+            parent_class = Primer
+            parent_class = parent_class.const_get(status) if status
+            parent_class = parent_class.const_get(parent)
+
+            parent_docs = component_docs[parent_class]
+            next unless parent_docs
+
+            if (child_docs = component_docs.delete(component))
+              parent_docs["subcomponents"] << child_docs
+            end
+          end
+
+          component_docs.values + [system_args_docs]
+        end
+
+        private
+
+        def system_args_docs
+          docs = registry.find(Primer::BaseComponent)
+
+          {
+            component: "BaseComponent",
+            fully_qualified_name: "Primer::BaseComponent",
+            description_md: docs.base_docstring,
+            args_md: view_context.render(inline: docs.constructor.base_docstring)
+          }
+        end
+
+        def serialize_params(param_tags, component)
+          param_tags.map do |tag|
+            default_value = Primer::Yard::DocsHelper.pretty_default_value(tag, component)
+
+            {
+              "name" => tag.name,
+              "type" => tag.types&.join(", ") || "",
+              "default" => default_value,
+              "description" => view_context.render(inline: tag.text.squish)
+            }
+          end
+        end
+
+        def previews
+          @previews ||= JSON.parse(Static.read(:previews))
+        end
+
+        def args
+          @args ||= Primer::Static::GenerateArguments.call(view_context: view_context)
+        end
+
+        def view_context
+          @view_context ||= ApplicationController.new.tap { |c| c.request = ActionDispatch::TestRequest.create }.view_context.tap do |vc|
+            vc.singleton_class.include(Primer::Yard::InfoArchDocsHelper)
+            vc.singleton_class.include(Primer::ViewHelper)
+          end
+        end
+
+        def registry
+          @registry ||= Primer::Yard::Registry.make
+        end
+      end
+    end
+  end
+end

data/lib/primer/static/generate_previews.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+require "json"
+
+module Primer
+  module Static
+    # :nodoc:
+    module GeneratePreviews
+      class << self
+        def call
+          Lookbook.previews.filter_map do |preview|
+            next if preview.preview_class == Primer::FormsPreview
+            next if Primer::Accessibility.ignore_preview?(preview.preview_class)
+
+            component = preview.components.first&.component_class
+
+            # rubocop:disable Style/IfUnlessModifier
+            unless component
+              raise "Could not determine which component `#{preview.preview_class}` is designed to preview. Please add a `@component` annotation."
+            end
+            # rubocop:enable Style/IfUnlessModifier
+
+            _, _, class_name = Primer::Yard::DocsHelper.status_module_and_short_name(component)
+
+            {
+              name: preview.name,
+              component: class_name,
+              status: component.status.to_s,
+              lookup_path: preview.lookup_path,
+              examples: preview.scenarios.flat_map do |parent_scenario|
+                scenarios = parent_scenario.type == :scenario_group ? parent_scenario.scenarios : [parent_scenario]
+
+                scenarios.map do |scenario|
+                  snapshot_tag = scenario.tags.find { |tag| tag.tag_name == "snapshot" }
+                  snapshot = if snapshot_tag.nil?
+                               "false"
+                             elsif snapshot_tag.text.blank?
+                               "true"
+                             else
+                               snapshot_tag.text
+                             end
+                  {
+                    preview_path: scenario.lookup_path,
+                    name: scenario.name,
+                    snapshot: snapshot,
+                    skip_rules: Primer::Accessibility.axe_rules_to_skip(
+                      component: component,
+                      scenario_name: scenario.name
+                    )
+                  }
+                end
+              end
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/primer/static/generate_statuses.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# :nocov:
+module Primer
+  module Static
+    # :nodoc:
+    module GenerateStatuses
+      class << self
+        def call
+          Primer::Component.descendants.sort_by(&:name).each_with_object({}) do |component, mem|
+            mem[component.to_s] = component.status.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/primer/static.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+require "json"
+
+module Primer
+  # :nodoc:
+  module Static
+    DEFAULT_STATIC_PATH = File.expand_path("static").freeze
+
+    FILE_NAMES = {
+      statuses: "statuses.json",
+      constants: "constants.json",
+      audited_at: "audited_at.json",
+      arguments: "arguments.json",
+      previews: "previews.json",
+      info_arch: "info_arch.json"
+    }.freeze
+
+    # Returns a hash mapping component names to component statuses (alpha, beta, etc),
+    # sorted alphabetically by the component name.
+    def self.generate_statuses
+      Static::GenerateStatuses.call
+    end
+
+    # Returns a hash mapping component names to the date on which the component passed
+    # an accessibility audit.
+    def self.generate_audited_at
+      Static::GenerateAuditedAt.call
+    end
+
+    # Returns a hash mapping component names to an array of the constants defined inside
+    # the component's class.
+    def self.generate_constants
+      Static::GenerateConstants.call
+    end
+
+    # Returns an array of hashes, one per Primer component, that contains some metadata and
+    # a list of the arguments accepted by the component's constructor. Arguments are enumerated
+    # with their value, data type, and docstring.
+    def self.generate_arguments
+      Static::GenerateArguments.call
+    end
+
+    # Returns an array of hashes, one per Primer component, that contains some metadata and
+    # an array of all the component's previews. The preview data contains the Lookbook URL
+    # to each preview and its name.
+    def self.generate_previews
+      Static::GeneratePreviews.call
+    end
+
+    # Returns an array of hashes, one per Primer component, that contains all the data needed
+    # for the new primer.style docsite.
+    def self.generate_info_arch
+      Static::GenerateInfoArch.call
+    end
+
+    # Generates the requested stat hash and outputs it to a file.
+    def self.dump(stats)
+      File.open(File.join(DEFAULT_STATIC_PATH, FILE_NAMES[stats]), "w") do |f|
+        f.write(JSON.pretty_generate(send("generate_#{stats}")))
+        f.write($INPUT_RECORD_SEPARATOR)
+      end
+    end
+
+    # Returns the contents of the stat file.
+    def self.read(stats)
+      File.read(File.join(DEFAULT_STATIC_PATH, FILE_NAMES[stats]))
+    end
+  end
+end

data/lib/primer/view_components/audited.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Primer
+  # :nodoc:
+  module ViewComponents
+    AUDITED = JSON.parse(
+      File.read(
+        File.join(File.dirname(__FILE__), "../../../static/audited_at.json")
+      )
+    ).freeze
+  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 = invert ? values.invert : values
+          # 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/engine.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "rails/engine"
+require "primer/classify/utilities"
+
+module Primer
+  module ViewComponents
+    # :nodoc:
+    class Engine < ::Rails::Engine
+      isolate_namespace Primer::ViewComponents
+
+      config.autoload_paths = %W[
+        #{root}/lib
+      ]
+
+      config.eager_load_paths = %W[
+        #{root}/app/components
+        #{root}/app/forms
+        #{root}/app/helpers
+        #{root}/app/lib
+      ]
+
+      config.primer_view_components = ActiveSupport::OrderedOptions.new
+
+      config.primer_view_components.raise_on_invalid_options = false
+      config.primer_view_components.silence_deprecations = false
+      config.primer_view_components.validate_class_names = !Rails.env.production?
+      config.primer_view_components.raise_on_invalid_aria = false
+
+      initializer "primer_view_components.assets" do |app|
+        app.config.assets.precompile += %w[primer_view_components] if app.config.respond_to?(:assets)
+      end
+
+      initializer "primer.eager_load_actions" do
+        ActiveSupport.on_load(:after_initialize) do
+          if Rails.application.config.eager_load
+            Primer::Forms::Base.compile!
+            Primer::Forms::Base.descendants.each(&:compile!)
+            Primer::Forms::BaseComponent.descendants.each(&:compile!)
+            Primer::Octicon::Cache.preload!
+          end
+        end
+      end
+
+      initializer "primer.forms.helpers" do
+        ActiveSupport.on_load :action_controller_base do
+          require "primer/form_helper"
+          helper Primer::FormHelper
+
+          # make primer_form_with available to view components also
+          ViewComponent::Base.prepend(Primer::FormHelper)
+        end
+      end
+
+      initializer "primer_view_components.zeitwerk_ignore" do
+        Rails.autoloaders.each do |autoloader|
+          autoloader.ignore(Engine.root.join("lib", "primer", "view_components", "linters.rb"))
+          autoloader.ignore(Engine.root.join("lib", "primer", "view_components", "linters", "**", "*.rb"))
+          autoloader.ignore(Engine.root.join("lib", "primer", "view_components", "statuses.rb"))
+          autoloader.ignore(Engine.root.join("lib", "primer", "view_components", "audited.rb"))
+        end
+      end
+
+      config.after_initialize do |app|
+        ::Primer::Classify::Utilities.validate_class_names = app.config.primer_view_components.delete(:validate_class_names)
+      end
+    end
+  end
+end

data/lib/primer/view_components/linters/accessibility.yml

@@ -0,0 +1,9 @@
+# Accessibility-focused lint rule configurations, tracked by accessibility scorecard.
+---
+linters:
+  NoUnusedDisable:
+    enabled: true
+  Primer::Accessibility::TooltippedMigration:
+    enabled: true
+  Primer::Accessibility::DetailsMenuMigration:
+    enabled: true

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]&.split || [])
+
+          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.
+        # @return { classes: Array, ... }
+        def classes_to_args(classes)
+          { classes: classes }
+        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