primer_view_components 0.0.85 → 0.0.86

data/lib/primer/forms/acts_as_component.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Primer
+  module Forms
+    # :nodoc:
+    module ActsAsComponent
+      # :nodoc:
+      module InstanceMethods
+        delegate :render, :content_tag, :output_buffer, :capture, to: :@view_context
+
+        def render_in(view_context, &block)
+          @view_context = view_context
+          before_render
+          perform_render(&block)
+        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)
+
+      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) %>
+  <% end %>
+<% end %>
+<% if after_content? %>
+  <%= render_after_content %>
+<% end %>

data/lib/primer/forms/base.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Primer
+  module Forms
+    # :nodoc:
+    class Base
+      extend ActsAsComponent
+
+      renders_template File.join(__dir__, "base.html.erb"), :render_base_form
+
+      class << self
+        attr_reader :has_after_content, :__vcf_form_block, :__vcf_builder
+        alias after_content? has_after_content
+
+        def form(&block)
+          @__vcf_form_block = block
+        end
+
+        def new(builder, **options)
+          allocate.tap do |form|
+            form.instance_variable_set(:@builder, builder)
+            form.send(:initialize, **options)
+          end
+        end
+
+        def inherited(base)
+          form_path = const_source_location(base.name)
+          return unless form_path
+
+          base.template_root_path = File.join(File.dirname(form_path), base.name.demodulize.underscore)
+
+          base.renders_template "after_content.html.erb" do
+            base.instance_variable_set(:@has_after_content, true)
+          end
+
+          base.renders_templates "*_caption.html.erb" do |path|
+            base.fields_with_caption_templates << File.basename(path).chomp("_caption.html.erb").to_sym
+          end
+        end
+
+        def caption_template?(field_name)
+          fields_with_caption_templates.include?(field_name)
+        end
+
+        def fields_with_caption_templates
+          @fields_with_caption_templates ||= []
+        end
+
+        private
+
+        # Unfortunately this bug (https://github.com/ruby/ruby/pull/5646) prevents us from using
+        # Ruby's native Module.const_source_location. Instead we have to fudge it by searching
+        # for the file in the configured autoload paths. Doing so relies on Rails' autoloading
+        # conventions, so it should work ok. Zeitwerk also has this information but lacks a
+        # public API to map constants to source files.
+        def const_source_location(class_name)
+          # NOTE: underscore respects namespacing, i.e. will convert Foo::Bar to foo/bar.
+          class_path = "#{class_name.underscore}.rb"
+
+          ActiveSupport::Dependencies.autoload_paths.each do |autoload_path|
+            absolute_path = File.join(autoload_path, class_path)
+            return absolute_path if File.exist?(absolute_path)
+          end
+
+          nil
+        end
+      end
+
+      def inputs
+        @inputs ||= form_object.inputs.map do |input|
+          next input unless input.input?
+
+          # wrap inputs in a group (unless they are already groups)
+          if input.type == :group
+            input
+          else
+            Primer::Forms::Dsl::InputGroup.new(builder: @builder, form: self) do |group|
+              group.send(:add_input, input)
+            end
+          end
+        end
+      end
+
+      def each_input_in(root_input, &block)
+        return enum_for(__method__, root_input) unless block
+
+        root_input.inputs.each do |input|
+          if input.respond_to?(:inputs)
+            each_input_in(input, &block)
+          else
+            yield input
+          end
+        end
+      end
+
+      def before_render
+        each_input_in(self) do |input|
+          if input.input? && input.invalid? && input.focusable?
+            input.autofocus!
+            break
+          end
+        end
+      end
+
+      def caption_template?(*args)
+        self.class.caption_template?(*args)
+      end
+
+      def after_content?(*args)
+        self.class.after_content?(*args)
+      end
+
+      def render_caption_template(name)
+        send(:"render_#{name}_caption")
+      end
+
+      def perform_render(&_block)
+        Base.compile!
+        self.class.compile!
+
+        render_base_form
+      end
+
+      private
+
+      def form_object
+        # rubocop:disable Naming/MemoizedInstanceVariableName
+        @__pf_form_object ||= Primer::Forms::Dsl::FormObject.new(builder: @builder, form: self).tap do |obj|
+          # compile before adding inputs so caption templates are identified
+          self.class.compile!
+          instance_exec(obj, &self.class.__vcf_form_block)
+        end
+        # rubocop:enable Naming/MemoizedInstanceVariableName
+      end
+    end
+  end
+end

