view_component_reducible 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b307a9c57921ef4216255c39918da4792c2f173c8485f6033554f23829f8f55b
-  data.tar.gz: f179351bb370f6d5591f6cf3e85a653d798b4b8f9f824f8315eddc0f258af7ea
+  metadata.gz: a699ce3503948db085a77d5d187e725157966bf53a132e9d9124a772db648f1c
+  data.tar.gz: ba68826392cd3ea83ca6ceea8f8f753d893f013467d61eff20f3085fd40c9e0c
 SHA512:
-  metadata.gz: b4d2804331f0ea6a8fdfe498c2126ef7d995d44cf46d7434ce0a16d015f53f29f580c264dce6c796424f85537e2b70a549967f6428c442e6bd7c78f4c85fdc7e
-  data.tar.gz: f46c695e6871637a11c124c41df49b738737a929b399b11f988764e9b6b37e6b8a1fc06c6fa36728d7f80bedf04e61e15b841a744f0d692dca05b8c5a0f92eab
+  metadata.gz: 9eca692a8a5b7185869237597cb79d199d4e1e036501f2c9c2574e40ea643e99535202f31fb44198a51e293e2fd5078adefd2e65756bd95fc8732917a688b892
+  data.tar.gz: bfe0b991478a5a8788f2b2f9c69f7705d5ad9bf1de828d76d50c5b652a8d57bb23c18dfe883289bf231c54b77885e311c35485e9d4a7fc37f200b87d113033a8

data/README.md

@@ -1,6 +1,15 @@
 # view_component_reducible
 
+![sample](doc/img/sample.png)
+
+This sample shows state transitions and partial updates powered entirely by ViewComponent.
+The only thing you add in Rails is a single endpoint:
+
+```rb
+mount ViewComponentReducible::Engine, at: "/vcr"
+```
+
+Everything else is **reducible** to ViewComponent—no extra endpoints, controllers, WebSockets, or JS frameworks required.
+
 view_component_reducible brings reducer-based state transitions
 to Rails ViewComponent, inspired by TEA (The Elm Architecture).
-
-This is a server-driven, HTTP-based approach — no WebSocket required.

data/lib/view_component_reducible/adapter/base.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ViewComponentReducible
+  module Adapter
+    # Base adapter interface for envelope serialization.
+    class Base
+      # @param secret [String]
+      def initialize(secret:)
+        @secret = secret
+      end
+
+      # Encode envelope to a client-safe token.
+      # @param envelope [Hash]
+      # @param request [ActionDispatch::Request]
+      # @return [String]
+      def dump(envelope, request:)
+        raise NotImplementedError
+      end
+
+      # Load envelope from a request.
+      # @param request [ActionDispatch::Request]
+      # @return [Hash]
+      def load(request:)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/view_component_reducible/adapter/hidden_field.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/message_verifier'
+
+module ViewComponentReducible
+  module Adapter
+    # Hidden field adapter using signed payloads.
+    class HiddenField < Base
+      # @return [ActiveSupport::MessageVerifier]
+      def verifier
+        @verifier ||= ActiveSupport::MessageVerifier.new(@secret, digest: 'SHA256', serializer: JSON)
+      end
+
+      # @param envelope [Hash]
+      # @param request [ActionDispatch::Request]
+      # @return [String]
+      def dump(envelope, request: nil)
+        _ = request
+        verifier.generate(envelope)
+      end
+
+      # @param request [ActionDispatch::Request]
+      # @return [Hash]
+      def load(request:)
+        signed = request.params.fetch('vcr_state')
+        verifier.verify(signed)
+      end
+    end
+  end
+end

