igniter 0.5.0 → 0.5.1

data/packages/igniter-frontend/lib/igniter/frontend/arbre/template_page.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "component"
+
+require_relative "components/action_group"
+require_relative "components/badge"
+require_relative "components/breadcrumbs"
+require_relative "components/card"
+require_relative "components/conversation_panel"
+require_relative "components/event_list"
+require_relative "components/json_panel"
+require_relative "components/key_value_list"
+require_relative "components/metric_grid"
+require_relative "components/page_header"
+require_relative "components/panel"
+require_relative "components/resource_list"
+require_relative "components/scenario_card"
+require_relative "components/tabs"
+
+module Igniter
+  module Frontend
+    module Arbre
+      class TemplatePage
+        UNSET = Object.new
+
+        class << self
+          def inherited(subclass)
+            super
+            subclass.template_root(template_root)
+            subclass.template(template)
+            subclass.layout(layout)
+          end
+
+          def render(**kwargs)
+            new(**kwargs).render
+          end
+
+          def template_root(path = UNSET)
+            return @template_root if path.equal?(UNSET)
+
+            @template_root = path.nil? ? nil : File.expand_path(path)
+          end
+
+          def template(name = UNSET)
+            return @template_name if name.equal?(UNSET)
+
+            @template_name = name
+          end
+
+          def layout(name = UNSET)
+            return @layout_name if name.equal?(UNSET)
+
+            @layout_name = name
+          end
+        end
+
+        def render(template: self.class.template, layout: self.class.layout, locals: nil)
+          rendered_template = build_context(resolve_template_path(template), assigns: merged_template_locals(locals))
+          return rendered_template.to_s if layout.nil?
+
+          @template_context = rendered_template
+          build_context(resolve_template_path(layout), assigns: merged_layout_locals(locals)).to_s
+        ensure
+          @template_context = nil
+        end
+
+        def render_template_content
+          raise ArgumentError, "#{self.class} has no template content to render" unless @template_context
+
+          target = current_arbre_context&.current_arbre_element
+          raise ArgumentError, "#{self.class} has no active Arbre context" unless target
+
+          @template_context.children.to_a.each do |child|
+            if target.respond_to?(:add_child)
+              target.add_child(child)
+            else
+              target << child
+            end
+          end
+
+          nil
+        end
+
+        def template_locals
+          {}
+        end
+
+        def layout_locals
+          template_locals
+        end
+
+        def controller_target(controller, name, **attributes)
+          attributes.merge(:"data-ig-#{dashize(controller)}-target" => dashize(name))
+        end
+
+        def controller_scope(*controllers, **attributes)
+          names = [attributes.delete(:"data-ig-controller"), controllers]
+                  .flatten
+                  .compact
+                  .flat_map { |value| value.to_s.split(/\s+/) }
+                  .map { |value| dashize(value) }
+                  .reject(&:empty?)
+                  .uniq
+
+          attributes.merge(:"data-ig-controller" => names.join(" "))
+        end
+
+        def stream_scope(**attributes)
+          controller_scope(:stream, **attributes)
+        end
+
+        def stream_target(name, **attributes)
+          controller_target(:stream, name, **attributes)
+        end
+
+        def controller_value(controller, name, value, **attributes)
+          serialized = serialize_controller_value(value)
+          return attributes if serialized.nil?
+
+          attributes.merge(:"data-ig-#{dashize(controller)}-#{dashize(name)}-value" => serialized)
+        end
+
+        def stream_value(name, value, **attributes)
+          controller_value(:stream, name, value, **attributes)
+        end
+
+        def frontend_runtime_path(mount: Assets::DEFAULT_MOUNT_PATH)
+          frontend_route_for(Assets.runtime_path(mount_path: mount))
+        end
+
+        def frontend_javascript_path(logical_path, mount: Assets::DEFAULT_MOUNT_PATH)
+          frontend_route_for(Assets.javascript_path(logical_path, mount_path: mount))
+        end
+
+        def render_frontend_javascript(*entrypoints, runtime: true, mount: Assets::DEFAULT_MOUNT_PATH, defer: true)
+          target = current_arbre_context&.current_arbre_element
+          raise ArgumentError, "#{self.class} has no active Arbre context" unless target
+
+          target.script(src: frontend_runtime_path(mount: mount), defer: defer) if runtime
+
+          Array(entrypoints).flatten.compact.each do |entrypoint|
+            target.script(src: frontend_javascript_path(entrypoint, mount: mount), defer: defer)
+          end
+
+          nil
+        end
+
+        private
+
+        def current_arbre_context
+          @current_arbre_context
+        end
+
+        def merged_template_locals(overrides)
+          merge_locals(template_locals, overrides)
+        end
+
+        def merged_layout_locals(overrides)
+          merge_locals(layout_locals, overrides)
+        end
+
+        def merge_locals(base, overrides)
+          base.merge(overrides || {})
+        end
+
+        def build_context(path, assigns:)
+          Arbre.ensure_available!
+          Arbre::RawTextNode
+
+          context = Arbre.context_class.new(assigns, self)
+          previous_context = @current_arbre_context
+          @current_arbre_context = context
+          context.instance_eval(File.read(path), path, 1)
+          context
+        ensure
+          @current_arbre_context = previous_context
+        end
+
+        def resolve_template_path(name)
+          candidate = name.to_s.strip
+          raise ArgumentError, "#{self.class} must define a template name" if candidate.empty?
+
+          path = if absolute_template_path?(candidate)
+                   candidate
+                 else
+                   root = self.class.template_root
+                   raise ArgumentError, "#{self.class} must define template_root for relative templates" if root.nil?
+
+                   File.expand_path(candidate, root)
+                 end
+
+          path = "#{path}.arb" if File.extname(path).empty?
+          raise ArgumentError, "missing Arbre template: #{path}" unless File.file?(path)
+
+          path
+        end
+
+        def absolute_template_path?(value)
+          value.start_with?("/", "./", "../")
+        end
+
+        def frontend_route_for(suffix)
+          routeable_context = if respond_to?(:context, true)
+                              send(:context)
+                            elsif instance_variable_defined?(:@context)
+                              instance_variable_get(:@context)
+                            end
+
+          return suffix unless routeable_context&.respond_to?(:route)
+
+          routeable_context.route(suffix)
+        end
+
+        def dashize(value)
+          value.to_s
+               .gsub(/([a-z0-9])([A-Z])/, '\1-\2')
+               .tr("_", "-")
+               .downcase
+        end
+
+        def serialize_controller_value(value)
+          case value
+          when nil
+            nil
+          when String
+            value
+          when Symbol, Numeric
+            value.to_s
+          when true
+            "true"
+          when false
+            "false"
+          when Array, Hash
+            JSON.generate(value)
+          else
+            value.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/packages/igniter-frontend/lib/igniter/frontend/arbre.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "tailwind"
+
+module Igniter
+  module Frontend
+    module Arbre
+      class MissingDependencyError < LoadError
+      end
+
+      module_function
+
+      def available?
+        !dependency.nil?
+      rescue MissingDependencyError
+        false
+      end
+
+      def component_class
+        dependency.const_get(:Component)
+      end
+
+      def context_class
+        dependency.const_get(:Context)
+      end
+
+      def ensure_available!
+        dependency
+      end
+
+      def dependency
+        return ::Arbre if defined?(::Arbre)
+
+        require "arbre"
+        ::Arbre
+      rescue LoadError
+        raise MissingDependencyError,
+              "`igniter-frontend` now ships with a required `arbre` dependency. " \
+              "If it is missing in this environment, run bundle install or reinstall the gem."
+      end
+    end
+  end
+end
+
+require_relative "arbre/component"
+require_relative "arbre/page"
+require_relative "arbre/raw_text_node"
+require_relative "arbre/template_page"

