live_component 0.1.0

data/lib/live_component/middleware.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module LiveComponent
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      if env["PATH_INFO"] == "/live_component/render"
+        raw_data = env["rack.input"].read
+        data = JSON.parse(raw_data)
+        payload = JSON.parse(data["payload"])
+
+        result = LiveComponent::RenderController.renderer.render(
+          :show, assigns: { state: payload["state"], reflexes: payload["reflexes"] }, layout: false
+        )
+
+        return [200, { "Content-Type" => "text/html" }, [result]]
+      end
+
+      @app.call(env)
+    end
+  end
+end

data/lib/live_component/model_serializer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module LiveComponent
+  class ModelSerializer
+    MODEL_SERIALIZER_KEY = "_lc_ar".freeze
+
+    attr_reader :sign, :load, :attributes
+
+    alias sign? sign
+    alias load? load
+
+    def self.make(...)
+      new(...)
+    end
+
+    def initialize(sign: true, load: false, attributes: true)
+      @sign = sign
+      @attributes = attributes.is_a?(Array) ? attributes.map(&:to_s) : attributes
+    end
+
+    def serialize(object)
+      gid = sign? ? object.to_signed_global_id : object.to_global_id
+
+      { MODEL_SERIALIZER_KEY => { "gid" => gid.to_s, "signed" => sign? } }.tap do |result|
+        object_attributes = if object.is_a?(RecordProxy)
+          object.cached_attributes
+        else
+          object.attributes
+        end
+
+        attributes_hash = if attributes.is_a?(Array)
+          object_attributes.slice(*attributes)
+        elsif attributes  # true case
+          object_attributes
+        end
+
+        if attributes_hash
+          attributes_hash.each_pair do |k, v|
+            result[k] = LiveComponent.serializer.serialize(v)
+          end
+        end
+      end
+    rescue URI::GID::MissingModelIdError
+      raise SerializationError, "Unable to serialize #{object.class} " \
+        "without an id. (Maybe you forgot to call save?)"
+    end
+
+    def deserialize(hash)
+      gid_attrs = hash[MODEL_SERIALIZER_KEY]
+      gid = gid_attrs["gid"]
+      signed = gid_attrs["signed"]
+
+      if load?
+        if signed
+          GlobalID::Locator.locate_signed(gid)
+        else
+          GlobalID::Locator.locate(gid)
+        end
+      else
+        parsed_gid = signed ? SignedGlobalID.parse(gid) : GlobalID.parse(gid)
+        RecordProxy.for(parsed_gid, hash.except("_lc_ar"))
+      end
+    end
+  end
+end

data/lib/live_component/module_serializer.rb

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

data/lib/live_component/object_serializer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module LiveComponent
+  class ObjectSerializer
+    OBJECT_SERIALIZER_KEY = "_lc_ser"
+
+    def self.make(...)
+      new(...)
+    end
+
+    def serialize(object)
+      { OBJECT_SERIALIZER_KEY => object.class.name }.merge!(object_to_hash(object))
+    end
+
+    def deserialize(hash)
+      hash_to_object(hash)
+    end
+
+    private
+
+    def object_to_hash(_object)
+      raise NotImplementedError, "please define #{__method__} in derived classes"
+    end
+
+    def hash_to_object(_hash)
+      raise NotImplementedError, "please define #{__method__} in derived classes"
+    end
+  end
+end

data/lib/live_component/range_serializer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module LiveComponent
+  class RangeSerializer < ObjectSerializer
+    private
+
+    def object_to_hash(range)
+      {
+        "begin" => LiveComponent.serializer.serialize(range.begin),
+        "end" => LiveComponent.serializer.serialize(range.end),
+        "exclude_end" => range.exclude_end?, # Always boolean, no need to serialize
+      }
+    end
+
+    def hash_to_object(hash)
+      Range.new(*LiveComponent.serializer.deserialize([hash["begin"], hash["end"]]), hash["exclude_end"])
+    end
+  end
+end

data/lib/live_component/react.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module LiveComponent
+  class React < ViewComponent::Base
+    include LiveComponent::Base
+
+    def initialize(component:, **props)
+      @component = component
+      @props = props
+    end
+
+    def call
+      ""
+    end
+
+    def __lc_tag_name
+      "live-component-react"
+    end
+
+    def __lc_controller
+      "livereact"
+    end
+  end
+end