data/lib/primer/forms/base_component.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "primer/class_name_helper"
+
+module Primer
+  module Forms
+    # :nodoc:
+    class BaseComponent
+      include Primer::ClassNameHelper
+      extend ActsAsComponent
+
+      def self.inherited(base)
+        base.renders_template File.join(__dir__, "#{base.name.demodulize.underscore}.html.erb"), :render_template
+      end
+
+      delegate :required?, :disabled?, :hidden?, to: :@input
+
+      def perform_render(&block)
+        @__prf_content_block = block
+        compile_and_render_template
+      end
+
+      def content
+        return @__prf_content if defined?(@__prf_content_evaluated) && @__prf_content_evaluated
+
+        @__prf_content_evaluated = true
+        @__prf_content = capture do
+          @__prf_content_block.call
+        end
+      end
+
+      # :nocov:
+      def type
+        :component
+      end
+      # :nocov:
+
+      def input?
+        false
+      end
+
+      private
+
+      def compile_and_render_template
+        self.class.compile! unless self.class.instance_methods(false).include?(:render_template)
+        render_template
+      end
+
+      def content_tag_if(condition, tag, **kwargs, &block)
+        if condition
+          content_tag(tag, **kwargs, &block)
+        else
+          capture(&block)
+        end
+      end
+    end
+  end
+end

data/lib/primer/forms/buffer_rewriter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module Primer
+  module Forms
+    # :nodoc:
+    class BufferRewriter < Ripper
+      class << self
+        def rewrite(code)
+          parser = new(code, "(code)", 0)
+          parser.parse
+
+          line_offsets = calc_line_offsets(code)
+
+          code.dup.tap do |result|
+            parser.var_refs.reverse_each do |lineno, stop|
+              line_offset = line_offsets[lineno]
+              start = (stop - "@output_buffer".length) + line_offset
+              stop += line_offset
+              result[start...stop] = "output_buffer"
+            end
+          end
+        end
+
+        private
+
+        def calc_line_offsets(code)
+          idx = -1
+
+          [0].tap do |offsets|
+            while (idx = code.index(/\r?\n/, idx + 1))
+              offsets << Regexp.last_match.end(0)
+            end
+          end
+        end
+      end
+
+      def on_var_ref(var)
+        return unless var == "@output_buffer"
+
+        var_refs << [lineno, column - 1]
+      end
+
+      def var_refs
+        @var_refs ||= []
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+<% if @input.caption? && !@input.caption.blank? %>
+  <span class="FormControl-caption" id="<%= @input.caption_id %>"><%= @input.caption %></span>
+<% elsif caption_template? %>
+  <% caption_template = render_caption_template %>
+  <% unless caption_template.blank? %>
+    <span class="FormControl-caption" id="<%= @input.caption_id %>">
+      <%= caption_template %>
+    </span>
+  <% end %>
+<% end %>

data/lib/primer/forms/caption.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Primer
+  module Forms
+    # :nodoc:
+    class Caption < BaseComponent
+      def initialize(input:)
+        @input = input
+      end
+
+      def caption_template?
+        @input.caption_template?
+      end
+
+      def render_caption_template
+        @input.render_caption_template
+      end
+
+      def before_render
+        return unless @input.caption? && caption_template?
+
+        raise <<~MESSAGE
+          Please provide either a caption: argument or caption template for the
+          '#{@input.name}' input; both were found.
+        MESSAGE
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+<div class="FormControl-checkbox-wrap">
+  <%= builder.check_box(@input.name, **@input.input_arguments) %>
+  <span class="FormControl-checkbox-labelWrap">
+    <%= builder.label(@input.name, **@input.label_arguments) do %>
+      <%= @input.label %>
+    <% end %>
+    <%= render(Caption.new(input: @input)) %>
+  </span>
+</div>

