Phlex Rails

The Phlex::Rails::Layout module provides an interface for rendering Phlex components as Rails layouts. When included in a class inheriting from Phlex::HTML, it enables the component to interact with the Rails view_context.

Key behaviors:

• Rendering: The render method handles the transition between Phlex and the Rails view flow. If a block yields a Symbol, the layout attempts to resolve that symbol using view_context.view_flow.get(symbol). Otherwise, it yields the block normally.
• Virtual Paths: The module automatically generates a virtual_path based on the class name. It converts Ruby constant names (e.g., Admin::UserLayout) into Rails-style underscored paths (e.g., admin.user_layout). This is useful for mapping Phlex layouts to Rails view lookup conventions.
• Helpers: It includes a suite of Rails-specific tag helpers such as CSPMetaTag, CSRFMetaTags, StylesheetLinkTag, and TurboRefresh tags, allowing you to use standard Rails asset and meta tags directly within your Phlex layout classes.

class ApplicationLayout < Phlex::HTML
  include Phlex::Rails::Layout

  def template
    head do
      # Helpers included via Phlex::Rails::Layout
      csrf_meta_tags
      javascript_importmap_tags
    end
    body do
      yield
    end
  end
end

In phlex-rails, Phlex::Rails::Buffered is a wrapper object used to manage how objects are rendered within a Phlex component. It acts as a proxy to an underlying @object, intercepting method calls to ensure that the output is correctly captured and passed through the component's rendering pipeline.

When a method is called on a Buffered object:

1. If a block is provided: The method is called on the underlying object, and the block is passed to @component.capture. The result is then wrapped in @component.raw to ensure it is treated as safe HTML/output.
2. If no block is provided: The method is called on the underlying object, and the result is passed through @component.raw.

This mechanism allows standard Ruby objects to behave as if they are part of the Phlex rendering flow, automatically handling content capture and raw output injection.

# Conceptual usage within a component context
# The Buffered object intercepts calls to ensure they are captured by the component
# and marked as raw output.

# If @object is a helper or another component:
# @component.raw(@object.method_name) if no block
# @component.raw(@object.method_name { |args| @component.capture(args) }) if block

The Phlex::Rails::Builder is a proxy object used during the construction of Phlex components within a Rails environment. It wraps a target object (typically a Rails view context or a builder object) and intercepts method calls to facilitate seamless integration between Phlex and Rails-specific output types.

When a method is called on the builder:

1. With a block: The builder executes the method on the underlying object and yields a new Phlex::Rails::Builder instance to the block. This allows for nested Phlex component construction.
2. Without a block: The builder simply delegates the method call to the underlying object.
3. Output Handling: If the result of the method call is an ActiveSupport::SafeBuffer (common in Rails for HTML-safe strings), the builder automatically wraps the output using @component.raw(output) to ensure correct rendering within the Phlex component.

# Conceptual usage pattern within a Phlex component
# The builder ensures Rails-specific helpers return correctly to Phlex

def construct
  # Inside a Phlex component, the builder might be used to wrap
  # Rails view helpers that return SafeBuffer strings.
  content.tag.div do
    # If 'link_to' returns a SafeBuffer, the Builder wraps it via @component.raw
    link_to "Home", root_path
  end
end