yattho_view_components 0.0.1

data/lib/yattho/forms/base.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Yattho
+  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)
+          if builder && !builder.is_a?(Yattho::Forms::Builder)
+            raise ArgumentError, "please pass an instance of Yattho::Forms::Builder when " \
+                                 "constructing a form object (consider using the `yattho_form_with` helper)"
+          end
+
+          allocate.tap do |form|
+            form.instance_variable_set(:@builder, builder)
+            form.send(:initialize, **options)
+          end
+        end
+
+        def inherited(base)
+          form_path = Utils.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?(sanitize_field_name_for_template_path(field_name))
+        end
+
+        def fields_with_caption_templates
+          @fields_with_caption_templates ||= []
+        end
+
+        def sanitize_field_name_for_template_path(field_name)
+          field_name.to_s.delete_suffix("?").to_sym
+        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
+            Yattho::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(field_name)
+        send(:"render_#{self.class.sanitize_field_name_for_template_path(field_name)}_caption")
+      end
+
+      def perform_render(&_block)
+        return "" unless render?
+
+        Base.compile!
+        self.class.compile!
+
+        render_base_form
+      end
+
+      def render?
+        true
+      end
+
+      private
+
+      def form_object
+        # rubocop:disable Naming/MemoizedInstanceVariableName
+        @__pf_form_object ||= Yattho::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/yattho/forms/base_component.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "yattho/class_name_helper"
+
+module Yattho
+  module Forms
+    # :nodoc:
+    class BaseComponent
+      include Yattho::ClassNameHelper
+      extend ActsAsComponent
+
+      def self.inherited(base)
+        base_path = Utils.const_source_location(base.name)
+
+        unless base_path
+          warn "Could not identify the template for #{base}"
+          return
+        end
+
+        dir = File.dirname(base_path)
+        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)
+        return "" unless render?
+
+        @__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
+
+      def to_component
+        self
+      end
+
+      def render?
+        true
+      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/yattho/forms/buffer_rewriter.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module Yattho
+  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]
+              stop += line_offset
+              stop -= 1 if stop < code.length
+              start = stop - "@output_buffer".length
+              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]
+      end
+
+      def var_refs
+        @var_refs ||= []
+      end
+    end
+  end
+end

data/lib/yattho/forms/builder.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "yattho/classify"
+
+# See: https://github.com/rails/rails/pull/46666
+ActionView::Helpers::Tags::Base.prepend(
+  Module.new do
+    def initialize(*args, **kwargs, &block)
+      super
+
+      return if defined?(@generate_error_markup)
+
+      @generate_error_markup = @options.delete(:generate_error_markup) { true }
+    end
+
+    private
+
+    def error_wrapping(html_tag)
+      return html_tag unless @generate_error_markup
+
+      # :nocov:
+      super
+      # :nocov:
+    end
+  end
+)
+
+module Yattho
+  module Forms
+    # :nodoc:
+    class Builder < ActionView::Helpers::FormBuilder
+      include Yattho::ClassNameHelper
+
+      UTILITY_KEYS = Yattho::Classify::Utilities::UTILITIES.keys.freeze
+
+      alias yattho_fields_for fields_for
+
+      def label(method, text = nil, **options, &block)
+        super(method, text, classify(options).merge(generate_error_markup: false), &block)
+      end
+
+      def check_box(method, options = {}, checked_value = 1, unchecked_value = 0, &block)
+        super(
+          method,
+          classify(options).merge(generate_error_markup: false),
+          checked_value,
+          unchecked_value,
+          &block
+        )
+      end
+
+      def radio_button(*args, **options, &block)
+        super(*args, classify(options).merge(generate_error_markup: false), &block)
+      end
+
+      def select(method, choices = nil, options = {}, html_options = {}, &block)
+        super(method, choices, options.merge(generate_error_markup: false), classify(html_options), &block)
+      end
+
+      def text_field(*args, **options, &block)
+        super(*args, classify(options).merge(generate_error_markup: false), &block)
+      end
+
+      def text_area(*args, **options, &block)
+        super(*args, classify(options).merge(generate_error_markup: false), &block)
+      end
+
+      private
+
+      # This method does the following:
+      #
+      # 1. Runs Yattho's classify routine to convert entries like mb: 1 to mb-1.
+      # 2. Runs classify on both options[:class] and options[:classes]. The first
+      #    is expected by Rails/HTML while the second is specific to Yattho.
+      # 3. Combines options[:class] and options[:classes] into options[:class]
+      #    so the options hash can be easily passed to Rails form builder methods.
+      #
+      def classify(options)
+        options[:classes] = class_names(options.delete(:class), options[:classes])
+        options.merge!(Yattho::Classify.call(options))
+        options.except!(*UTILITY_KEYS)
+        options[:class] = class_names(options[:class], options.delete(:classes))
+        options
+      end
+    end
+  end
+end

data/lib/yattho/forms/button.html.erb

@@ -0,0 +1,4 @@
+<%= render(Yattho::Beta::Button.new(**input_arguments)) do |component| %>
+  <% @input.block.call(component) if @input.block %>
+  <%= @input.label %>
+<% end %>

