ariadne_view_components 0.0.59 → 0.0.65

data/app/lib/ariadne/attributes_helper.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Ariadne
+  # :nodoc:
+  module AttributesHelper
+    PLURAL_ARIA_ATTRIBUTES = [:describedby, :labelledby].freeze
+    PLURAL_DATA_ATTRIBUTES = [:target, :targets].freeze
+
+    def prepend_controller(html_attrs, name = stimulus_name)
+      prepend_data_attribute(html_attrs, :controller, name)
+    end
+
+    def prepend_action(html_attrs, action)
+      prepend_data_attribute(html_attrs, :action, action)
+    end
+
+    def prepend_data_attribute(html_attrs, attr_name, attr_value)
+      html_attrs[:data] ||= {}
+      html_attrs[:data][attr_name] = "#{attr_value} #{html_attrs[:data][attr_name]}".strip
+      html_attrs
+    end
+
+    def aria(html_attrs, val)
+      html_attrs[:"aria-#{val}"] || html_attrs.dig(:aria, val.to_sym)
+    end
+
+    def data(html_attrs, val)
+      html_attrs[:"data-#{val}"] || html_attrs.dig(:data, val.to_sym)
+    end
+
+    # Merges hashes that contain "aria-*" keys and nested aria: hashes. Removes keys from
+    # each hash and returns them in the new hash.
+    #
+    # Eg. merge_aria({ "aria-disabled": "true" }, { aria: { invalid: "true" } })
+    #     => { disabled: "true", invalid: "true" }
+    #
+    # Certain aria attributes can contain multiple values separated by spaces. merge_aria
+    # will combine these plural attributes into a composite string.
+    #
+    # Eg. merge_aria({ "aria-labelledby": "foo" }, { aria: { labelledby: "bar" } })
+    #     => { labelledby: "foo bar" }
+    #
+    # It's designed to be used to normalize and merge aria information from system_arguments
+    # hashes. Consider using this pattern in component initializers:
+    #
+    # @system_arguments[:aria] = merge_aria(
+    #   @system_arguments,
+    #   { aria: { labelled_by: id } }
+    # )
+    def merge_aria(*hashes)
+      merge_prefixed_attribute_hashes(
+        *hashes, prefix: :aria, plural_keys: PLURAL_ARIA_ATTRIBUTES
+      )
+    end
+
+    # Merges hashes that contain "data-*" keys and nested data: hashes. Removes keys from
+    # each hash and returns them in the new hash.
+    #
+    # Eg. merge_data({ "data-foo": "true" }, { data: { bar: "true" } })
+    #     => { foo: "true", bar: "true" }
+    #
+    # Certain data attributes can contain multiple values separated by spaces. merge_data
+    # will combine these plural attributes into a composite string.
+    #
+    # Eg. merge_data({ "data-target": "foo" }, { data: { target: "bar" } })
+    #     => { target: "foo bar" }
+    #
+    # It's designed to be used to normalize and merge data information from system_arguments
+    # hashes. Consider using this pattern in component initializers:
+    #
+    # @system_arguments[:data] = merge_aria(
+    #   @system_arguments,
+    #   { data: { foo: "bar" } }
+    # )
+    def merge_data(*hashes)
+      merge_prefixed_attribute_hashes(
+        *hashes, prefix: :data, plural_keys: PLURAL_DATA_ATTRIBUTES
+      )
+    end
+
+    def merge_prefixed_attribute_hashes(*hashes, prefix:, plural_keys:)
+      {}.tap do |result|
+        hashes.each do |hash|
+          next unless hash
+
+          prefix_hash = hash.delete(prefix) || {}
+
+          prefix_hash.each_pair do |key, val|
+            result[key] =
+              if plural_keys.include?(key)
+                [*(result[key] || "").split, val].join(" ").strip
+              else
+                val
+              end
+          end
+
+          hash.delete_if do |key, val|
+            key_s = key.to_s
+
+            if key.start_with?("#{prefix}-")
+              bare_key = key_s.sub("#{prefix}-", "").to_sym
+
+              result[bare_key] =
+                if plural_keys.include?(bare_key)
+                  [*(result[bare_key] || "").split, val].join(" ").strip
+                else
+                  val
+                end
+
+              true
+            else
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/ariadne/fetch_or_fallback_helper.rb

@@ -34,7 +34,7 @@ module Ariadne
       check_against_given_value = against || given_value
       if allowed_values.include?(check_against_given_value)
         given_value
-      else
+      elsif fallback_raises
         raise InvalidValueError, <<~MSG
           fetch_or_raise was called with an invalid value.
 

data/app/lib/ariadne/form.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Ariadne
+  # :nodoc:
+  module Form
+    def self.inline_form(builder, base = nil, &block)
+      base ||= defined?(ApplicationForm) ? ApplicationForm : Ariadne::Forms::Base
+
+      klass = Class.new(base) do
+        form(&block)
+      end
+
+      klass.new(builder)
+    end
+  end
+end

data/app/lib/ariadne/view_helper.rb

