live_component 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a94ea37093288d3f0b8a8c8b843edbaecb90432df85e5f0ad8616e57e0ec6ee2
+  data.tar.gz: 062fdc7ae9925cfdeb34f2ed58b51fa553544eb75d88c2001244e4df1702eea7
+SHA512:
+  metadata.gz: 5973e55e49860be0d89d62e707b8b23e07b5fc3632ab8d5525b2be29a119fa74ace9e5981381ffa6a81a390bb2832c31c7c48f73b1cc1232b9e3d49a09b0609e
+  data.tar.gz: dabe8e9473069e34225cfacae0ffe1d663d77f0fc7c4a8a0d9989e327561090dd2943a2b0f8869ffd004b9337d9fe874dd32851d969ff75603be9922d9ba6888

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+# 1.0.0
+* Birthday!

data/Gemfile

@@ -0,0 +1 @@
+eval_gemfile "test/dummy/Gemfile"

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Cameron Dutro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Rakefile

@@ -0,0 +1,41 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be included in the set of available tasks.
+
+ENV["RAILS_ENV"] ||= "test"
+
+require "rubygems/package_task"
+Bundler::GemHelper.install_tasks
+
+require_relative "test/dummy/config/application"
+
+# Load tasks but skip the test unit tasks to avoid the "rails new" help output
+Rails.application.load_tasks
+
+# Override the Rails test:system task to use our custom implementation
+Rake::Task["test:system"].clear if Rake::Task.task_defined?("test:system")
+Rake::Task["test"].clear if Rake::Task.task_defined?("test")
+
+task default: :test
+
+namespace :test do
+  task :setup do
+    $:.push(File.join(__dir__, "test"))
+
+    require "test_helper"
+    require "minitest/autorun"
+  end
+
+  desc "Run unit tests"
+  task unit: :setup do
+    # Run all system tests
+    Dir.glob("test/unit/**/*_test.rb").each { |file| require_relative file }
+  end
+
+  desc "Run system tests"
+  task system: :setup do
+    # Run all system tests
+    Dir.glob("test/system/**/*_test.rb").each { |file| require_relative file }
+  end
+end
+
+task test: ["test:unit", "test:system"]

data/app/channels/live_component_channel.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "json"
+
+class LiveComponentChannel < ActionCable::Channel::Base
+  def subscribed
+    stream_from "live_component"
+  end
+
+  def receive(data)
+    request_id = data["request_id"]
+    payload = JSON.parse(data["payload"])
+
+    result = LiveComponent::RenderController.renderer.render(
+      :show, assigns: { state: payload["state"], reflexes: payload["reflexes"] }, layout: false
+    )
+
+    ActionCable.server.broadcast(
+      "live_component",
+      { payload: result, request_id: request_id }
+    )
+  end
+end

data/app/components/live_component/render_component.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module LiveComponent
+  class RenderComponent < ViewComponent::Base
+    def initialize(state, reflexes, prop_overrides = {})
+      @state = LiveComponent::State.build(state, prop_overrides)
+      @reflexes = reflexes
+    end
+
+    def render_in(view_context, &block)
+      component = @state.klass.new(**@state.props.symbolize_keys)
+
+      @reflexes.each do |reflex|
+        method_name = reflex["method_name"] || reflex[:method_name]
+
+        props = (reflex["props"] || reflex[:props] || {}).each_with_object({}) do |(k, v), memo|
+          memo[k.to_sym] = LiveComponent.serializer.deserialize(v)
+        end
+
+        SafeDispatcher.send_safely(component, method_name, **props)
+      end
+
+      component.render_in(view_context) do
+        apply_slots(component, @state.slots)
+        block.call(component) if block
+        @state.content
+      end
+    end
+
+    private
+
+    def apply_slots(component_instance, slots)
+      slots.each do |slot_method, slot_defs|
+        slot_defs.each do |slot_def|
+          component_instance.send("with_#{slot_method}", **slot_def.props) do |slot_instance|
+            apply_slots(slot_instance, slot_def.slots)
+            slot_def.content
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/live_component/render_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module LiveComponent
+  class RenderController < ActionController::Base
+    def show
+      render layout: false, formats: [:html]
+    end
+  end
+end

