primer_view_components 0.0.85 → 0.0.86

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

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+require "primer/classify"
+
+module Primer
+  module Forms
+    module Dsl
+      # :nodoc:
+      class Input
+        SPACE_DELIMITED_ARIA_ATTRIBUTES = %i[describedby].freeze
+        DEFAULT_SIZE = :medium
+        SIZE_MAPPINGS = {
+          :small => "FormControl-small",
+          DEFAULT_SIZE => "FormControl-medium",
+          :large => "FormControl-large"
+        }.freeze
+        SIZE_OPTIONS = SIZE_MAPPINGS.keys
+
+        UTILITY_KEYS = Primer::Classify::Utilities::UTILITIES.keys.freeze
+
+        include Primer::ClassNameHelper
+
+        attr_reader :builder, :form, :input_arguments, :label_arguments, :caption, :validation_message, :ids
+
+        def initialize(builder:, form:, **system_arguments)
+          @builder = builder
+          @form = form
+
+          @input_arguments = system_arguments
+          process_classes!(@input_arguments)
+
+          @label_arguments = @input_arguments.delete(:label_arguments) || {}
+          process_classes!(@label_arguments)
+
+          @label_arguments[:class] = class_names(
+            @label_arguments[:class],
+            @input_arguments.fetch(:visually_hide_label, true) ? "sr-only" : nil
+          )
+
+          @input_arguments.delete(:visually_hide_label)
+
+          @input_arguments.delete(:class) if @input_arguments[:class].blank?
+          @label_arguments.delete(:class) if @label_arguments[:class].blank?
+
+          @caption = @input_arguments.delete(:caption)
+          @validation_message = @input_arguments.delete(:validation_message)
+          @invalid = @input_arguments.delete(:invalid)
+          @full_width = @input_arguments.delete(:full_width)
+          @size = @input_arguments.delete(:size)
+
+          @input_arguments[:invalid] = "true" if invalid?
+
+          base_id = SecureRandom.hex[0..5]
+
+          @ids = {}.tap do |id_map|
+            id_map[:validation] = "validation-#{base_id}" if invalid?
+            id_map[:caption] = "caption-#{base_id}" if caption? || caption_template?
+          end
+
+          add_input_aria(:required, true) if required?
+          add_input_aria(:describedby, ids.values) if ids.any?
+
+          # avoid browser-native validation, which doesn't match Primer's style
+          input_arguments.delete(:required)
+        end
+
+        def add_input_classes(*class_names)
+          input_arguments[:class] = class_names(
+            input_arguments[:class], *class_names
+          )
+        end
+
+        def add_label_classes(*class_names)
+          label_arguments[:class] = class_names(
+            label_arguments[:class], *class_names
+          )
+        end
+
+        def add_input_aria(key, value)
+          @input_arguments[:aria] ||= {}
+
+          @input_arguments[:aria][key] = if space_delimited_aria_attribute?(key)
+                                           aria_join(@input_arguments[:aria][key], *Array(value))
+                                         else
+                                           value
+                                         end
+        end
+
+        def add_input_data(key, value)
+          input_data[key] = value
+        end
+
+        def remove_input_data(key)
+          input_data.delete(key)
+        end
+
+        def merge_input_arguments!(arguments)
+          arguments.each do |k, v|
+            case k
+            when :class, :classes, "class", "classes"
+              add_input_classes(v)
+            when :aria, "aria"
+              v.each do |aria_k, aria_v|
+                add_input_aria(aria_k, aria_v)
+              end
+            when :data, "data"
+              v.each do |data_k, data_v|
+                add_input_data(data_k, data_v)
+              end
+            else
+              @input_arguments[k] = v
+            end
+          end
+        end
+
+        def validation_id
+          ids[:validation]
+        end
+
+        def caption_id
+          ids[:caption]
+        end
+
+        def caption?
+          caption.present?
+        end
+
+        def caption_template?
+          return false unless form
+
+          form.caption_template?(caption_template_name)
+        end
+
+        def render_caption_template
+          form.render_caption_template(caption_template_name)
+        end
+
+        def valid?
+          validation_messages.empty? && !@invalid
+        end
+
+        def invalid?
+          !valid?
+        end
+
+        def hidden?
+          !!input_arguments[:hidden]
+        end
+
+        def required?
+          input_arguments[:required] ||
+            input_arguments[:aria_required] ||
+            input_arguments[:"aria-required"] ||
+            input_arguments.dig(:aria, :required)
+        end
+
+        def disabled?
+          input_arguments.include?(:disabled)
+        end
+
+        def full_width?
+          @full_width
+        end
+
+        def size
+          @size ||= SIZE_MAPPINGS.include?(@size) ? @size : DEFAULT_SIZE
+        end
+
+        def validation_messages
+          @validation_messages ||=
+            if validation_message
+              [validation_message]
+            elsif builder.object.respond_to?(:errors)
+              name ? builder.object.errors.full_messages_for(name) : []
+            else
+              []
+            end
+        end
+
+        def autofocus!
+          input_arguments[:autofocus] = true
+        end
+
+        # :nocov:
+        def name
+          raise_for_abstract_method!(__method__)
+        end
+
+        def label
+          raise_for_abstract_method!(__method__)
+        end
+
+        def type
+          raise_for_abstract_method!(__method__)
+        end
+
+        def to_component
+          raise_for_abstract_method!(__method__)
+        end
+        # :nocov:
+
+        def focusable?
+          false
+        end
+
+        def input?
+          true
+        end
+
+        # Avoid using Rails delegation here for performance reasons
+        # rubocop:disable Rails/Delegate
+        def render_in(view_context)
+          to_component.render_in(view_context)
+        end
+        # rubocop:enable Rails/Delegate
+
+        private
+
+        def process_classes!(args)
+          args[:classes] = class_names(args.delete(:class), args[:classes])
+          args.merge!(Primer::Classify.call(args))
+          args[:class] = class_names(args[:class], args.delete(:classes))
+          args.except!(*UTILITY_KEYS)
+          args
+        end
+
+        def input_data
+          @input_arguments[:data] ||= {}
+        end
+
+        def caption_template_name
+          return nil unless name
+
+          @caption_template_name ||= if respond_to?(:value)
+                                       :"#{name}_#{value}"
+                                     else
+                                       name.to_sym
+                                     end
+        end
+
+        def space_delimited_aria_attribute?(attrib)
+          SPACE_DELIMITED_ARIA_ATTRIBUTES.include?(attrib)
+        end
+
+        def aria_join(*values)
+          values = values.flat_map { |v| v.to_s.split }
+          values.reject!(&:empty?)
+          values.join(" ")
+        end
+
+        # :nocov:
+        def raise_for_abstract_method!(method_name)
+          raise NotImplementedError, "subclasses must implement ##{method_name}."
+        end
+        # :nocov:
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Primer
+  module Forms
+    module Dsl
+      # :nodoc:
+      class InputGroup
+        include InputMethods
+
+        attr_reader :builder, :form, :system_arguments
+
+        def initialize(builder:, form:, **system_arguments)
+          @builder = builder
+          @form = form
+          @system_arguments = system_arguments
+
+          yield(self) if block_given?
+        end
+
+        def to_component
+          Group.new(inputs: inputs, builder: builder, form: form, **@system_arguments)
+        end
+
+        def type
+          :group
+        end
+
+        def input?
+          true
+        end
+
+        # Avoid using Rails delegation here for performance reasons
+        # rubocop:disable Rails/Delegate
+        def render_in(view_context)
+          to_component.render_in(view_context)
+        end
+        # rubocop:enable Rails/Delegate
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Primer
+  module Forms
+    module Dsl
+      # :nodoc:
+      module InputMethods
+        def fields_for(*args, **kwargs, &block)
+          add_input FormReferenceInput.new(*args, builder: builder, form: form, **kwargs, &block)
+        end
+
+        def multi(**options, &block)
+          add_input MultiInput.new(builder: builder, form: form, **options, &block)
+        end
+
+        def hidden(**options)
+          add_input HiddenInput.new(builder: builder, form: form, **options)
+        end
+
+        def check_box(**options)
+          add_input CheckBoxInput.new(builder: builder, form: form, **options)
+        end
+
+        def radio_button_group(**options, &block)
+          add_input RadioButtonGroupInput.new(builder: builder, form: form, **options, &block)
+        end
+
+        def check_box_group(**options, &block)
+          add_input CheckBoxGroupInput.new(builder: builder, form: form, **options, &block)
+        end
+
+        def separator
+          add_input Separator.new
+        end
+
+        # START text input methods
+
+        def text_field(**options, &block)
+          options = decorate_options(**options)
+          add_input TextFieldInput.new(builder: builder, form: form, **options, &block)
+        end
+
+        def text_area(**options, &block)
+          options = decorate_options(**options)
+          add_input TextAreaInput.new(builder: builder, form: form, **options, &block)
+        end
+
+        # END text input methods
+
+        # START select input methods
+
+        def select_list(**options, &block)
+          options = decorate_options(**options)
+          add_input SelectListInput.new(builder: builder, form: form, **options, &block)
+        end
+
+        # END select input methods
+
+        # START button input methods
+
+        def submit(**options, &block)
+          options = decorate_options(**options)
+          add_input SubmitButtonInput.new(builder: builder, form: form, **options, &block)
+        end
+
+        # END button input methods
+
+        def inputs
+          @inputs ||= []
+        end
+
+        private
+
+        def add_input(input)
+          inputs << input
+        end
+
+        # Called before the corresponding Input class is instantiated. The return value of this method is passed
+        # to the Input class's constructor.
+        def decorate_options(**options)
+          options
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Primer
+  module Forms
+    module Dsl
+      # :nodoc:
+      class MultiInput < Input
+        include InputMethods
+
+        attr_reader :name, :label
+
+        def initialize(name:, label:, **system_arguments)
+          @name = name
+          @label = label
+
+          super(**system_arguments)
+
+          yield(self) if block_given?
+        end
+
+        def to_component
+          Multi.new(input: self)
+        end
+
+        def type
+          :multi
+        end
+
+        private
+
+        def add_input(input)
+          super
+
+          check_one_input_visible!
+        end
+
+        def decorate_options(name: nil, **options)
+          check_name!(name) if name
+          new_options = { name: name || @name, label: nil, **options }
+          new_options[:id] = nil if options[:hidden]
+          new_options
+        end
+
+        def check_name!(name)
+          return if name == @name
+
+          raise ArgumentError, "Inputs inside a `multi' block must all have the same name. Expected '#{@name}', got '#{name}'."
+        end
+
+        def check_one_input_visible!
+          return if inputs.count { |input| !input.hidden? } <= 1
+
+          raise ArgumentError, "Only one input can be visible at a time in a `multi' block."
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Primer
+  module Forms
+    module Dsl
+      # :nodoc:
+      class RadioButtonGroupInput < Input
+        attr_reader :name, :label, :radio_buttons
+
+        def initialize(name:, label: nil, **system_arguments)
+          @name = name
+          @label = label
+          @radio_buttons = []
+
+          super(**system_arguments)
+
+          add_label_classes("FormControl-label", "mb-2")
+
+          yield(self) if block_given?
+        end
+
+        def to_component
+          RadioButtonGroup.new(input: self)
+        end
+
+        def type
+          :radio_button_group
+        end
+
+        def radio_button(**system_arguments, &block)
+          @radio_buttons << RadioButtonInput.new(
+            builder: @builder, form: @form, name: @name, **system_arguments, &block
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Primer
+  module Forms
+    module Dsl
+      # :nodoc:
+      class RadioButtonInput < Input
+        attr_reader :name, :value, :label, :nested_form_block, :nested_form_arguments
+
+        def initialize(name:, value:, label:, **system_arguments)
+          @name = name
+          @value = value
+          @label = label
+
+          super(**system_arguments)
+
+          yield(self) if block_given?
+        end
+
+        def to_component
+          RadioButton.new(input: self)
+        end
+
+        def nested_form(**system_arguments, &block)
+          @nested_form_arguments = system_arguments
+          @nested_form_block = block
+        end
+
+        # :nocov:
+        def type
+          :radio_button
+        end
+        # :nocov:
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Primer
+  module Forms
+    module Dsl
+      # :nodoc:
+      class SelectListInput < Input
+        # :nodoc:
+        class Option
+          attr_reader :label, :value, :system_arguments
+
+          def initialize(label:, value:, **system_arguments)
+            @label = label
+            @value = value
+            @system_arguments = system_arguments
+          end
+        end
+
+        attr_reader :name, :label, :options
+
+        def initialize(name:, label:, **system_arguments)
+          @name = name
+          @label = label
+          @options = []
+
+          super(**system_arguments)
+
+          yield(self) if block_given?
+        end
+
+        def option(**system_arguments)
+          @options << Option.new(**system_arguments)
+        end
+
+        def to_component
+          SelectList.new(input: self)
+        end
+
+        # :nocov:
+        def type
+          :select_list
+        end
+        # :nocov:
+
+        # :nocov:
+        def focusable?
+          true
+        end
+        # :nocov:
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Primer
+  module Forms
+    module Dsl
+      # :nodoc:
+      class SubmitButtonInput < Input
+        attr_reader :name, :label, :block
+
+        def initialize(name:, label:, **system_arguments, &block)
+          @name = name
+          @label = label
+          @block = block
+
+          super(**system_arguments)
+        end
+
+        def to_component
+          SubmitButton.new(input: self)
+        end
+
+        def type
+          :submit_button
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Primer
+  module Forms
+    module Dsl
+      # :nodoc:
+      class TextAreaInput < Input
+        attr_reader :name, :label
+
+        def initialize(name:, label:, **system_arguments)
+          @name = name
+          @label = label
+
+          super(**system_arguments)
+        end
+
+        def to_component
+          TextArea.new(input: self)
+        end
+
+        def type
+          :text_area
+        end
+
+        # :nocov:
+        def focusable?
+          true
+        end
+        # :nocov:
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Primer
+  module Forms
+    module Dsl
+      # :nodoc:
+      class TextFieldInput < Input
+        attr_reader(
+          *%i[
+            name label show_clear_button leading_visual clear_button_id
+            visually_hide_label inset monospace field_wrap_classes
+          ]
+        )
+
+        def initialize(name:, label:, **system_arguments)
+          @name = name
+          @label = label
+
+          @show_clear_button = system_arguments.delete(:show_clear_button)
+          @leading_visual = system_arguments.delete(:leading_visual)
+          @clear_button_id = system_arguments.delete(:clear_button_id)
+          @inset = system_arguments.delete(:inset)
+          @monospace = system_arguments.delete(:monospace)
+
+          super(**system_arguments)
+
+          add_input_classes(
+            "FormControl-input",
+            Primer::Forms::Dsl::Input::SIZE_MAPPINGS[size]
+          )
+
+          add_input_classes("FormControl-inset") if inset?
+          add_input_classes("FormControl-monospace") if monospace?
+
+          @field_wrap_classes = class_names(
+            "FormControl-input-wrap",
+            Primer::Forms::Dsl::Input::SIZE_MAPPINGS[size],
+            "FormControl-input-wrap--trailingAction": show_clear_button?,
+            "FormControl-input-wrap--leadingVisual": leading_visual?
+          )
+        end
+
+        alias show_clear_button? show_clear_button
+        alias inset? inset
+        alias monospace? monospace
+
+        def to_component
+          TextField.new(input: self)
+        end
+
+        def type
+          :text_field
+        end
+
+        def focusable?
+          true
+        end
+
+        def leading_visual?
+          !!@leading_visual
+        end
+      end
+    end
+  end
+end