data/lib/view_component_reducible/adapter/session.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/message_verifier'
+require 'securerandom'
+
+module ViewComponentReducible
+  module Adapter
+    # Session adapter storing envelope in server session.
+    class Session < Base
+      # @return [ActiveSupport::MessageVerifier]
+      def verifier
+        @verifier ||= ActiveSupport::MessageVerifier.new(@secret, digest: 'SHA256', serializer: JSON)
+      end
+
+      # @param envelope [Hash]
+      # @param request [ActionDispatch::Request]
+      # @return [String]
+      def dump(envelope, request:)
+        key = SecureRandom.hex(16)
+        request.session["vcr:#{key}"] = envelope
+        verifier.generate({ 'k' => key })
+      end
+
+      # @param request [ActionDispatch::Request]
+      # @return [Hash]
+      def load(request:)
+        signed = request.params.fetch('vcr_state')
+        payload = verifier.verify(signed)
+        key = payload.fetch('k')
+        request.session.fetch("vcr:#{key}")
+      end
+    end
+  end
+end

data/lib/view_component_reducible/component.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'securerandom'
+
+module ViewComponentReducible
+  # Include to enable the component state DSL and helpers.
+  module Component
+    # Hook to include DSL and class methods.
+    # @param base [Class]
+    # @return [void]
+    def self.included(base)
+      base.include(State::DSL)
+      base.extend(ClassMethods)
+    end
+
+    # @return [Hash, nil]
+    attr_reader :vcr_envelope
+    # @return [String, nil]
+    attr_reader :vcr_state_token
+
+    # @param vcr_envelope [Hash, nil]
+    # @param vcr_state_token [String, nil]
+    def initialize(vcr_envelope: nil, vcr_state_token: nil, **kwargs)
+      @vcr_envelope = vcr_envelope
+      @vcr_state_token = vcr_state_token
+      return unless defined?(super)
+
+      kwargs.empty? ? super() : super(**kwargs)
+    end
+
+    # Build state hash for rendering from the envelope.
+    # @return [Hash{String=>Object}]
+    def vcr_state
+      return {} if vcr_envelope.nil?
+
+      schema = self.class.vcr_state_schema
+      schema.build(vcr_envelope['data'])
+    end
+
+    # Optional DOM target id for updates.
+    # @param path [String]
+    # @return [String]
+    def vcr_dom_id(path:)
+      "vcr:#{self.class.vcr_id}:#{path}"
+    end
+
+    # Render component markup wrapped in a VCR boundary when available.
+    # @param view_context [ActionView::Base]
+    # @return [String]
+    def render_in(view_context, &block)
+      ensure_vcr_state(view_context) if vcr_envelope.nil?
+
+      path = vcr_envelope && vcr_envelope['path']
+      previous_path = view_context.instance_variable_get(:@vcr_current_path)
+      view_context.instance_variable_set(:@vcr_current_path, path)
+
+      rendered = super
+      return rendered if path.nil? || path.to_s.empty?
+
+      inject_vcr_path(rendered, path)
+    ensure
+      view_context.instance_variable_set(:@vcr_current_path, previous_path)
+    end
+
+    module ClassMethods
+      # Stable component identifier for envelopes.
+      # @return [String]
+      def vcr_id
+        name.to_s
+      end
+    end
+
+    private
+
+    def inject_vcr_path(rendered, path)
+      fragment = Nokogiri::HTML::DocumentFragment.parse(rendered.to_s)
+      root = fragment.children.find(&:element?)
+      return rendered if root.nil?
+
+      root['data-vcr-path'] = path
+      html = fragment.to_html
+      html.respond_to?(:html_safe) ? html.html_safe : html
+    end
+
+    def ensure_vcr_state(view_context)
+      return unless view_context.respond_to?(:controller)
+
+      controller = view_context.controller
+      return unless controller.respond_to?(:request)
+
+      envelope = State::Envelope.initial(self.class, path: next_root_path(view_context))
+      adapter = ViewComponentReducible.config.adapter_for(controller)
+      @vcr_state_token = adapter.dump(envelope, request: controller.request)
+      @vcr_envelope = envelope
+    end
+
+    def next_root_path(_view_context)
+      "root/#{SecureRandom.uuid}"
+    end
+  end
+end