data/packages/igniter-frontend/lib/igniter/frontend/arbre_page.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Frontend
+    ArbrePage = Arbre::TemplatePage unless const_defined?(:ArbrePage, false)
+  end
+end

data/packages/igniter-frontend/lib/igniter/frontend/assets.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Frontend
+    module Assets
+      DEFAULT_MOUNT_PATH = "/__frontend"
+      DEFAULT_SOURCE_PATH = "frontend"
+      JAVASCRIPT_CONTENT_TYPE = "text/javascript; charset=utf-8"
+
+      module_function
+
+      def build_config(root_dir:, source_path: DEFAULT_SOURCE_PATH, mount_path: DEFAULT_MOUNT_PATH)
+        normalized_mount_path = normalize_mount_path(mount_path)
+        source_root = File.expand_path(source_path, root_dir)
+
+        {
+          mount_path: normalized_mount_path,
+          root_dir: File.expand_path(root_dir),
+          source_path: source_path.to_s,
+          source_root: source_root
+        }
+      end
+
+      def runtime_path(mount_path: DEFAULT_MOUNT_PATH)
+        "#{normalize_mount_path(mount_path)}/runtime.js"
+      end
+
+      def javascript_path(logical_path, mount_path: DEFAULT_MOUNT_PATH)
+        normalized_logical_path = normalize_logical_path(logical_path)
+        "#{normalize_mount_path(mount_path)}/assets/#{normalized_logical_path}"
+      end
+
+      def runtime_handler
+        lambda do |params:, body:, headers:, env:, raw_body:, config:| # rubocop:disable Lint/UnusedBlockArgument
+          {
+            status: 200,
+            body: Frontend::JavaScript.runtime_source,
+            headers: { "Content-Type" => JAVASCRIPT_CONTENT_TYPE }
+          }
+        end
+      end
+
+      def javascript_handler(frontend_assets_config)
+        lambda do |params:, body:, headers:, env:, raw_body:, config:| # rubocop:disable Lint/UnusedBlockArgument
+          logical_path = params.fetch(:logical_path, "")
+          asset_path = resolve_asset_path(frontend_assets_config, logical_path)
+
+          if asset_path.nil?
+            {
+              status: 404,
+              body: "Frontend asset not found: #{logical_path}",
+              headers: { "Content-Type" => "text/plain; charset=utf-8" }
+            }
+          else
+            {
+              status: 200,
+              body: File.read(asset_path),
+              headers: { "Content-Type" => JAVASCRIPT_CONTENT_TYPE }
+            }
+          end
+        end
+      end
+
+      def javascript_route_pattern(mount_path: DEFAULT_MOUNT_PATH)
+        mount = Regexp.escape(normalize_mount_path(mount_path))
+        %r{\A#{mount}/assets/(?<logical_path>.+)\z}
+      end
+
+      def normalize_mount_path(mount_path)
+        path = mount_path.to_s.strip
+        path = DEFAULT_MOUNT_PATH if path.empty?
+        path = "/#{path}" unless path.start_with?("/")
+        path = path.gsub(%r{/+}, "/")
+        return "/" if path == "/"
+
+        path.sub(%r{/\z}, "")
+      end
+
+      def normalize_logical_path(logical_path)
+        path = logical_path.to_s.strip
+        path = "#{path}.js" if File.extname(path).empty?
+        path.sub(%r{\A/+}, "")
+      end
+
+      def resolve_asset_path(frontend_assets_config, logical_path)
+        normalized_path = normalize_logical_path(logical_path)
+        return nil unless normalized_path.end_with?(".js")
+
+        segments = normalized_path.split("/")
+        return nil if segments.empty? || segments.any? { |segment| segment.empty? || segment == "." || segment == ".." }
+
+        source_root = frontend_assets_config.fetch(:source_root)
+        candidate = File.expand_path(normalized_path, source_root)
+        return nil unless candidate == source_root || candidate.start_with?("#{source_root}/")
+        return nil unless File.file?(candidate)
+
+        candidate
+      end
+    end
+  end
+end

data/packages/igniter-frontend/lib/igniter/frontend/builder.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module Igniter
+  module Frontend
+    class Builder
+      VOID_TAGS = %i[area base br col embed hr img input link meta param source track wbr].freeze
+
+      def initialize(output = +"")
+        @output = output
+      end
+
+      def doctype(type = "html")
+        @output << "<!DOCTYPE #{escape_text(type)}>\n"
+        nil
+      end
+
+      def tag(name, attrs = nil, content = nil, **kwargs, &block)
+        if !attrs.nil? && !attrs.is_a?(Hash)
+          content = attrs
+          attrs = nil
+        end
+
+        attrs = normalize_attrs((attrs || {}).merge(kwargs))
+        @output << "<#{name}#{render_attrs(attrs)}>"
+
+        if VOID_TAGS.include?(name.to_sym) && block.nil? && content.nil?
+          return nil
+        end
+
+        if block
+          block.call(self)
+        elsif !content.nil?
+          text(content)
+        end
+
+        @output << "</#{name}>"
+        nil
+      end
+
+      def text(value)
+        @output << escape_text(value)
+        nil
+      end
+
+      def component(component = nil, **kwargs)
+        instance = component.is_a?(Class) ? component.new(**kwargs) : component
+        raise ArgumentError, "component must be a component instance or class" if instance.nil?
+
+        instance.render_in(self)
+        nil
+      end
+
+      def form(action:, method: "post", **attrs)
+        tag(:form, attrs.merge(action: action, method: method)) do |form_view|
+          yield(FormBuilder.new(form_view))
+        end
+      end
+
+      def button(text = nil, type: "button", **attrs, &block)
+        tag(:button, attrs.merge(type: type)) do |button_view|
+          if block
+            block.call(button_view)
+          else
+            button_view.text(text)
+          end
+        end
+      end
+
+      def raw(value)
+        @output << value.to_s
+        nil
+      end
+
+      def capture(&block)
+        nested = self.class.new
+        block.call(nested)
+        nested.to_s
+      end
+
+      def to_s
+        @output.dup
+      end
+
+      private
+
+      def escape_text(value)
+        CGI.escape_html(value.to_s)
+      end
+
+      def normalize_attrs(attrs, prefix = nil)
+        attrs.each_with_object({}) do |(key, value), result|
+          next if value.nil? || value == false
+
+          attr_name = [prefix, key.to_s.tr("_", "-")].compact.join("-")
+
+          if value.is_a?(Hash)
+            result.merge!(normalize_attrs(value, attr_name))
+            next
+          end
+
+          result[attr_name] =
+            case value
+            when Array
+              value.compact.join(" ")
+            when true
+              true
+            else
+              value
+            end
+        end
+      end
+
+      def render_attrs(attrs)
+        return "" if attrs.empty?
+
+        attrs.map do |key, value|
+          value == true ? " #{key}" : " #{key}=\"#{escape_text(value)}\""
+        end.join
+      end
+    end
+  end
+end

data/packages/igniter-frontend/lib/igniter/frontend/component.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Frontend
+    class Component
+      def self.render(**kwargs)
+        new(**kwargs).render
+      end
+
+      def render
+        Frontend.render { |view| render_in(view) }
+      end
+
+      def render_in(view)
+        call(view)
+        nil
+      end
+
+      def call(_view)
+        raise NotImplementedError, "#{self.class} must implement #call(view)"
+      end
+    end
+  end
+end

data/packages/igniter-frontend/lib/igniter/frontend/components.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Frontend
+    Components = Arbre::Components unless const_defined?(:Components, false)
+  end
+end

data/packages/igniter-frontend/lib/igniter/frontend/context.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Frontend
+    class Context
+      class << self
+        def build(**kwargs)
+          new(**kwargs)
+        end
+      end
+
+      attr_reader :request, :app_access, :response, :handler
+
+      def initialize(request: nil, app_access: nil, response: nil, handler: nil, **attributes)
+        @request = request
+        @app_access = app_access
+        @response = response
+        @handler = handler
+        @attributes = attributes.transform_keys(&:to_sym)
+      end
+
+      def base_path
+        request&.script_name.to_s
+      end
+
+      def route(suffix)
+        [base_path.sub(%r{/+\z}, ""), suffix.to_s].join
+      end
+
+      def [](key)
+        @attributes[key.to_sym]
+      end
+
+      def fetch(key, *args)
+        @attributes.fetch(key.to_sym, *args)
+      end
+
+      def to_h
+        @attributes.dup
+      end
+
+      def method_missing(name, *args, &block)
+        return @attributes.fetch(name) if args.empty? && block.nil? && @attributes.key?(name)
+
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @attributes.key?(name.to_sym) || super
+      end
+    end
+  end
+end

data/packages/igniter-frontend/lib/igniter/frontend/form_builder.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Frontend
+    class FormBuilder
+      attr_reader :view
+
+      def initialize(view)
+        @view = view
+      end
+
+      def label(for_id, text = nil, **attrs, &block)
+        view.tag(:label, attrs.merge(for: for_id)) do |label_view|
+          if block
+            block.call(label_view)
+          else
+            label_view.text(text)
+          end
+        end
+      end
+
+      def input(name, type: "text", value: nil, **attrs)
+        view.tag(:input, attrs.merge(type: type, name: name, value: value))
+      end
+
+      def hidden(name, value, **attrs)
+        input(name, type: "hidden", value: value, **attrs)
+      end
+
+      def checkbox(name, value: "1", checked: false, **attrs)
+        view.tag(:input, attrs.merge(type: "checkbox", name: name, value: value, checked: checked))
+      end
+
+      def textarea(name, value: nil, **attrs)
+        view.tag(:textarea, attrs.merge(name: name)) { |textarea| textarea.text(value) unless value.nil? }
+      end
+
+      def select(name, options:, selected: nil, **attrs)
+        view.tag(:select, attrs.merge(name: name)) do |select_view|
+          options.each do |label, value|
+            option_attrs = { value: value }
+            option_attrs[:selected] = true if selected.to_s == value.to_s
+            select_view.tag(:option, option_attrs) { |option| option.text(label) }
+          end
+        end
+      end
+
+      def button(text = nil, type: "button", **attrs, &block)
+        view.tag(:button, attrs.merge(type: type)) do |button_view|
+          if block
+            block.call(button_view)
+          else
+            button_view.text(text)
+          end
+        end
+      end
+
+      def submit(text = "Submit", **attrs)
+        button(text, type: "submit", **attrs)
+      end
+    end
+  end
+end