data/app/helpers/live_component/application_helper.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module LiveComponent
+  module ApplicationHelper
+    def live
+      @__lc_tag_builder ||= LiveComponent::TagBuilder.new(self)
+    end
+
+    def form_with(rerender: nil, html: {}, **options, &block)
+      if (params = Utils.html_params_for_rerender(rerender))
+        html.merge!(params)
+      end
+
+      options = ::LiveComponent::Utils.translate_all_attrs(options)
+
+      super(**options, html: html, &block)
+    end
+
+    def button_to(*args, rerender: nil, form: {}, **options, &block)
+      if (params = Utils.html_params_for_rerender(rerender))
+        form.merge!(params)
+      end
+
+      options = ::LiveComponent::Utils.translate_all_attrs(options)
+
+      super(*args, **options, form: form, &block)
+    end
+
+    def content_tag(name, content_or_options_with_block = nil, options = nil, escape = true, &block)
+      if block_given?
+        options = content_or_options_with_block if content_or_options_with_block.is_a?(Hash)
+      end
+
+      options ||= {}
+      options = ::LiveComponent::Utils.translate_all_attrs(options)
+
+      super
+    end
+  end
+end

data/app/views/live_component/render/show.html.erb

@@ -0,0 +1 @@
+<%= render(LiveComponent::RenderComponent.new(@state, @reflexes)) %>

data/config/routes.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+LiveComponent::Engine.routes.draw do
+  post "/render", to: "render#show", as: "render"
+end

data/ext/view_component_patch.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "view_component"
+
+module LiveComponent
+  module ViewComponentPatch
+    def self.included(base)
+      base.singleton_class.prepend(ClassMethodOverrides)
+    end
+
+    module ClassMethodOverrides
+      def new(*args, **kwargs, &block)
+        return super unless kwargs[:actions] || kwargs[:targets]
+
+        kwargs = ::LiveComponent::Utils.translate_attrs(Action, kwargs) if kwargs[:actions]
+        kwargs = ::LiveComponent::Utils.translate_attrs(Target, kwargs) if kwargs[:targets]
+
+        super
+      end
+    end
+  end
+end

data/lib/live_component/action.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module LiveComponent
+  class Action
+    def initialize(controller_name, event_name)
+      @controller_name = controller_name
+      @event_name = event_name
+    end
+
+    def call(method_name)
+      @method_name = method_name
+      self
+    end
+
+    def self.attr_name
+      :actions
+    end
+
+    def attr_name
+      self.class.attr_name
+    end
+
+    def to_attributes
+      { data: {} }.tap do |attrs|
+        if @method_name
+          attrs[:data][:action] = "#{@event_name}->#{@controller_name}##{@method_name}"
+        end
+      end
+    end
+  end
+end