data/lib/yattho/forms/button.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Yattho
+  module Forms
+    # :nodoc:
+    class Button < BaseComponent
+      # :nodoc:
+      module ButtonAttributeGenerator
+        extend ActionView::Helpers::FormTagHelper
+
+        class << self
+          alias submit_tag_attributes submit_tag
+          alias button_tag_attributes button_tag
+
+          private
+
+          # FormTagHelper#submit_tag ultimately calls the #tag method. We return the options hash here instead
+          # of returning a string so it can be merged into the hash of options we pass to the Yattho::ButtonComponent.
+          def tag(_name, options)
+            options
+          end
+
+          # FormTagHelper#button_tag ultimately calls the #content_tag method. We return the options hash here instead
+          # of returning a string so it can be merged into the hash of options we pass to the Yattho::ButtonComponent.
+          def content_tag(_name, _content, options)
+            options
+          end
+        end
+      end
+
+      delegate :builder, :form, to: :@input
+
+      def initialize(input:, type: :button)
+        @input = input
+        @type = type
+
+        @input.add_input_classes("FormField-input flex-self-start")
+        @input.merge_input_arguments!(tag_attributes.deep_symbolize_keys)
+
+        # rails uses a string for this, but YVC wants a symbol
+        @input.merge_input_arguments!(type: type.to_sym)
+
+        # Never disable buttons. This overrides the global
+        # ActionView::Base.automatically_disable_submit_tag setting.
+        # Disabling buttons is not accessible.
+        @input.remove_input_data(:disable_with)
+      end
+
+      def input_arguments
+        @input_arguments ||= @input.input_arguments.deep_dup.tap do |args|
+          # rails uses :class but YVC wants :classes
+          args[:classes] = args.delete(:class)
+        end
+      end
+
+      private
+
+      def tag_attributes
+        case @type
+        when :submit
+          ButtonAttributeGenerator.submit_tag_attributes(@input.label, name: @input.name)
+        else
+          ButtonAttributeGenerator.button_tag_attributes(@input.label, name: @input.name)
+        end
+      end
+    end
+  end
+end

data/lib/yattho/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/yattho/forms/caption.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Yattho
+  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/yattho/forms/check_box.html.erb

@@ -0,0 +1,16 @@
+<%= content_tag(:div, class: "FormControl-checkbox-wrap", hidden: @input.hidden?) do %>
+  <%= builder.check_box(@input.name, @input.input_arguments, checked_value, unchecked_value) %>
+  <span class="FormControl-checkbox-labelWrap">
+    <%= builder.label(@input.name, **@input.label_arguments) do %>
+      <%= @input.label %>
+    <% end %>
+    <% if @input.form_control? %>
+      <%= render(Caption.new(input: @input)) %>
+    <% end %>
+  </span>
+<% end %>
+<% if @input.nested_form_block %>
+  <%= content_tag(:div, nested_form_arguments) do %>
+    <%= render(@input.nested_form_block.call(builder)) %>
+  <% end %>
+<% end %>

data/lib/yattho/forms/check_box.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Yattho
+  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")
+
+        return unless @input.scheme == :array
+
+        @input.input_arguments[:multiple] = true
+        @input.label_arguments[:value] = checked_value
+      end
+
+      def nested_form_arguments
+        return @nested_form_arguments if defined?(@nested_form_arguments)
+
+        @nested_form_arguments = { hidden: @input.hidden?, **@input.nested_form_arguments }
+        @nested_form_arguments[:class] = class_names(
+          @nested_form_arguments[:class],
+          @nested_form_arguments.delete(:classes),
+          "ml-4"
+        )
+
+        @nested_form_arguments
+      end
+
+      private
+
+      def checked_value
+        @input.value || "1"
+      end
+
+      def unchecked_value
+        return if @input.scheme == :array
+
+        @input.unchecked_value || "0"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+<%= content_tag(:fieldset, hidden: @input.hidden?) do %>
+  <% 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.to_component) %>
+    <% end %>
+  <% end %>
+<% end %>

data/lib/yattho/forms/check_box_group.rb

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

data/lib/yattho/forms/dsl/button_input.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Yattho
+  module Forms
+    module Dsl
+      # :nodoc:
+      class ButtonInput < 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
+          Button.new(input: self)
+        end
+
+        # :nocov:
+        def type
+          :button
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Yattho
+  module Forms
+    module Dsl
+      # :nodoc:
+      class CheckBoxGroupInput < Input
+        attr_reader :label, :check_boxes
+
+        def initialize(name: nil, label: nil, **system_arguments)
+          @name = name
+          @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, &block)
+          args = {
+            name: @name,
+            **system_arguments,
+            builder: @builder,
+            form: @form,
+            scheme: scheme
+          }
+
+          @check_boxes << CheckBoxInput.new(**args, &block)
+        end
+
+        private
+
+        def scheme
+          @name ? :array : :boolean
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Yattho
+  module Forms
+    module Dsl
+      # :nodoc:
+      class CheckBoxInput < Input
+        DEFAULT_SCHEME = :boolean
+        SCHEMES = [DEFAULT_SCHEME, :array].freeze
+
+        attr_reader :name, :label, :value, :unchecked_value, :scheme, :nested_form_block, :nested_form_arguments
+
+        def initialize(name:, label:, value: nil, unchecked_value: nil, scheme: DEFAULT_SCHEME, **system_arguments)
+          raise ArgumentError, "Check box scheme must be one of #{SCHEMES.join(', ')}" unless SCHEMES.include?(scheme)
+
+          raise ArgumentError, "Check box needs an explicit value if scheme is array" if scheme == :array && value.nil?
+
+          @name = name
+          @label = label
+          @value = value
+          @unchecked_value = unchecked_value
+          @scheme = scheme
+
+          super(**system_arguments)
+
+          yield(self) if block_given?
+        end
+
+        def to_component
+          CheckBox.new(input: self)
+        end
+
+        def nested_form(**system_arguments, &block)
+          @nested_form_arguments = system_arguments
+          @nested_form_block = block
+        end
+
+        def type
+          :check_box
+        end
+
+        private
+
+        def caption_template_name
+          @caption_template_name ||= if @scheme == :array
+                                       :"#{name}_#{value}"
+                                     else
+                                       name.to_sym
+                                     end
+        end
+      end
+    end
+  end
+end