data/lib/view_component_reducible/configuration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ViewComponentReducible
+  # Global configuration for adapter and secrets.
+  class Configuration
+    # @return [Class]
+    attr_accessor :adapter, :secret
+
+    def initialize
+      @adapter = Adapter::Session
+      @secret = nil
+    end
+
+    # Build adapter instance for a controller request.
+    # @param controller [ActionController::Base]
+    # @param adapter_class [Class, nil]
+    # @return [ViewComponentReducible::Adapter::Base]
+    def adapter_for(_controller, adapter_class: nil)
+      resolved_secret = secret || default_secret
+      raise 'ViewComponentReducible secret is missing' if resolved_secret.nil?
+
+      (adapter_class || adapter).new(secret: resolved_secret)
+    end
+
+    private
+
+    def default_secret
+      return Rails.application.secret_key_base if defined?(Rails) && Rails.respond_to?(:application)
+
+      nil
+    end
+  end
+end

data/lib/view_component_reducible/dispatch.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module ViewComponentReducible
+  # Helpers for dispatch responses.
+  module Dispatch
+    # Inject a signed state token into HTML.
+    # @param html [String]
+    # @param signed_state [String]
+    # @return [String]
+    def self.inject_state(html, signed_state)
+      meta = %(<meta name="vcr-state" content="#{ERB::Util.html_escape(signed_state)}">)
+      script = <<~SCRIPT.chomp
+        <script>
+        (function() {
+          var meta = document.querySelector('meta[name="vcr-state"]');
+          if (!meta) return;
+          var state = meta.getAttribute('content');
+          var inputs = document.querySelectorAll('input[name="vcr_state"]');
+          inputs.forEach(function(input) { input.value = state; });
+        })();
+        </script>
+      SCRIPT
+
+      injection = meta + script
+      html.include?('</head>') ? html.sub('</head>', "#{injection}</head>") : (injection + html)
+    end
+  end
+end

data/lib/view_component_reducible/dispatch_controller.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'action_controller'
+
+module ViewComponentReducible
+  # Rails controller entry for dispatch requests.
+  class DispatchController < ActionController::Base
+    protect_from_forgery with: :exception
+
+    # @param adapter_class [Class]
+    # @return [Class, nil]
+    def self.vcr_adapter(adapter_class = nil)
+      return @vcr_adapter if adapter_class.nil?
+
+      @vcr_adapter = adapter_class
+    end
+
+    # @return [void]
+    def call
+      adapter_class = self.class.vcr_adapter || ViewComponentReducible.config.adapter
+      adapter = ViewComponentReducible.config.adapter_for(self, adapter_class: adapter_class)
+      envelope = adapter.load(request:)
+      msg = ViewComponentReducible::Msg.from_params(params)
+      target_path = params.fetch('vcr_target_path', envelope['path'])
+
+      runtime = ViewComponentReducible::Runtime.new
+      new_envelope, html = runtime.call(
+        envelope:,
+        msg:,
+        target_path:,
+        controller: self
+      )
+
+      signed = adapter.dump(new_envelope, request:)
+      if params['vcr_partial'] == '1'
+        partial_html = runtime.render_target(envelope: new_envelope, target_path:, controller: self)
+        response.set_header('X-VCR-State', signed)
+        render html: partial_html, content_type: 'text/html'
+      else
+        render html: ViewComponentReducible::Dispatch.inject_state(html, signed), content_type: 'text/html'
+      end
+    rescue ActiveSupport::MessageVerifier::InvalidSignature
+      render status: 400, plain: 'Invalid state signature'
+    end
+  end
+end

data/lib/view_component_reducible/engine.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'rails/engine'
+
+module ViewComponentReducible
+  # Rails engine for mounting dispatch routes.
+  class Engine < ::Rails::Engine
+    isolate_namespace ViewComponentReducible
+  end
+end