@@ -7,14 +7,11 @@ module Ariadne
     class ViewHelperNotFound < StandardError; end
 
     HELPERS = {
-      heroicon: "Ariadne::HeroiconComponent",
-      heading: "Ariadne::HeadingComponent",
-      time_ago: "Ariadne::TimeAgoComponent",
-      image: "Ariadne::ImageComponent",
+      heroicon: "Ariadne::UI::Heroicon::Component",
     }.freeze
 
     HELPERS.each do |name, component|
-      define_method "ariadne_#{name}" do |*args, **kwargs, &block|
+      define_method :"ariadne_#{name}" do |*args, **kwargs, &block|
         render component.constantize.new(*args, **kwargs), &block
       end
     end

data/app/lib/view_components_contrib/html_attrs.rb

@@ -0,0 +1,64 @@
+# typed: false
+# frozen_string_literal: true
+
+require "action_view/helpers/tag_helper"
+
+module ViewComponentContrib
+  module HTMLAttrs
+    class AttributesHash < ::Hash
+      TAG_BUILDER = ActionView::Helpers::TagHelper::TagBuilder.new(nil)
+      TAG_OPTIONS = ActionView::Helpers::TagHelper::TagBuilder.instance_method(:tag_options)
+
+      def to_html(nested: false)
+        # TODO: implement + change usage by @tag nested-attributes
+        tag_options(self)&.html_safe # rubocop:disable Rails/OutputSafety
+      end
+      private def tag_options(...) = TAG_OPTIONS.bind_call(TAG_BUILDER, ...)
+    end
+
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def accepts_html_attributes_for(name, **defaults, &block)
+        html_attribute_accessors[name] = defaults
+
+        name = name.to_sym
+        method_name = :"#{name}_attrs"
+        ivar_name = :"@#{method_name}"
+
+        attr_reader(method_name)
+
+        mod = Module.new do
+          define_method(:initialize) do |**options|
+            value = self.class.default_html_attributes_for(name).deep_merge!(options.delete(method_name).to_h)
+            super(**options)
+            instance_exec(value, &block) if block
+            instance_variable_set(ivar_name, value)
+          end
+        end
+
+        prepend(mod)
+      end
+
+      def accepts_html_attributes(**defaults, &block)
+        accepts_html_attributes_for(:html, **defaults, &block)
+      end
+
+      def html_attribute_accessors
+        @html_attribute_accessors ||=
+          if superclass.respond_to?(:html_attribute_accessors)
+            superclass.html_attribute_accessors.deep_dup
+          else
+            {}
+          end
+      end
+
+      def default_html_attributes_for(name)
+        html_attribute_accessors.fetch(name).each_with_object(AttributesHash.new) do |(k, v), acc|
+          acc[k] = v.is_a?(Proc) ? v.call : v
+          acc
+        end
+      end
+    end
+  end
+end

data/app/lib/view_components_contrib/style_variants.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ViewComponentContrib
+  module StyleVariants
+    module ClassMethods
+      # Returns the name of the default style set based on the class name:
+      #  MyComponent::Component => my_component
+      #  Namespaced::MyComponent => my_component
+      def default_style_name
+        @default_style_name ||= name.split("::")[-2].underscore.presence || "component"
+      end
+    end
+  end
+end

data/lib/ariadne/forms/acts_as_component.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Ariadne
+  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:
+        def set_original_view_context(view_context)
+          @view_context = view_context
+        end
+        # :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_method :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)
+        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/ariadne/forms/base.html.erb

@@ -0,0 +1,8 @@
+<div class="ariadne-flex ariadne-flex-col ariadne-gap-8">
+  <% inputs.each do |input| %>
+    <%= render(input.to_component) %>
+  <% end %>
+</div>
+<% if after_content? %>
+  <%= render_after_content %>
+<% end %>

data/lib/ariadne/forms/base.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Ariadne
+  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_method :after_content?, :has_after_content
+
+        def form(&block)
+          @__vcf_form_block = block
+        end
+
+        def new(builder, **options)
+          if builder && !builder.is_a?(Ariadne::Forms::Builder)
+            raise ArgumentError, "please pass an instance of Ariadne::Forms::Builder when " \
+              "constructing a form object (consider using the `ariadne_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 = Ariadne::Forms::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
+            Ariadne::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
+        @__pf_form_object ||= Ariadne::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/ariadne/forms/buffer_rewriter.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module Ariadne
+  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/ariadne/forms/builder.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# 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 Ariadne
+  module Forms
+    module Tags
+      # :nodoc:
+      class TextField < ::ActionView::Helpers::Tags::TextField
+        def attributes
+          render
+        end
+
+        private
+
+        def tag(_name, options)
+          options
+        end
+      end
+    end
+
+    # :nodoc:
+    class Builder < ActionView::Helpers::FormBuilder
+      alias_method :ariadne_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_field_attributes(method, options = {})
+        Tags::TextField.new(@object_name, method, @template, options).attributes
+      end
+
+      def text_area(*args, **options, &block)
+        super(*args, classify(options).merge(generate_error_markup: false), &block)
+      end
+
+      private
+
+      def classify(options)
+        Ariadne::Forms::Utils.classify(options)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Ariadne
+  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
+          Ariadne::UI::Button::Component.new(label: @label).with_content(@label)
+        end
+
+        # :nocov:
+        def type
+          :button
+        end
+
+        def supports_validation?
+          false
+        end
+      end
+    end
+  end
+end