Class: Ruact::RenderPipeline

Inherits:
Object
  • Object
show all
Defined in:
lib/ruact/render_pipeline.rb

Overview

Internal — orchestrates the full server component render:

ERB source → (preprocessor) → evaluated HTML → (HtmlConverter) → ReactElement tree
                                                               → (Flight::Renderer) → wire bytes

External code should use Ruact::Controller#ruact_render instead. Ruact::RenderPipeline (and the rest of Ruact::Flight::* / Ruact::Internal::*) are not part of the public API and may change between minor versions.

Single entry point: #render.

Constant Summary collapse

VALID_MODES = 
%i[string stream].freeze

Instance Method Summary collapse

Constructor Details

#initialize(manifest, controller_path: nil, logger: nil) ⇒ RenderPipeline

Returns a new instance of RenderPipeline.



18
19
20
21
22
 
# File 'lib/ruact/render_pipeline.rb', line 18

def initialize(manifest, controller_path: nil, logger: nil)
  @manifest         = manifest
  @controller_path  = controller_path
  @logger           = logger
end

Instance Method Details

#render(input, mode: :string) ⇒ String, Enumerator

Render a server component tree to Flight wire format.

Internal API. External code should call Ruact::Controller#ruact_render instead. Ruact::RenderPipeline is not part of the public API and may change between minor versions without deprecation. Reach into it only when extending the gem itself.

Examples:

ERB source, buffered output

pipeline.render({ erb: "<NavBar />", binding: ctx.instance_eval { binding } }, mode: :string)
# => "0:[\"$\",\"div\",null,...]\n"

Pre-rendered HTML, streaming output

ctx = Ruact::RenderContext.new
pipeline.render({ html: "<!-- __RUACT_0__ -->", render_context: ctx }, mode: :stream)
# => #<Enumerator: ...>  (yields Flight rows lazily)

Parameters:

  • input (Hash) —

    selects the input shape — exactly one of:

    • { erb: String, binding: Binding } — render an ERB template within the given binding. Both keys required; :erb must be a String, :binding must be a Binding.
    • { html: String, render_context: Ruact::RenderContext } — convert pre-rendered HTML (from ActionView) using a render context populated during ERB evaluation. Both keys required; :html must be a String, :render_context must be a Ruact::RenderContext. Extra keys beyond the two-key shapes above are rejected with ArgumentError.
  • mode (Symbol) (defaults to: :string) —

    one of:

    • :string — returns the full serialized String. Deferred chunks are inlined eagerly (no Suspense delay). Suitable for buffered HTTP responses.
    • :stream — returns an Enumerator that yields Flight rows one at a time. Deferred chunks delay. Suitable for ActionController::Live streaming.

Returns:

  • (String, Enumerator) —

    depending on mode.

Raises:

  • (ArgumentError) —

    when:

    • input is not a Hash,
    • input mixes :erb and :html keys,
    • input omits both :erb and :html,
    • the required sibling key is missing or has the wrong type (:binding must be a Binding; :render_context must be a Ruact::RenderContext),
    • :erb or :html is not a String,
    • input contains extra keys beyond the documented shapes,
    • mode is not in VALID_MODES. All ArgumentError messages name the offending input and reference RenderPipeline#render for the canonical contract.


64
65
66
67
68
 
# File 'lib/ruact/render_pipeline.rb', line 64

def render(input, mode: :string)
  validate_mode!(mode)
  enum = build_enum(input, streaming: mode == :stream)
  mode == :string ? enum.to_a.join : enum
end