data/lib/view_component_reducible/helpers.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module ViewComponentReducible
+  # View helpers for dispatching messages to the VCR endpoint.
+  module Helpers
+    # Wrap component markup with a boundary for partial updates.
+    # @param path [String]
+    # @yield block for component content
+    # @return [String]
+    def vcr_boundary(path:, &block)
+      content_tag(:div, capture(&block), data: { vcr_path: path })
+    end
+
+    # Build a dispatch form with hidden fields for the VCR endpoint.
+    # @param state [String] signed state token
+    # @param msg_type [String]
+    # @param msg_payload [Hash, String]
+    # @param target_path [String, nil]
+    # @param url [String]
+    # @yield block for the form body (e.g., submit button)
+    # @return [String]
+    def vcr_dispatch_form(state:, msg_type:, msg_payload: {}, target_path: nil, url: '/vcr/dispatch', &block)
+      payload = msg_payload.is_a?(String) ? msg_payload : JSON.generate(msg_payload)
+      resolved_target = target_path || vcr_envelope_path || instance_variable_get(:@vcr_current_path) || 'root'
+
+      form_tag(url, method: :post, data: { vcr_form: true }) do
+        body = [
+          hidden_field_tag('vcr_state', state),
+          hidden_field_tag('vcr_msg_type', msg_type),
+          hidden_field_tag('vcr_msg_payload', payload),
+          hidden_field_tag('vcr_target_path', resolved_target),
+          (block_given? ? capture(&block) : '')
+        ]
+        safe_join(body)
+      end
+    end
+
+    # Insert the minimal JS dispatcher for partial updates.
+    # @return [String]
+    def vcr_dispatch_script_tag
+      js = <<~JS
+        (function() {
+          if (window.__vcrDispatchInstalled) return;
+          window.__vcrDispatchInstalled = true;
+          document.addEventListener("submit", function(event) {
+            var form = event.target;
+            if (!(form instanceof HTMLFormElement)) return;
+            if (!form.matches("[data-vcr-form]")) return;
+            event.preventDefault();
+            var formData = new FormData(form);
+            formData.append("vcr_partial", "1");
+            fetch(form.action, {
+              method: (form.method || "POST").toUpperCase(),
+              body: formData,
+              headers: { "X-Requested-With": "XMLHttpRequest" }
+            })
+              .then(function(response) {
+                var state = response.headers.get("X-VCR-State");
+                return response.text().then(function(html) {
+                  return { html: html, state: state };
+                });
+              })
+              .then(function(payload) {
+                var targetPath = formData.get("vcr_target_path");
+                var parser = new DOMParser();
+                var doc = parser.parseFromString(payload.html, "text/html");
+                var newNode = doc.querySelector('[data-vcr-path="' + targetPath + '"]') || doc.body.firstElementChild;
+                var current = document.querySelector('[data-vcr-path="' + targetPath + '"]');
+                if (newNode && current) {
+                  current.replaceWith(newNode);
+                }
+                if (payload.state) {
+                  var boundary = document.querySelector('[data-vcr-path="' + targetPath + '"]');
+                  if (boundary) {
+                    boundary.querySelectorAll('input[name="vcr_state"]').forEach(function(input) {
+                      input.value = payload.state;
+                    });
+                  }
+                }
+              });
+          });
+        })();
+      JS
+      content_tag(:script, js.html_safe)
+    end
+
+    def vcr_envelope_path
+      return unless respond_to?(:vcr_envelope) && vcr_envelope
+
+      vcr_envelope['path']
+    end
+  end
+end

data/lib/view_component_reducible/msg.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module ViewComponentReducible
+  # Message payload sent from the client.
+  Msg = Struct.new(:type, :payload, keyword_init: true) do
+    # Enable pattern matching with normalized symbol types.
+    # @param keys [Array<Symbol>, nil]
+    # @return [Hash{Symbol=>Object}]
+    def deconstruct_keys(keys)
+      payload_hash = { type: normalized_type, payload: payload }
+      keys ? payload_hash.slice(*keys) : payload_hash
+    end
+
+    # Build a Msg from request params.
+    # @param params [Hash]
+    # @return [ViewComponentReducible::Msg]
+    def self.from_params(params)
+      type = params.fetch('vcr_msg_type')
+      payload_json = params['vcr_msg_payload']
+      payload = payload_json && payload_json != '' ? JSON.parse(payload_json) : {}
+      new(type:, payload:)
+    end
+
+    private
+
+    def normalized_type
+      type.to_s
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr('-', '_')
+          .downcase
+          .to_sym
+    end
+  end
+end

