igniter 0.5.1 → 0.5.2

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

@@ -1,48 +0,0 @@
-# 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

@@ -1,7 +0,0 @@
-# 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

@@ -1,101 +0,0 @@
-# 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

@@ -1,124 +0,0 @@
-# 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

@@ -1,24 +0,0 @@
-# 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

@@ -1,7 +0,0 @@
-# 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

@@ -1,53 +0,0 @@
-# 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

@@ -1,63 +0,0 @@
-# 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

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

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Frontend
-    class Handler
-      class << self
-        def call(params:, body:, headers:, env:, raw_body:, config:)
-          new(
-            params: params,
-            body: body,
-            headers: headers,
-            env: env,
-            raw_body: raw_body,
-            config: config
-          ).call
-        end
-      end
-
-      attr_reader :params, :body, :headers, :env, :raw_body, :config
-
-      def initialize(params:, body:, headers:, env:, raw_body:, config:)
-        @params = params
-        @body = body
-        @headers = headers
-        @env = env
-        @raw_body = raw_body
-        @config = config
-      end
-
-      def call
-        raise NotImplementedError, "#{self.class} must implement #call"
-      end
-
-      def request
-        @request ||= Request.new(
-          method: env.fetch("REQUEST_METHOD", "GET"),
-          path: env.fetch("PATH_INFO", "/"),
-          route_params: params,
-          body: body,
-          headers: headers,
-          env: env,
-          raw_body: raw_body
-        )
-      end
-
-      def response
-        @response ||= Response.new
-      end
-
-      def app_access
-        @app_access ||= AppAccess.new(request: request, config: config)
-      end
-
-      def build_context(context_class, **attributes)
-        context_class.build(
-          request: request,
-          app_access: app_access,
-          response: response,
-          handler: self,
-          **attributes
-        )
-      end
-
-      def render(page_class, context:, **options)
-        page_body =
-          if page_class.respond_to?(:render)
-            page_class.render(context: context, **options)
-          else
-            page_class.new(context: context, **options).render
-          end
-
-        response.html(page_body)
-      end
-
-      def html(body, status: 200, headers: {})
-        response.html(body, status: status, headers: headers)
-      end
-
-      def json(body, status: 200, headers: {})
-        response.json(body, status: status, headers: headers)
-      end
-
-      def text(body, status: 200, headers: {})
-        response.text(body, status: status, headers: headers)
-      end
-
-      def redirect_to(location, status: 303, headers: {})
-        response.redirect(location, status: status, headers: headers)
-      end
-    end
-  end
-end