data/lib/live_component/record_proxy.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module LiveComponent
+  class RecordProxy
+    class << self
+      def for(gid, attributes = {})
+        proxy_mixins[gid.model_class] ||= Module.new.tap do |mod|
+          mtds = (gid.model_class.column_names - ["id"]).map do |column_name|
+            <<~RUBY
+              def #{column_name}
+                return @record.#{column_name} if @record
+
+                if @attributes.include?("#{column_name}")
+                  return @attributes["#{column_name}"]
+                end
+
+                load
+
+                @record.#{column_name}
+              end
+            RUBY
+          end
+
+          mod.class_eval(mtds.join("\n"), __FILE__, __LINE__)
+        end
+
+        new(gid, attributes).tap do |proxy|
+          proxy.singleton_class.include(proxy_mixins[gid.model_class])
+        end
+      end
+
+      private
+
+      def proxy_mixins
+        @proxy_mixins ||= {}
+      end
+    end
+
+    def initialize(gid, attributes)
+      @gid = gid
+      @attributes = attributes
+    end
+
+    def cached_attributes
+      @attributes
+    end
+
+    def method_missing(method_name, *args, **kwargs, &block)
+      load unless @record
+      @record.send(method_name, *args, **kwargs, &block)
+    end
+
+    def load
+      @record ||= GlobalID::Locator.locate(@gid)
+    end
+
+    def reload
+      @record = @record ? @record.reload : load
+    end
+
+    def id
+      @id ||= @gid.model_class.type_for_attribute("id").cast(@gid.model_id)
+    end
+
+    def to_global_id
+      GlobalID.new(@gid.uri)
+    end
+
+    def to_signed_global_id
+      SignedGlobalID.new(@gid.uri)
+    end
+
+    def to_model
+      self
+    end
+
+    def to_param
+      id.to_s
+    end
+
+    def persisted?
+      true
+    end
+  end
+end

data/lib/live_component/safe_dispatcher.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# this is a gem that conditionally loads a backport of ObjectSpace::WeakKeyMap for
+# ruby 3.2 and older
+require "weak_key_map"
+
+module LiveComponent
+  class SafeDispatcher
+    include Singleton
+
+    def initialize
+      @cache = ObjectSpace::WeakKeyMap.new
+    end
+
+    def send_safely(receiver, method_name, **kwargs)
+      if receiver_defines_safe_method?(receiver, method_name)
+        receiver.send(method_name, **kwargs)
+      else
+        raise(
+          SafeDispatchError,
+          "`#{method_name}' could not be called on an object of type '#{receiver.class.name}'. "\
+            "Only public methods defined on classes that inherit from ViewComponent::Base "\
+            "may be called."
+        )
+      end
+    end
+
+    def self.send_safely(...)
+      instance.send_safely(...)
+    end
+
+    private
+
+    def receiver_defines_safe_method?(receiver, method_name)
+      receiver.class.ancestors.each do |ancestor|
+        if ancestor_defines_safe_method?(ancestor, method_name)
+          @cache[receiver.class] ||= Set.new
+          @cache[receiver.class] << method_name
+
+          return true
+        end
+      end
+
+      false
+    end
+
+    def ancestor_defines_safe_method?(ancestor, method_name)
+      return false unless ancestor < ViewComponent::Base
+
+      public_mtds = @cache[ancestor] ||= Set.new
+
+      if public_mtds.include?(method_name)
+        return true
+      end
+
+      if ancestor.public_method_defined?(method_name, false)
+        public_mtds << method_name
+        return true
+      end
+
+      false
+    end
+  end
+end