data/lib/view_component_reducible/railtie.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+
+module ViewComponentReducible
+  # Railtie for wiring helpers into ActionView.
+  class Railtie < ::Rails::Railtie
+    initializer 'view_component_reducible.helpers' do
+      ActiveSupport.on_load(:action_view) do
+        include ViewComponentReducible::Helpers
+      end
+    end
+  end
+end

data/lib/view_component_reducible/runtime.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module ViewComponentReducible
+  # Core runtime for dispatching messages and rendering components.
+  class Runtime
+    MAX_EFFECT_STEPS = 8
+
+    # @param envelope [Hash]
+    # @param msg [ViewComponentReducible::Msg]
+    # @param target_path [String]
+    # @param controller [ActionController::Base]
+    # @return [Array<Hash, String>] [new_envelope, html]
+    def call(envelope:, msg:, target_path:, controller:)
+      root_klass = ViewComponentReducible.registry.fetch(envelope['root'])
+      new_env = deep_dup(envelope)
+
+      new_env = dispatch_to_path(root_klass, new_env, msg, target_path, controller)
+      html = render_root(root_klass, new_env, controller)
+      [new_env, html]
+    end
+
+    # Render HTML for a specific path after state updates.
+    # @param envelope [Hash]
+    # @param target_path [String]
+    # @param controller [ActionController::Base]
+    # @return [String]
+    def render_target(envelope:, target_path:, controller:)
+      root_klass = ViewComponentReducible.registry.fetch(envelope['root'])
+      component_klass, env = find_env_and_class(root_klass, envelope, target_path)
+      controller.view_context.render(component_klass.new(vcr_envelope: env))
+    end
+
+    private
+
+    def dispatch_to_path(root_klass, env, msg, target_path, controller)
+      if target_path == env['path']
+        apply_reducer(root_klass, env, msg, controller)
+      else
+        child = env['children'].fetch(target_path) { raise KeyError, "Unknown path: #{target_path}" }
+        child_klass = ViewComponentReducible.registry.fetch(child['root'])
+        env['children'][target_path] = dispatch_to_path(child_klass, child, msg, target_path, controller)
+        env
+      end
+    end
+
+    def apply_reducer(component_klass, env, msg, controller)
+      component = component_klass.new(vcr_envelope: env)
+      schema = component_klass.vcr_state_schema
+      state = schema.build_data(env['data'])
+
+      new_state = component.reduce(state, msg)
+      env['data'] = normalize_state(new_state, schema)
+      effects = build_effects(component, schema, env['data'], msg)
+
+      run_effects(component_klass, env, effects, controller)
+    end
+
+    def run_effects(component_klass, env, effects, controller)
+      return env if effects.nil? || effects.empty?
+
+      effects_queue = effects.dup
+      steps = 0
+
+      while (eff = effects_queue.shift)
+        steps += 1
+        raise 'Too many effect steps' if steps > MAX_EFFECT_STEPS
+
+        follow_msg = eff.call(controller: controller, envelope: env)
+        next unless follow_msg
+
+        component = component_klass.new(vcr_envelope: env)
+        schema = component_klass.vcr_state_schema
+        state = schema.build_data(env['data'])
+
+        new_state = component.reduce(state, follow_msg)
+        env['data'] = normalize_state(new_state, schema)
+        new_effects = build_effects(component, schema, env['data'], follow_msg)
+        effects_queue.concat(Array(new_effects))
+      end
+
+      env
+    end
+
+    def render_root(root_klass, env, controller)
+      controller.view_context.render(root_klass.new(vcr_envelope: env))
+    end
+
+    def find_env_and_class(component_klass, env, target_path)
+      return [component_klass, env] if target_path == env['path']
+
+      child = env['children'].fetch(target_path) { raise KeyError, "Unknown path: #{target_path}" }
+      child_klass = ViewComponentReducible.registry.fetch(child['root'])
+      find_env_and_class(child_klass, child, target_path)
+    end
+
+    def normalize_state(state, schema)
+      if state.is_a?(schema.data_class)
+        state.to_h.transform_keys(&:to_s)
+      elsif state.is_a?(Hash)
+        schema.build(state)
+      else
+        raise ArgumentError, "Reducer must return a Hash or #{schema.data_class}"
+      end
+    end
+
+    def build_effects(component, schema, state_hash, msg)
+      return [] unless component.respond_to?(:effects)
+
+      state = schema.build_data(state_hash)
+      Array(component.effects(state, msg))
+    end
+
+    def deep_dup(obj)
+      Marshal.load(Marshal.dump(obj))
+    end
+  end
+end