data/lib/live_component/base.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require "use_context"
+
+module LiveComponent
+  module Base
+    JS_SIDECAR_EXTENSIONS = %w(js ts jsx tsx).freeze
+
+    def self.included(base)
+      base.prepend(Overrides)
+      base.include(InstanceMethods)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def __lc_js_sidecar_files
+        @__lc_js_sidecar_files ||= sidecar_files(JS_SIDECAR_EXTENSIONS)
+      end
+
+      def __lc_init_args
+        @__lc_init_args ||= instance_method(:initialize).super_method.parameters
+      end
+
+      def __lc_compile_if_necessary!
+        return if @__lc_compiled
+
+        if registered_slots.empty?
+          @__lc_compiled = true
+          return
+        end
+
+        registered_slots.each do |slot_name, slot_config|
+          is_collection = slot_type(slot_name) == :collection
+          singular_name = is_collection ? ActiveSupport::Inflector.singularize(slot_name) : slot_name
+
+          __lc_slot_mod.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def with_#{singular_name}(**props, &block)
+              new_slot_data = {}
+              new_slot_data[:props] = props unless props.empty?
+
+              @__lc[:slots] ||= {}
+              @__lc[:slots][#{singular_name.inspect}] ||= []
+              @__lc[:slots][#{singular_name.inspect}] << new_slot_data
+
+              singular_name = #{singular_name.inspect}
+              slot_def = registered_slots[#{slot_name.inspect}]
+
+              UseContext.provide_context(:__lc_context, { slot_name: singular_name, slot_def: slot_def }) do
+                if block
+                  super(**props) do |**block_props|
+                    slot = block.call(**block_props)
+
+                    if slot.is_a?(ViewComponent::Slot)
+                      content = slot.instance_variable_get(:@__vc_content)
+                      new_slot_data[:content] = Utils.normalize_html_whitespace(content) if content
+                    end
+
+                    if (instance = slot.instance_variable_get(:@__vc_component_instance))
+                      if instance.respond_to?(:__lc_attributes)
+                        new_slot_data[:props][:__lc_attributes] ||= {}
+                        new_slot_data[:props][:__lc_attributes]["data-id"] = instance.__lc_attributes["data-id"]
+                      end
+                    end
+
+                    slot
+                  end
+                else
+                  super
+                end
+              end
+            end
+          RUBY
+        end
+
+        unless self < __lc_slot_mod
+          prepend(__lc_slot_mod)
+        end
+
+        @__lc_compiled = true
+      end
+
+      def __lc_slot_mod
+        @__lc_slot_mod ||= Module.new
+      end
+
+      # For collections
+      def __vc_initialize_parameters
+        @__vc_initialize_parameters ||= instance_method(:initialize).super_method.parameters
+      end
+
+      def __lc_controller
+        # If there are any sidecar js files, assume one of them defines a controller
+        # named after the Ruby class. Otherwise, use the default LiveController.
+        @__lc_controller ||= __lc_js_sidecar_files.empty? ? "live" : self.name.dasherize.downcase.gsub("::", "-")
+      end
+
+      def serializes(prop_name, with: nil, **serializer_options, &block)
+        if block && with
+          raise "Expected `#{__method__}' to be called with a block or the with: parameter, but both were provided"
+        end
+
+        if block
+          builder = InlineSerializer::Builder.new
+          block.call(builder, **serializer_options)
+          prop_serializers[prop_name] = builder.to_serializer
+          return
+        end
+
+        unless with
+          raise "Expected `#{__method__}' to be called with a block or the with: parameter"
+        end
+
+        unless LiveComponent.registered_prop_serializers.include?(with)
+          raise "Could not find a serializer with the name '#{with}' - is it registered?"
+        end
+
+        prop_serializers[prop_name] = LiveComponent.registered_prop_serializers[with].make(**serializer_options)
+
+        nil
+      end
+
+      def prop_serializers
+        @prop_serializers ||= {}
+      end
+
+      def serialize_props(props)
+        {}.tap do |serialized_props|
+          props.each_pair do |k, v|
+            k = k.to_sym
+            serializer = prop_serializers[k] ||= LiveComponent.serializer
+            serialized_props[k] = serializer.serialize(v)
+          end
+        end
+      end
+
+      def deserialize_props(props)
+        {}.tap do |deserialized_props|
+          props.each_pair do |k, v|
+            k = k.to_sym
+            serializer = prop_serializers[k] ||= LiveComponent.serializer
+            deserialized_props[k] = serializer.deserialize(v)
+          end
+        end
+      end
+    end
+
+    module InstanceMethods
+      attr_reader :__lc_attributes
+
+      def __lc_id
+        @__lc_id ||= @__lc_attributes["data-id"] || SecureRandom.uuid
+      end
+
+      def fn(method_name)
+        "fn:#{__lc_id}##{method_name}"
+      end
+
+      def on(event_name)
+        Action.new(__lc_controller, event_name)
+      end
+
+      def target(target_name)
+        Target.new(__lc_controller, target_name)
+      end
+
+      private
+
+      def __lc_tag_name
+        @__lc_tag_name ||= if self.class.__lc_js_sidecar_files.empty?
+          "live-component"
+        else
+          self.class.name.gsub("::", "-").downcase.yield_self do |name|
+            if name.split("-").size == 1
+              "lc-#{name}"  # custom element names have to be more than one word
+            else
+              name
+            end
+          end
+        end
+      end
+
+      def __lc_controller
+        self.class.__lc_controller
+      end
+    end
+
+    module Overrides
+      def initialize(__lc_attributes: {}, **props, &block)
+        @__lc = { ruby_class: self.class.name }
+        @__lc_attributes = __lc_attributes
+
+        UseContext.use_context(:__lc_context, :slot_name) do |slot_name|
+          @__lc_slot_name = slot_name if slot_name
+        end
+
+        self.class.__lc_compile_if_necessary!
+
+        super(**props, &block)
+      end
+
+      def render_in(view_context, &block)
+        props = {
+          __lc_attributes: @__lc_attributes.merge(
+            "data-id" => __lc_id
+          )
+        }
+
+        current_state = State.new(
+          klass: self.class,
+          props: props,
+          slots: @__lc[:slots] || {},
+          children: @__lc[:children] || {},
+        )
+
+        result = UseContext.use_context(:__lc_context, :state) do |parent_state|
+          if !parent_state
+            current_state.root!
+          end
+
+          if parent_state
+            if @__lc_slot_name
+              parent_state.slots[@__lc_slot_name] ||= []
+              parent_state.slots[@__lc_slot_name] << current_state
+            else
+              parent_state.children[__lc_id] = current_state
+            end
+          end
+
+          UseContext.provide_context(:__lc_context, { state: current_state }) do
+            super
+          end
+        end
+
+        self.class.__lc_init_args.each do |(type, name)|
+          if type == :key || type == :keyreq
+            props[name] = instance_variable_get(:"@#{name}")
+          elsif type == :keyrest
+            props.merge!(instance_variable_get(:"@#{name}"))
+          end
+        end
+
+        if @__vc_content
+          @__lc[:content] = Utils.normalize_html_whitespace(@__vc_content)
+          current_state.content = @__lc[:content]
+        end
+
+        attributes = {
+          "data-id" => __lc_id,
+          "data-controller" => __lc_controller,
+          "data-livecomponent" => "true",
+          "data-component" => self.class.name,
+          **@__lc_attributes,
+        }
+
+        if current_state.root?
+          attributes["data-state"] = current_state.to_json
+        end
+
+        if @__lc_slot_name
+          attributes["data-slot-name"] = @__lc_slot_name
+        end
+
+        content_tag(__lc_tag_name, result, **attributes)
+      end
+    end
+  end
+end

data/lib/live_component/big_decimal_serializer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module LiveComponent
+  class BigDecimalSerializer < ObjectSerializer
+    private
+
+    def object_to_hash(big_decimal)
+      { "value" => big_decimal.to_s }
+    end
+
+    def hash_to_object(hash)
+      BigDecimal(hash["value"])
+    end
+  end
+end

data/lib/live_component/component.html.erb

@@ -0,0 +1,4 @@
+<%= render(component_klass.new(**@component_def.args)) do |component| %>
+  <% apply_slots(component, @component_def.slots) %>
+  <%= @component_def.content %>
+<% end %>

data/lib/live_component/controller_methods.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module LiveComponent
+  module ControllerMethods
+    def live
+      helpers.live
+    end
+  end
+end

data/lib/live_component/date_serializer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module LiveComponent
+  class DateSerializer < ObjectSerializer
+    private
+
+    def object_to_hash(date)
+      { "value" => date.iso8601 }
+    end
+
+    def hash_to_object(hash)
+      Date.iso8601(hash["value"])
+    end
+  end
+end

data/lib/live_component/date_time_serializer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module LiveComponent
+  class DateTimeSerializer < TimeObjectSerializer
+    private
+
+    def hash_to_object(hash)
+      DateTime.iso8601(hash["value"])
+    end
+  end
+end

data/lib/live_component/duration_serializer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module LiveComponent
+  class DurationSerializer < ObjectSerializer
+    private
+
+    def object_to_hash(duration)
+      { "value" => duration.value, "parts" => LiveComponent.serializer.serialize(duration.parts.to_a) }
+    end
+
+    def hash_to_object(hash)
+      value = hash["value"]
+      parts = LiveComponent.serializer.deserialize(hash["parts"].to_h)
+      # `parts` is originally a hash, but will have been flattened to an array by serializer.deserialize
+      ActiveSupport::Duration.new(value, parts.to_h)
+    end
+  end
+end

data/lib/live_component/engine.rb

@@ -0,0 +1,21 @@
+require "live_component"
+
+module LiveComponent
+  class Engine < ::Rails::Engine
+    isolate_namespace LiveComponent
+
+    initializer "live-component.include_helpers" do
+      ActiveSupport.on_load(:action_controller) do
+        helper LiveComponent::ApplicationHelper
+        include LiveComponent::ControllerMethods
+      end
+    end
+
+    initializer "live-component.patch_vc" do
+      ActiveSupport.on_load(:view_component) do
+        include LiveComponent::ViewComponentPatch
+        include LiveComponent::ApplicationHelper
+      end
+    end
+  end
+end

data/lib/live_component/inline_serializer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module LiveComponent
+  class InlineSerializer
+    class Builder
+      def serialize(&block)
+        @serializer_proc = block
+        self
+      end
+
+      def deserialize(&block)
+        @deserializer_proc = block
+        self
+      end
+
+      def to_serializer
+        InlineSerializer.new(@serializer_proc, @deserializer_proc)
+      end
+    end
+
+    def initialize(serializer_proc, deserializer_proc)
+      @serializer_proc = serializer_proc
+      @deserializer_proc = deserializer_proc
+    end
+
+    def serialize(object)
+      @serializer_proc ? @serializer_proc.call(object) : object
+    end
+
+    def deserialize(hash)
+      @deserializer_proc ? @deserializer_proc.call(hash) : hash
+    end
+  end
+end