data/lib/live_component/serializer.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module LiveComponent
+  class Serializer
+    GLOBALID_KEY = "_lc_gid"
+    SYMBOL_KEY = "_lc_sym"
+    SYMBOL_KEYS_KEY = "_lc_symkeys"
+    SYMBOL_HASH_KEY = "_lc_symhash"
+    WITH_INDIFFERENT_ACCESS_KEY = "_lc_hwia"
+
+    RESERVED_KEYS = [
+      GLOBALID_KEY, GLOBALID_KEY.to_sym,
+      SYMBOL_KEYS_KEY, SYMBOL_KEYS_KEY.to_sym,
+      SYMBOL_HASH_KEY, SYMBOL_HASH_KEY.to_sym,
+      ObjectSerializer::OBJECT_SERIALIZER_KEY, ObjectSerializer::OBJECT_SERIALIZER_KEY.to_sym,
+      WITH_INDIFFERENT_ACCESS_KEY, WITH_INDIFFERENT_ACCESS_KEY.to_sym,
+    ].to_set
+
+    class << self
+      def make
+        new
+      end
+    end
+
+    def initialize
+      add_serializer(BigDecimal, BigDecimalSerializer)
+      add_serializer(Date, DateSerializer)
+      add_serializer(DateTime, DateTimeSerializer)
+      add_serializer(ActiveSupport::Duration, DurationSerializer)
+      add_serializer(Module, ModuleSerializer)
+      add_serializer(Range, RangeSerializer)
+      add_serializer(Time, TimeSerializer)
+      add_serializer(ActiveSupport::TimeWithZone, TimeWithZoneSerializer)
+    end
+
+    def add_serializer(klass, serializer_klass)
+      self.serializers[klass] = serializer_klass.make
+    end
+
+    def serializers
+      @serializers ||= {}
+    end
+
+    def serialize(object)
+      case object
+      when nil, true, false, Integer, Float, String
+        object
+      when Symbol
+        { SYMBOL_KEY => true, "value" => object.name }
+      when ActiveRecord::Base, RecordProxy
+        default_model_serializer.serialize(object)
+      when GlobalID::Identification
+        convert_to_global_id_hash(object)
+      when Array
+        object.map { |elem| serialize(elem) }
+      when ActiveSupport::HashWithIndifferentAccess
+        serialize_indifferent_hash(object)
+      when Hash
+        symbol_keys = object.keys
+        symbol_keys.select! { |k| k.is_a?(Symbol) }
+        symbol_keys.map!(&:name)
+        result = serialize_hash(object)
+
+        if Hash.ruby2_keywords_hash?(object)
+          result[SYMBOL_HASH_KEY] = true
+        else
+          result[SYMBOL_KEYS_KEY] = symbol_keys
+        end
+
+        result
+      else
+        if object.respond_to?(:permitted?) && object.respond_to?(:to_h)
+          serialize_indifferent_hash(object.to_h)
+        elsif serializer = serializers[object.class]
+          serializer.serialize(object)
+        else
+          raise SerializationError, "No serializer found for #{object.class}"
+        end
+      end
+    end
+
+    def deserialize(object)
+      case object
+      when nil, true, false, String, Integer, Float
+        object
+      when Array
+        object.map { |elem| deserialize(elem) }
+      when Hash
+        if object[SYMBOL_KEY]
+          object["value"].to_sym
+        elsif serialized_model?(object)
+          default_model_serializer.deserialize(object)
+        elsif serialized_global_id?(object)
+          deserialize_global_id(object)
+        elsif custom_serialized?(object)
+          serializer_name = object[ObjectSerializer::OBJECT_SERIALIZER_KEY]
+          raise SerializationError, "Serializer name is not present in the object: #{object.inspect}" unless serializer_name
+
+          serializer = lookup_serializer(serializer_name)
+          raise SerializationError, "Serializer #{serializer_name} is not known" unless serializer
+
+          serializer.deserialize(object)
+        else
+          deserialize_hash(object)
+        end
+      else
+        raise SerializationError, "Can only deserialize primitive types, got #{object.inspect}"
+      end
+    end
+
+    private
+
+    def lookup_serializer(const_str)
+      const = const_str.safe_constantize
+
+      if serializers.include?(const)
+        serializers[const]
+      end
+    end
+
+    def serialized_global_id?(hash)
+      hash.include?(GLOBALID_KEY)
+    end
+
+    def serialized_model?(hash)
+      hash.include?(ModelSerializer::MODEL_SERIALIZER_KEY)
+    end
+
+    def deserialize_global_id(hash)
+      GlobalID::Locator.locate(hash[GLOBALID_KEY])
+    end
+
+    def custom_serialized?(hash)
+      hash.include?(ObjectSerializer::OBJECT_SERIALIZER_KEY)
+    end
+
+    def serialize_hash(object)
+      object.each_with_object({}) do |(key, value), hash|
+        hash[serialize_hash_key(key)] = serialize(value)
+      end
+    end
+
+    def deserialize_hash(serialized_hash)
+      result = serialized_hash.transform_values { |v| deserialize(v) }
+
+      if result.delete(WITH_INDIFFERENT_ACCESS_KEY)
+        result = result.with_indifferent_access
+      elsif symbol_keys = result.delete(SYMBOL_KEYS_KEY)
+        result = transform_symbol_keys(result, symbol_keys)
+      elsif result.delete(SYMBOL_HASH_KEY)
+        result.symbolize_keys!
+      end
+
+      result
+    end
+
+    def serialize_hash_key(key)
+      case key
+      when RESERVED_KEYS
+        raise SerializationError.new("Can't serialize a Hash with reserved key #{key.inspect}")
+      when String
+        key
+      when Symbol
+        key.name
+      else
+        raise SerializationError.new("Only string and symbol hash keys are supported, but #{key.inspect} is a(n) #{key.class}")
+      end
+    end
+
+    def serialize_indifferent_hash(indifferent_hash)
+      result = serialize_hash(indifferent_hash)
+      result[WITH_INDIFFERENT_ACCESS_KEY] = true
+      result
+    end
+
+    def transform_symbol_keys(hash, symbol_keys)
+      # NOTE: HashWithIndifferentAccess#transform_keys always
+      # returns stringified keys with indifferent access
+      # so we call #to_h here to ensure keys are symbolized.
+      hash.to_h.transform_keys do |key|
+        if symbol_keys.include?(key)
+          key.to_sym
+        else
+          key
+        end
+      end
+    end
+
+    def convert_to_global_id_hash(object)
+      { GLOBALID_KEY => object.to_global_id.to_s }
+    rescue URI::GID::MissingModelIdError
+      raise SerializationError, "Unable to serialize #{object.class} " \
+        "without an id. (Maybe you forgot to call save?)"
+    end
+
+    def default_model_serializer
+      @default_model_serializer ||= ModelSerializer.new
+    end
+  end
+end