data/lib/view_component_reducible/state/dsl.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ViewComponentReducible
+  module State
+    # DSL for defining state schemas on components.
+    module DSL
+      # Hook to extend class methods when included.
+      # @param base [Class]
+      # @return [void]
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # Define a state schema for the component.
+        # @yield DSL block to declare fields.
+        # @return [void]
+        def state(&block)
+          schema = Schema.new
+          dsl = Builder.new(schema)
+          dsl.instance_eval(&block)
+          @vcr_state_schema = schema
+
+          define_singleton_method(:vcr_state_schema) { @vcr_state_schema }
+        end
+      end
+
+      class Builder
+        def initialize(schema) = (@schema = schema)
+
+        # Define a state field.
+        # @param name [Symbol]
+        # @param default [Object, #call]
+        # @return [void]
+        def field(name, default:)
+          @schema.add_field(name, default:)
+        end
+      end
+    end
+  end
+end

data/lib/view_component_reducible/state/envelope.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ViewComponentReducible
+  module State
+    # Envelope builder for initial state payloads.
+    class Envelope
+      # Build an initial envelope for a component.
+      # @param root_component_klass [Class]
+      # @param path [String]
+      # @return [Hash{String=>Object}]
+      def self.initial(root_component_klass, path: 'root')
+        schema = root_component_klass.vcr_state_schema
+        data = schema.defaults
+        {
+          'v' => 1,
+          'root' => root_component_klass.vcr_id,
+          'path' => path,
+          'data' => data,
+          'children' => {}
+        }
+      end
+    end
+  end
+end

data/lib/view_component_reducible/state/schema.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ViewComponentReducible
+  module State
+    # State schema for defining default fields and building state payloads.
+    class Schema
+      Field = Struct.new(:name, :default, keyword_init: true)
+
+      def initialize
+        @fields = []
+        @data_class = nil
+        @data_class_fields = nil
+      end
+
+      # Add a field definition.
+      # @param name [Symbol]
+      # @param default [Object, #call]
+      # @return [void]
+      def add_field(name, default:)
+        @fields << Field.new(name:, default:)
+      end
+
+      # @return [Class]
+      def data_class
+        field_names = @fields.map(&:name)
+        return @data_class if @data_class && @data_class_fields == field_names
+
+        defaults_proc = -> { build({}) }
+        @data_class_fields = field_names
+        @data_class = Data.define(*field_names) do
+          def [](key)
+            to_h[key.to_sym]
+          end
+
+          define_method(:with_defaults) do
+            defaults = defaults_proc.call.transform_keys(&:to_sym)
+            self.class.new(**defaults)
+          end
+        end
+      end
+
+      # Build state hashes from input payloads.
+      # @param state_hash [Hash]
+      # @return [Hash{String=>Object}]
+      def build(state_hash)
+        data = {}
+        @fields.each do |field|
+          src = state_hash || {}
+          value = if src.key?(field.name.to_s)
+                    src[field.name.to_s]
+                  elsif src.key?(field.name)
+                    src[field.name]
+                  end
+          value = field.default.call if value.nil? && field.default.respond_to?(:call)
+          value = field.default if value.nil? && !field.default.respond_to?(:call)
+
+          data[field.name.to_s] = value
+        end
+        data
+      end
+
+      # Build a Data object from input payloads.
+      # @param state_hash [Hash]
+      # @return [Data]
+      def build_data(state_hash)
+        data = build(state_hash)
+        data_class.new(**data.transform_keys(&:to_sym))
+      end
+
+      # Build default state hashes.
+      # @return [Hash{String=>Object}]
+      def defaults
+        build({})
+      end
+    end
+  end
+end

