openproject-primer_view_components 0.6.3

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 = /text-|box-shadow-|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/classify.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative "classify/utilities"
+require_relative "classify/validation"
+
+module Primer
+  # :nodoc:
+  class Classify
+    FLEX_VALUES = [1, :auto].freeze
+
+    FLEX_WRAP_MAPPINGS = {
+      wrap: "flex-wrap",
+      nowrap: "flex-nowrap",
+      reverse: "flex-wrap-reverse"
+    }.freeze
+
+    FLEX_ALIGN_SELF_VALUES = [:auto, :start, :end, :center, :baseline, :stretch].freeze
+
+    FLEX_DIRECTION_VALUES = [:column, :column_reverse, :row, :row_reverse].freeze
+
+    FLEX_JUSTIFY_CONTENT_VALUES = [:flex_start, :flex_end, :center, :space_between, :space_around].freeze
+
+    FLEX_ALIGN_ITEMS_VALUES = [:flex_start, :flex_end, :center, :baseline, :stretch].freeze
+
+    LOOKUP = Primer::Classify::Utilities::UTILITIES
+
+    class << self
+      # Utility for mapping component configuration into Primer CSS class names.
+      #
+      # **args can contain utility keys that mimic the interface used by
+      # https://github.com/primer/components, as well as the special entries :classes
+      # and :style.
+      #
+      # Returns a hash containing two entries. The :classes entry is a string of
+      # Primer CSS class names, including any classes given in the :classes entry
+      # in **args. The :style entry is the value of the given :style entry given in
+      # **args.
+      #
+      #
+      # Example usage:
+      # extract_css_attrs({ mt: 4, py: 2 }) => { classes: "mt-4 py-2", style: nil }
+      # extract_css_attrs(classes: "d-flex", mt: 4, py: 2) => { classes: "d-flex mt-4 py-2", style: nil }
+      # extract_css_attrs(classes: "d-flex", style: "float: left", mt: 4, py: 2) => { classes: "d-flex mt-4 py-2", style: "float: left" }
+      #
+      def call(args = {})
+        style = nil
+        classes = [].tap do |result|
+          args.each do |key, val|
+            case key
+            when :classes
+              # insert :classes first to avoid huge doc diffs
+              if (class_names = validated_class_names(val))
+                result.unshift(class_names)
+              end
+              next
+            when :style
+              style = val
+              next
+            end
+
+            next unless LOOKUP[key]
+
+            if val.is_a?(Array)
+              # A while loop is ~3.5x faster than Array#each.
+              brk = 0
+              while brk < val.size
+                item = val[brk]
+
+                if item.nil?
+                  brk += 1
+                  next
+                end
+
+                # Believe it or not, three calls to Hash#[] and an inline rescue
+                # are about 30% faster than Hash#dig. It also ensures validate is
+                # only called when necessary, i.e. when the class can't be found
+                # in the lookup table.
+                # rubocop:disable Style/RescueModifier
+                found = (LOOKUP[key][item][brk] rescue nil) || validate(key, item, brk)
+                # rubocop:enable Style/RescueModifier
+                result << found if found
+                brk += 1
+              end
+            else
+              next if val.nil?
+
+              # rubocop:disable Style/RescueModifier
+              found = (LOOKUP[key][val][0] rescue nil) || validate(key, val, 0)
+              # rubocop:enable Style/RescueModifier
+              result << found if found
+            end
+          end
+        end.join(" ")
+
+        # This is much faster than Rails' presence method.
+        # rubocop:disable Rails/Blank
+        {
+          class: !classes || classes.empty? ? nil : classes,
+          style: !style || style.empty? ? nil : style
+        }
+        # rubocop:enable Rails/Blank
+      end
+
+      private
+
+      def validate(key, val, brk)
+        brk_str = Primer::Classify::Utilities::BREAKPOINTS[brk]
+        Primer::Classify::Utilities.validate(key, val, brk_str)
+      end
+
+      def validated_class_names(classes)
+        return if classes.blank?
+
+        if raise_on_invalid_options? && !ENV["PRIMER_WARNINGS_DISABLED"]
+          invalid_class_names =
+            classes.split.each_with_object([]) do |class_name, memo|
+              memo << class_name if Primer::Classify::Validation.invalid?(class_name)
+            end
+
+          if invalid_class_names.any?
+            raise ArgumentError, "Use System Arguments (https://primer.style/view-components/system-arguments) "\
+              "instead of Primer CSS class #{'name'.pluralize(invalid_class_names.length)} #{invalid_class_names.to_sentence}. "\
+              "This warning will not be raised in production. Set PRIMER_WARNINGS_DISABLED=1 to disable this warning."
+          end
+        end
+
+        classes
+      end
+
+      def raise_on_invalid_options?
+        Rails.application.config.primer_view_components.raise_on_invalid_options
+      end
+    end
+  end
+end