data/lib/live_component/state.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module LiveComponent
+  class State
+    class << self
+      def build(definition, prop_overrides = {})
+        klass = definition["ruby_class"] || definition[:ruby_class]
+        klass = LiveComponent::Utils.lookup_component_class(klass) if klass && !klass.is_a?(Class)
+        props = definition["props"] || definition[:props] || {}
+
+        props.symbolize_keys!
+        props.except!(*prop_overrides.keys)
+        props = klass.deserialize_props(props) if klass
+        props.merge!(prop_overrides)
+
+        slots = build_slots(definition["slots"] || definition[:slots] || {}) || {}
+        children = build_children(definition["children"] || definition[:children] || {}) || {}
+
+        State.new(
+          klass: klass,
+          props: props,
+          slots: slots,
+          children: children,
+          content: definition["content"] || definition[:content]
+        )
+      end
+
+      private
+
+      def build_slots(slot_map)
+        return unless slot_map
+
+        {}.tap do |results|
+          slot_map.each do |slot_name, slot_entries|
+            results[slot_name] = slot_entries.map do |slot_entry|
+              build(slot_entry)
+            end
+          end
+        end
+      end
+
+      def build_children(child_map)
+        return unless child_map
+
+        child_map.each_with_object({}) do |(child_id, child_entry), memo|
+          memo[child_id] = build(child_entry)
+        end
+      end
+    end
+
+    attr_reader :root, :klass, :props, :slots, :children
+    attr_accessor :content
+
+    alias root? root
+
+    def initialize(root: false, klass: nil, props: {}, slots: {}, children: {}, content: nil)
+      @root = root
+      @klass = klass
+      @props = props
+      @slots = slots
+      @children = children
+      @content = content
+    end
+
+    def root!
+      @root = true
+    end
+
+    def to_h
+      {
+        ruby_class: klass ? klass.name : nil,
+
+        props: klass ? klass.serialize_props(props) : LiveComponent.serializer.serialize(props),
+
+        slots: slots.each_with_object({}) do |(k, v), h|
+          h[k] = v.map(&:to_h)
+        end,
+
+        children: children.each_with_object({}) do |(k, v), h|
+          h[k] = v.to_h
+        end,
+
+        content: content,
+      }
+    end
+
+    def to_json
+      to_h.to_json
+    end
+  end
+end

data/lib/live_component/tag_builder.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module LiveComponent
+  class TagBuilder
+    def initialize(controller)
+      @controller = controller
+    end
+
+    def rerender(**kwargs, &block)
+      state = JSON.parse(@controller.params[:__lc_rerender_state])
+      id = @controller.params[:__lc_rerender_id]
+      state["props"]["__lc_attributes"] = { "data-id" => id }
+
+      component = LiveComponent::RenderComponent.new(state, [], kwargs)
+
+      # We have to render a turbo stream so Turbo doesn't append this to the <html> tag
+      @controller.turbo_stream.update(:this_id_shouldnt_exist, @controller.render(component, &block))
+    end
+  end
+end

data/lib/live_component/target.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module LiveComponent
+  class Target
+    def initialize(controller_name, target_name)
+      @controller_name = controller_name
+      @target_name = target_name
+    end
+
+    def to_attributes
+      {
+        data: {
+          "#{@controller_name}-target": @target_name
+        }
+      }
+    end
+
+    def self.attr_name
+      :targets
+    end
+
+    def attr_name
+      self.class.attr_name
+    end
+  end
+end

data/lib/live_component/time_object_serializer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module LiveComponent
+  class TimeObjectSerializer < ObjectSerializer
+    NANO_PRECISION = 9
+
+    private
+
+    def object_to_hash(time)
+      { "value" => time.iso8601(NANO_PRECISION) }
+    end
+  end
+end

data/lib/live_component/time_serializer.rb

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