data/lib/view_component_reducible/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ViewComponentReducible
-  VERSION = "0.1.0"
+  VERSION = '0.1.2'
 end

data/lib/view_component_reducible.rb

@@ -1,8 +1,44 @@
 # frozen_string_literal: true
 
-require_relative "view_component_reducible/version"
+require_relative 'view_component_reducible/version'
+require_relative 'view_component_reducible/configuration'
+require_relative 'view_component_reducible/msg'
+require_relative 'view_component_reducible/adapter/base'
+require_relative 'view_component_reducible/adapter/hidden_field'
+require_relative 'view_component_reducible/adapter/session'
+require_relative 'view_component_reducible/helpers'
+require_relative 'view_component_reducible/state/schema'
+require_relative 'view_component_reducible/state/dsl'
+require_relative 'view_component_reducible/state/envelope'
+require_relative 'view_component_reducible/component'
+require_relative 'view_component_reducible/runtime'
+require_relative 'view_component_reducible/dispatch'
+require_relative 'view_component_reducible/dispatch_controller'
+require_relative 'view_component_reducible/engine'
+require_relative 'view_component_reducible/railtie'
 
 module ViewComponentReducible
   class Error < StandardError; end
-  # Your code goes here...
+
+  # @return [Hash{String=>Class}]
+  def self.registry
+    @registry ||= {}
+  end
+
+  # @param component_klass [Class]
+  # @return [void]
+  def self.register(component_klass)
+    registry[component_klass.vcr_id] = component_klass
+  end
+
+  # @return [ViewComponentReducible::Configuration]
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  # @yield [ViewComponentReducible::Configuration]
+  # @return [void]
+  def self.configure
+    yield config
+  end
 end

metadata

@@ -1,15 +1,86 @@
 --- !ruby/object:Gem::Specification
 name: view_component_reducible
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - manabeai
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: view_component
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: |
+  This gem is intentionally published early. The API is unstable, but the idea is stable.
   view_component_reducible brings reducer-style (TEA-inspired) state transitions
   to Rails ViewComponent. Server-driven, HTTP-based, no WebSocket required.
 email:
@@ -21,6 +92,21 @@ files:
 - LICENSE.txt
 - README.md
 - lib/view_component_reducible.rb
+- lib/view_component_reducible/adapter/base.rb
+- lib/view_component_reducible/adapter/hidden_field.rb
+- lib/view_component_reducible/adapter/session.rb
+- lib/view_component_reducible/component.rb
+- lib/view_component_reducible/configuration.rb
+- lib/view_component_reducible/dispatch.rb
+- lib/view_component_reducible/dispatch_controller.rb
+- lib/view_component_reducible/engine.rb
+- lib/view_component_reducible/helpers.rb
+- lib/view_component_reducible/msg.rb
+- lib/view_component_reducible/railtie.rb
+- lib/view_component_reducible/runtime.rb
+- lib/view_component_reducible/state/dsl.rb
+- lib/view_component_reducible/state/envelope.rb
+- lib/view_component_reducible/state/schema.rb
 - lib/view_component_reducible/version.rb
 homepage: https://github.com/manabeai/view_component_reducible
 licenses:
@@ -36,7 +122,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="