data/lib/primer/deprecations.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Primer
+  # :nodoc:
+  class Deprecations
+    class << self
+      def register(file_path)
+        data = YAML.load_file(file_path)
+        data["deprecations"].each do |dep|
+          register_deprecation(dep["component"], {
+                                 autocorrect: dep["autocorrect"],
+                                 guide: dep["guide"],
+                                 replacement: dep["replacement"]
+                               })
+        end
+      end
+
+      def register_deprecation(component, options)
+        registered_deprecations[component] = {
+          autocorrect: options[:autocorrect],
+          guide: options[:guide],
+          replacement: options[:replacement]
+        }
+      end
+
+      def deprecated_components
+        registered_deprecations.keys.sort
+      end
+
+      def deprecated?(component_name)
+        # if the component is registered, it is deprecated
+        registered_deprecations.key?(component_name)
+      end
+
+      def replacement?(component_name)
+        !replacement(component_name).nil?
+      end
+
+      def replacement(component_name)
+        dep = registered_deprecations[component_name]
+        return nil if dep.nil?
+
+        dep[:replacement]
+      end
+
+      def correctable?(component_name)
+        dep = registered_deprecations[component_name]
+        return false if dep.nil?
+
+        dep[:autocorrect]
+      end
+
+      def guide?(component_name)
+        !guide(component_name).nil?
+      end
+
+      def guide(component_name)
+        dep = registered_deprecations[component_name]
+        return nil if dep.nil?
+
+        dep[:guide]
+      end
+
+      def deprecation_message(component_name)
+        return nil unless deprecated?(component_name)
+
+        msg = ["'#{component_name}' has been deprecated."]
+
+        # this nested structure is complex, because it has to
+        # match all of the valid scenarios for a component being
+        # replaceable, auto-correctable, and having a guide. for
+        # more information on what is and is not valid, see the
+        # documentation here: docs/contributors/deprecations.md
+
+        if replacement?(component_name)
+          msg << "Please update your code to use '#{replacement(component_name)}'."
+          msg << "Use Rubocop's auto-correct, or replace it yourself." if correctable?(component_name)
+          msg << "See #{guide(component_name)} for more information." if guide?(component_name)
+        else # if there is no replacement, it must have a guide. this is enforced through tests
+          msg << "Unfortunately, there is no direct replacement."
+          msg << "See #{guide(component_name)} for more information and available options."
+        end
+
+        msg.join(" ")
+      end
+
+      private
+
+      def registered_deprecations
+        @registered_deprecations ||= {}
+      end
+    end
+
+    # auto-load PVC's deprecations
+    register(File.expand_path("deprecations.yml", __dir__))
+  end
+end

data/lib/primer/deprecations.yml

@@ -0,0 +1,45 @@
+# PVC Component Deprecations
+# --------------------------
+#
+# All component deprecations for PVC must be listed here, and must have valid configurations.
+# See 'docs/contributors/deprecations.md' for information on configuration options.
+
+deprecations:
+  - component: "Primer::Alpha::AutoComplete"
+    autocorrect: true
+    replacement: "Primer::Beta::AutoComplete"
+
+  - component: "Primer::Alpha::AutoComplete::Item"
+    autocorrect: true
+    replacement: "Primer::Beta::AutoComplete::Item"
+
+  - component: "Primer::BlankslateComponent"
+    autocorrect: true
+    replacement: "Primer::Beta::Blankslate"
+
+  - component: "Primer::ButtonComponent"
+    autocorrect: false
+    replacement: "Primer::Beta::Button"
+    guide: "https://primer.style/view-components/guides/primer_button_component"
+
+  - component: "Primer::IconButton"
+    autocorrect: true
+    replacement: "Primer::Beta::IconButton"
+
+  - component: "Primer::LayoutComponent"
+    autocorrect: false
+    replacement: "Primer::Alpha::Layout"
+    guide: "https://primer.style/view-components/guides/primer_layout_component"
+
+  - component: "Primer::Navigation::TabComponent"
+    autocorrect: true
+    replacement: "Primer::Alpha::Navigation::Tab"
+
+  - component: "Primer::Tooltip"
+    autocorrect: true
+    replacement: "Primer::Alpha::Tooltip"
+
+  - component: "Primer::Truncate"
+    autocorrect: false
+    replacement: "Primer::Beta::Truncate"
+    guide: "https://primer.style/view-components/guides/primer_truncate"

data/lib/primer/example_image.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nocov:
+module Primer
+  class ExampleImage
+    BASE64_SRC = "data:image/png;base64,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"
+  end
+end

