ariadne_view_components 0.0.58 → 0.0.64

data/app/components/ariadne/ui/image/component.rb

@@ -0,0 +1,69 @@
+# typed: false
+# frozen_string_literal: true
+
+module Ariadne
+  module UI
+    module Image
+      # @example Default
+      #
+      #   <%= render(Ariadne::ImageComponent.new(src: "https://github.com/github.png", alt: "GitHub")) %>
+      #
+      # @example Helper
+      #
+      #   <%= ariadne_image(src: "https://github.com/github.png", alt: "GitHub") %>
+      #
+      # @example Lazy loading
+      #
+      #   <%= render(Ariadne::ImageComponent.new(src: "https://github.com/github.png", alt: "GitHub", lazy: true)) %>
+      #
+      # @example Custom size
+      #
+      #   <%= render(Ariadne::ImageComponent.new(src: "https://github.com/github.png", alt: "GitHub", attributes: { height: 100, width: 100 })) %>
+      #
+      # @param tag [Symbol, String] The rendered tag name
+      # @param src [String] The source url of the image.
+      # @param alt [String] Specifies an alternate text for the image.
+      # @param lazy [Boolean] Whether or not to lazily load the image.
+      # @param classes [String] <%= link_to_classes_docs %>
+      # @param attributes [Hash] <%= link_to_attributes_docs %>
+      class Component < Ariadne::BaseComponent
+        option :src
+        option :alt
+        option :size, default: -> { :original }
+        option :lazy, default: -> { false }
+
+        accepts_html_attributes do |html_attrs|
+          html_attrs[:class] = Ariadne::ViewComponents.tailwind_merger.merge([style(size: @size), html_attrs[:class]].join(" "))
+
+          html_attrs[:src] = @src
+          html_attrs[:alt] = @alt
+
+          next unless @lazy
+
+          html_attrs[:loading] = :lazy
+          html_attrs[:decoding] = :async
+        end
+
+        style do
+          base do
+            ["ariadne-object-cover", "ariadne-object-center"]
+          end
+
+          variants do
+            size do
+              xs { "ariadne-w-4" }
+              sm { "ariadne-w-6" }
+              md { "ariadne-w-8" }
+              lg { "ariadne-w-12" }
+              xl { "ariadne-w-16" }
+            end
+          end
+        end
+
+        erb_template <<~ERB
+          <img class="<%= html_attrs[:class] %>" <%= html_attributes %> />
+        ERB
+      end
+    end
+  end
+end

data/app/components/ariadne/ui/link/component.html.erb

@@ -0,0 +1,3 @@
+<a href="<%= href %>" class="<%= style(theme:, size:) %>" <%= html_attributes %>>
+<%= content %>
+</a>

data/app/components/ariadne/ui/link/component.rb

@@ -0,0 +1,56 @@
+# typed: false
+# frozen_string_literal: true
+
+module Ariadne
+  module UI
+    module Link
+      class Component < Ariadne::BaseComponent
+        option :href
+
+        option :theme, default: proc { :base }
+        option :size, default: proc { :base }
+
+        include Ariadne::Behaviors::Tooltipable
+
+        style do
+          base do
+            [
+              "ariadne-inline-flex",
+              "ariadne-items-center",
+              "ariadne-border-b",
+              "ariadne-border-transparent",
+            ]
+          end
+
+          variants do
+            theme do
+              base do
+                [
+                  "[&>svg]:ariadne-text-zinc-400",
+                  "[&>svg]:dark:ariadne-text-zinc-600",
+                  "hover:ariadne-text-indigo-600",
+                  "dark:hover:ariadne-text-indigo-400",
+                  "hover:ariadne-border-indigo-600",
+                  "dark:hover:ariadne-border-indigo-400",
+                  "focus:ariadne-text-indigo-600",
+                  "dark:focus:ariadne-text-indigo-400",
+                  "focus:!ariadne-border-transparent",
+                  "active:ariadne-bg-indigo-700/10",
+                  "active:dark:ariadne-bg-indigo-300/10",
+                ]
+              end
+              nude { "" }
+              thick { "ariadne-font-semibold" }
+            end
+            size do
+              xs { "ariadne-text-xs ariadne-gap-0.5 [&>svg]:ariadne-size-3" }
+              sm { "ariadne-text-sm ariadne-gap-0.5 [&>svg]:ariadne-size-4" }
+              md { "ariadne-text-base ariadne-gap-1 [&>svg]:ariadne-size-4" }
+              lg { "ariadne-text-lg ariadne-gap-1 [&>svg]:ariadne-size-5" }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/components/ariadne/ui/typography/component.html.erb

@@ -0,0 +1,3 @@
+<%= content_tag(tag_name, html_attrs) do %>
+    <%= content %>
+<% end %>

data/app/components/ariadne/ui/typography/component.rb

@@ -0,0 +1,41 @@
+# typed: false
+# frozen_string_literal: true
+
+module Ariadne
+  module UI
+    module Typography
+      class Component < Ariadne::BaseComponent
+        option :type
+
+        accepts_html_attributes do |html_attrs|
+          html_attrs[:class] = Ariadne::ViewComponents.tailwind_merger.merge([style(type: @type), html_attrs[:class]].join(" "))
+        end
+
+        def tag_name
+          case type
+          when :heading
+            :h1
+          else
+            :span
+          end
+        end
+
+        style do
+          variants do
+            type do
+              heading do
+                [
+                  "ariadne-scroll-m-20",
+                  "ariadne-text-4xl",
+                  "ariadne-font-extrabold",
+                  "ariadne-tracking-tight",
+                  "lg:ariadne-text-5xl",
+                ]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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