data/lib/primer/forms/check_box.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Primer
+  module Forms
+    # :nodoc:
+    class CheckBox < BaseComponent
+      delegate :builder, :form, to: :@input
+
+      def initialize(input:)
+        @input = input
+        @input.add_label_classes("FormControl-label")
+        @input.add_input_classes("FormControl-checkbox")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+<fieldset>
+  <% if @input.label %>
+    <%= content_tag(:legend, **@input.label_arguments) do %>
+      <%= @input.label %>
+    <% end %>
+  <% end %>
+  <%= render(SpacingWrapper.new) do %>
+    <% @input.check_boxes.each do |check_box| %>
+      <%= render(check_box) %>
+    <% end %>
+  <% end %>
+</fieldset>

data/lib/primer/forms/check_box_group.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Primer
+  module Forms
+    # :nodoc:
+    class CheckBoxGroup < BaseComponent
+      delegate :builder, :form, to: :@input
+
+      def initialize(input:)
+        @input = input
+      end
+    end
+  end
+end

data/lib/primer/forms/dsl/check_box_group_input.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Primer
+  module Forms
+    module Dsl
+      # :nodoc:
+      class CheckBoxGroupInput < Input
+        attr_reader :label, :check_boxes
+
+        def initialize(label: nil, **system_arguments)
+          @label = label
+          @check_boxes = []
+
+          super(**system_arguments)
+
+          add_label_classes("FormControl-label", "mb-2")
+
+          yield(self) if block_given?
+        end
+
+        def to_component
+          CheckBoxGroup.new(input: self)
+        end
+
+        def name
+          nil
+        end
+
+        def type
+          :check_box_group
+        end
+
+        def check_box(**system_arguments)
+          @check_boxes << CheckBoxInput.new(
+            builder: @builder, form: @form, **system_arguments
+          )
+        end
+      end
+    end
+  end
+end

data/lib/primer/forms/dsl/check_box_input.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Primer
+  module Forms
+    module Dsl
+      # :nodoc:
+      class CheckBoxInput < Input
+        attr_reader :name, :label
+
+        def initialize(name:, label:, **system_arguments)
+          @name = name
+          @label = label
+
+          super(**system_arguments)
+        end
+
+        def to_component
+          CheckBox.new(input: self)
+        end
+
+        def type
+          :check_box
+        end
+      end
+    end
+  end
+end

data/lib/primer/forms/dsl/form_object.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Primer
+  module Forms
+    module Dsl
+      # :nodoc:
+      class FormObject
+        include InputMethods
+
+        attr_reader :builder, :form
+
+        def initialize(builder:, form:)
+          @builder = builder
+          @form = form
+
+          yield(self) if block_given?
+        end
+
+        def group(**options, &block)
+          add_input InputGroup.new(builder: @builder, form: @form, **options, &block)
+        end
+      end
+    end
+  end
+end

data/lib/primer/forms/dsl/form_reference_input.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Primer
+  module Forms
+    module Dsl
+      # :nodoc:
+      class FormReferenceInput < Input
+        attr_reader :ref_block, :fields_for_args, :fields_for_kwargs
+
+        def initialize(*fields_for_args, builder:, form:, **fields_for_kwargs, &block)
+          @fields_for_args = fields_for_args
+          @fields_for_kwargs = fields_for_kwargs
+          @ref_block = block
+
+          super(builder: builder, form: form, **fields_for_kwargs)
+        end
+
+        def to_component
+          FormReference.new(input: self)
+        end
+
+        def name
+          nil
+        end
+
+        def label
+          nil
+        end
+
+        def type
+          :form
+        end
+      end
+    end
+  end
+end

data/lib/primer/forms/dsl/hidden_input.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Primer
+  module Forms
+    module Dsl
+      # :nodoc:
+      class HiddenInput < Input
+        attr_reader :name
+
+        def initialize(name:, **system_arguments)
+          @name = name
+          super(**system_arguments)
+        end
+
+        def to_component
+          HiddenField.new(input: self)
+        end
+
+        def label
+          nil
+        end
+
+        def type
+          :hidden
+        end
+      end
+    end
+  end
+end