data/lib/primer/form_components.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Primer
+  # :nocov:
+  # :nodoc:
+  class FormComponents
+    def self.from_input(input_klass)
+      Class.new(Primer::Component) do
+        @input_klass = input_klass
+
+        class << self
+          attr_reader :input_klass
+        end
+
+        def initialize(**system_arguments)
+          @system_arguments = system_arguments
+        end
+
+        def render_in(view_context, &block)
+          builder = Primer::Forms::Builder.new(
+            nil, nil, view_context, {}
+          )
+
+          # `block` is the block passed to `#render`. We pass it to the
+          # input's constructor here to mimic the way constructors often
+          # yield in the forms framework. Only allowing the block to be
+          # passed to `#initialize` is awkward because `#render` is often
+          # called without parens, making it non-obvious which method the
+          # block is passed to. Moreover, users of view components expect
+          # `#render` to accept a block and for that block to yield the
+          # component, which allows setting slots, etc. They do not expect
+          # that block to be accepted by the component's initializer
+          # instead.
+          #
+          # One caveat here is that not all form input classes yield
+          # themselves to the block. In such a case, the block will
+          # never be called, which is potentially confusing. We could
+          # detect whether or not the block is called and yield the input
+          # if it is not, but that comes with its own set of problems and
+          # could also lead to confusion (for example, if the block is
+          # conditionally called with one set of arguments from the input
+          # and then a different set of arguments here). Since we can't
+          # know which arguments the input will yield, it's safer to simply
+          # pass the block as-is.
+          input = self.class.input_klass.new(
+            builder: builder,
+            form: nil,
+            **@system_arguments,
+            &block
+          )
+
+          input.to_component.render_in(view_context) { content }
+        end
+      end
+    end
+  end
+end

data/lib/primer/forms/acts_as_component.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Primer
+  module Forms
+    # :nodoc:
+    module ActsAsComponent
+      # :nodoc:
+      module InstanceMethods
+        delegate :render, :content_tag, :output_buffer, to: :@view_context
+
+        def render_in(view_context, &block)
+          @view_context = view_context
+          before_render
+          perform_render(&block)
+        end
+
+        # This is necessary to restore the functionality changed by https://github.com/rails/rails/pull/47194.
+        # I would love to remove this at some point, perhaps if we ever decide to replace
+        # ActsAsComponent with view component.
+        def capture(*args, &block)
+          old_buffer = @view_context.output_buffer
+          @view_context.output_buffer = ActionView::OutputBuffer.new
+          @view_context.capture(*args, &block)
+        ensure
+          @view_context.output_buffer = old_buffer
+        end
+
+        # :nocov:
+        def perform_render(&_block)
+          raise NotImplementedError, "subclasses must implement ##{__method__}."
+        end
+        # :nocov:
+
+        def before_render; end
+
+        # :nocov:
+        # rubocop:disable Naming/AccessorMethodName
+        def set_original_view_context(view_context)
+          @view_context = view_context
+        end
+        # rubocop:enable Naming/AccessorMethodName
+        # :nocov:
+      end
+
+      def self.extended(base)
+        base.include(InstanceMethods)
+      end
+
+      TemplateGlob = Struct.new(:glob_pattern, :method_name, :on_compile_callback)
+      TemplateParams = Struct.new(:source, :identifier, :type, :format, keyword_init: true)
+
+      attr_accessor :template_root_path
+
+      def renders_templates(glob_pattern, method_name = nil, &block)
+        template_globs << TemplateGlob.new(glob_pattern, method_name, block)
+      end
+      alias renders_template renders_templates
+
+      def compile!
+        # always recompile in dev
+        return if defined?(@compiled) && @compiled && !Rails.env.development?
+
+        template_globs.each do |template_glob|
+          compile_templates_in(template_glob)
+        end
+
+        @compiled = true
+      end
+
+      private
+
+      def template_globs
+        @template_globs ||= []
+      end
+
+      def compile_templates_in(template_glob)
+        pattern = if Pathname(template_glob.glob_pattern).absolute?
+                    template_glob.glob_pattern
+                  else
+                    # skip compilation for anonymous form classes, as in tests
+                    return unless template_root_path
+
+                    File.join(template_root_path, template_glob.glob_pattern)
+                  end
+
+        template_paths = Dir.glob(pattern)
+
+        raise "Cannot compile multiple templates with the same method name." if template_paths.size > 1 && template_glob.method_name
+
+        template_paths.each do |template_path|
+          method_name = template_glob.method_name
+          method_name ||= "render_#{File.basename(template_path).chomp('.html.erb')}"
+          define_template_method(template_path, method_name)
+          template_glob&.on_compile_callback&.call(template_path)
+        end
+      end
+
+      def define_template_method(template_path, method_name)
+        # rubocop:disable Style/DocumentDynamicEvalDefinition
+        # rubocop:disable Style/EvalWithLocation
+        class_eval <<-RUBY, template_path, 0
+        private def #{method_name}
+          capture { #{compile_template(template_path)} }
+        end
+        RUBY
+        # rubocop:enable Style/EvalWithLocation
+        # rubocop:enable Style/DocumentDynamicEvalDefinition
+      end
+
+      def compile_template(path)
+        handler = ActionView::Template.handler_for_extension("erb")
+        template = File.read(path)
+        template_params = TemplateParams.new({
+                                               source: template,
+                                               identifier: __FILE__,
+                                               type: "text/html",
+                                               format: "text/html"
+                                             })
+
+        # change @output_buffer ivar to output_buffer method call
+        BufferRewriter.rewrite(
+          handler.call(template_params, template)
+        )
+      end
+    end
+  end
+end

data/lib/primer/forms/base.html.erb

@@ -0,0 +1,8 @@
+<%= render(SpacingWrapper.new) do %>
+  <% inputs.each do |input| %>
+    <%= render(input.to_component) %>
+  <% end %>
+<% end %>
+<% if after_content? %>
+  <%= render_after_content %>
+<% end %>