live_cable 0.0.1 → 0.1.2

data/lib/live_cable/connection.rb

@@ -2,135 +2,29 @@
 
 module LiveCable
   class Connection
-    attr_reader :session_id
+    include ComponentManagement
+    include ChannelManagement
+    include StateManagement
+    include Messaging
+    include Broadcasting
+    include ErrorHandling
 
     SHARED_CONTAINER = '_shared'
 
     def initialize(request)
       @request = request
       @session_id = SecureRandom.uuid
-      @containers = {} # @todo Use Hash.new with a proc to make a container / hash
+      @containers = Hash.new { |hash, key| hash[key] = Container.new }
       @components = {}
       @channels = {}
     end
 
-    def get_component(id)
-      components[id]
-    end
-
-    def add_component(component)
-      component.live_connection = self
-      components[component.live_id] = component
-    end
-
-    def remove_component(component)
-      components.delete(component.live_id)
-      containers.delete(component.live_id)
-    end
-
-    def set_channel(component, channel)
-      @channels[component] = channel
-    end
-
-    def get_channel(component)
-      @channels[component]
-    end
-
-    def remove_channel(component)
-      @channels.delete(component)
-    end
-
-    def get(container_name, component, variable, initial_value)
-      containers[container_name] ||= Container.new
-      containers[container_name][variable] ||= process_initial_value(component, variable, initial_value)
-    end
-
-    def set(container_name, variable, value)
-      dirty(container_name, variable)
-
-      containers[container_name] ||= Container.new
-      containers[container_name][variable] = value
-    end
-
-    def receive(component, data)
-      check_csrf_token(data)
-      reset_changeset
-
-      return unless data['messages'].present?
-
-      data['messages'].each do |message|
-        action(component, message)
-      end
-
-      broadcast_changeset
-    end
-
-    def action(component, data)
-      params = parse_params(data)
-
-      if data['_action']
-        action = data['_action']&.to_sym
-
-        if action == :_reactive
-          return reactive(component, data)
-        end
-
-        unless component.class.allowed_actions.include?(action)
-          raise LiveCable::Error, "Unauthorized action: #{action}"
-        end
-
-        method = component.method(action)
-
-        if method.arity.positive?
-          method.call(params)
-        else
-          method.call
-        end
-      end
-    rescue StandardError => e
-      handle_error(component, e)
-    end
-
-    def reactive(component, data)
-      unless component.all_reactive_variables.include?(data['name'].to_sym)
-        raise Error, "Invalid reactive variable: #{data['name']}"
-      end
-
-      component.public_send("#{data['name']}=", data['value'])
-    rescue StandardError => e
-      handle_error(component, e)
-    end
-
-    def channel_name
-      "live_#{session_id}"
-    end
-
-    def dirty(container_name, *variables)
-      containers[container_name] ||= Container.new
-      containers[container_name].mark_dirty(*variables)
-    end
-
-    def broadcast_changeset
-      # Use a copy of the components since new ones can get added while rendering
-      # and causes an issue here.
-      components.values.dup.each do |component|
-        container = containers[component.live_id]
-        if container&.changed?
-          component.render_broadcast
-
-          next
-        end
-
-        shared_changeset = containers[SHARED_CONTAINER]&.changeset || []
-
-        if (component.shared_reactive_variables || []).intersect?(shared_changeset)
-          component.render_broadcast
-        end
-      end
-    end
-
     private
 
+    # @return [String]
+    attr_reader :session_id
+
+    # @return [ActionDispatch::Request]
     attr_reader :request
 
     # @return [Hash<String, Container>]
@@ -138,68 +32,5 @@ module LiveCable
 
     # @return [Hash<String, Component>]
     attr_reader :components
-
-    def check_csrf_token(data)
-      session = request.session
-      return unless session[:_csrf_token]
-
-      token = data['_csrf_token']
-      unless csrf_checker.valid?(session, token)
-        raise LiveCable::Error, 'Invalid CSRF token'
-      end
-    end
-
-    def csrf_checker
-      @csrf_checker ||= LiveCable::CsrfChecker.new(request)
-    end
-
-    def process_initial_value(component, variable, initial_value)
-      case initial_value
-      when nil
-        nil
-      when Proc
-        args = []
-        args << component if initial_value.arity.positive?
-
-        initial_value.call(*args)
-      else
-        raise Error, "Initial value for \":#{variable}\" must be a proc or nil"
-      end
-    rescue StandardError => e
-      handle_error(component, e)
-    end
-
-    def parse_params(data)
-      params = data['params'] || ''
-
-      ActionController::Parameters.new(
-        ActionDispatch::ParamBuilder.from_pairs(
-          ActionDispatch::QueryParser.each_pair(params)
-        )
-      )
-    end
-
-    def reset_changeset
-      containers.each_value(&:reset_changeset)
-    end
-
-    def handle_error(component, error)
-      html = <<~HTML
-        <details>
-          <summary style="color: #f00; cursor: pointer">
-            <strong>#{component.class.name}</strong> - #{error.class.name}: #{error.message}
-          </summary>
-          <small>
-            <ol>
-              #{error.backtrace&.map { "<li>#{it}</li>" }&.join("\n")}
-            </ol>
-          </small>
-        </details>
-      HTML
-
-      component.broadcast(_refresh: html)
-    ensure
-      raise(error)
-    end
   end
 end

data/lib/live_cable/container.rb

@@ -45,6 +45,9 @@ module LiveCable
     #   container[:tags] = ['ruby']              # Array - wrapped in Delegator
     #   container[:user] = User.new              # ActiveRecord - wrapped in Delegator
     def []=(key, value)
+      # Remove observer from the old value so it stops notifying this container
+      self[key].try(:remove_live_cable_observer, observer, key)
+
       # ActiveRecord models get observers attached directly
       if value.class < ModelObserver
         value.add_live_cable_observer(observer, key)
@@ -99,5 +102,27 @@ module LiveCable
     def observer
       @observer ||= Observer.new(self)
     end
+
+    # Clean up all observer references to prevent memory leaks.
+    # This breaks the reference chain between delegators, observers, and the container.
+    #
+    # Should be called when the component is destroyed.
+    #
+    # @return [void]
+    def cleanup
+      # Remove this container's observer from all delegated values
+      # Note: We only remove this specific observer, not all observers,
+      # because the same object might be shared across multiple containers
+      each do |variable, value|
+        if value.respond_to?(:remove_live_cable_observer)
+          value.remove_live_cable_observer(observer, variable)
+        end
+      end
+
+      # Clear the container's data
+      clear
+      @changeset&.clear
+      @observer = nil
+    end
   end
 end

data/lib/live_cable/delegation/array.rb

@@ -15,6 +15,7 @@ module LiveCable
         drop
         drop_while
         filter
+        find
         find_all
         first
         flatten

data/lib/live_cable/delegator.rb

@@ -4,13 +4,6 @@ module LiveCable
   # Delegation modules for different data types.
   # Each module defines which methods should trigger change notifications.
   module Delegation
-    extend ActiveSupport::Autoload
-
-    autoload :Array
-    autoload :Hash
-    autoload :Methods
-    autoload :Model
-
     # Maps Ruby classes to their delegation modules.
     # When a value of one of these types is stored in a container,
     # it will be wrapped in a Delegator and extended with the appropriate module.

data/lib/live_cable/engine.rb

@@ -4,16 +4,28 @@ module LiveCable
   class Engine < ::Rails::Engine
     config.before_configuration do |app|
       # Setup autoloader to use Live namespace for components
-      Rails.autoloaders.main.push_dir(app.root.join('app/live'), namespace: Live)
+      live_component_dir = app.root.join('app/live')
 
-      # Add LiveCable to importmap
-      app.config.importmap.paths << root.join('config/importmap.rb')
+      if live_component_dir.directory?
+        Rails.autoloaders.main.push_dir(live_component_dir, namespace: Live)
+      else
+        warn("[LiveCable Warning] #{live_component_dir} does not exist for components.")
+      end
+
+      # Add LiveCable to importmap (skip when using jsbundling/npm)
+      if app.config.respond_to?(:importmap)
+        app.config.importmap.paths << root.join('config/importmap.rb')
+      end
     end
 
     initializer 'live_cable.assets_precompile' do |app|
       app.config.assets.precompile << %w[live_cable/**/*.js]
     end
 
+    initializer 'live_cable.renderer' do |_app|
+      ActionView::Template.register_template_handler(:'live.erb', Rendering::Handler)
+    end
+
     initializer 'live_cable.active_record' do
       ActiveSupport.on_load :active_record do
         include ModelObserver

data/lib/live_cable/observer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'weakref'
+
 module LiveCable
   # Observer pattern implementation for tracking changes to reactive variables.
   #
@@ -21,7 +23,7 @@ module LiveCable
   class Observer
     # @param container [LiveCable::Container] The container to notify of changes
     def initialize(container)
-      @container = container
+      @container = WeakRef.new(container)
     end
 
     # Notify the container that a variable has changed.
@@ -34,6 +36,8 @@ module LiveCable
     #   observer.notify(:tags)  # Component will re-render because :tags changed
     def notify(variable)
       container.mark_dirty(variable)
+    rescue WeakRef::RefError
+      # Container was already GC'd — nothing to do
     end
 
     private

data/lib/live_cable/observer_tracking.rb

@@ -41,6 +41,26 @@ module LiveCable
       end
     end
 
+    # Remove an observer from tracking changes to a specific variable.
+    #
+    # @param observer [LiveCable::Observer] The observer to remove
+    # @param variable [Symbol] The reactive variable name
+    # @return [void]
+    def remove_live_cable_observer(observer, variable)
+      observers = live_cable_observers_for(variable)
+      observers.delete(observer)
+    end
+
+    def initialize_dup(other)
+      super
+      @live_cable_observers = {}
+    end
+
+    def initialize_clone(other)
+      super
+      @live_cable_observers = {}
+    end
+
     private
 
     # Get the hash of all observers, keyed by variable name.

data/lib/live_cable/render_context.rb

@@ -2,28 +2,75 @@
 
 module LiveCable
   class RenderContext
-    def initialize(component)
+    def initialize(component, root: nil)
       @component = component
       @children = []
+      @root = root
+      @render_results = {}
+      @children_by_part = {}
+      @current_part = nil
     end
 
     # @return [Array<LiveCable::Component>]
     attr_reader :children
 
-    def reset
-      self.children = []
+    # @return [LiveCable::Component]
+    attr_reader :component
+
+    # @return [Hash<String, RenderResult>]
+    attr_reader :render_results
+
+    # @return [Hash<Integer, Array<LiveCable::Component>>]
+    attr_reader :children_by_part
+
+    def render_part(index)
+      @current_part = index
+      result = yield
+      @children_by_part[index] ||= [] unless result.nil?
+      result
+    end
+
+    # Returns children from the previous context that came from parts which were
+    # skipped (not rendered) in this render cycle. These children should not be
+    # destroyed — their part simply didn't re-evaluate.
+    #
+    # @param previous_context [RenderContext]
+    # @return [Array<LiveCable::Component>]
+    def preserved_children_from(previous_context)
+      previous_context.children_by_part.each_with_object([]) do |(part, part_children), preserved|
+        preserved.concat(part_children) unless @children_by_part.key?(part)
+      end
+    end
+
+    def root?
+      root.nil?
+    end
+
+    def clear
+      @children = nil
+      @component = nil
+    end
+
+    # @param result [RenderResult]
+    def <<(result)
+      if root?
+        render_results[result.live_id] = result
+      else
+        root << result
+      end
     end
 
     def add_component(child)
-      return unless component.live_connection
+      return unless live_connection
 
-      component.live_connection.add_component(child)
+      live_connection.add_component(child)
       children << child
+      (@children_by_part[@current_part] ||= []) << child
     end
 
     # @return [LiveCable::Component, nil]
     def get_component(live_id)
-      component.live_connection&.get_component(live_id)
+      live_connection&.get_component(live_id)
     end
 
     # @return [LiveCable::Connection]
@@ -33,7 +80,7 @@ module LiveCable
 
     private
 
-    # @return [LiveCable::Component]
-    attr_reader :component
+    # @return [LiveCable::RenderContext, nil]
+    attr_reader :root
   end
 end

data/lib/live_cable/rendering/compiler.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module LiveCable
+  module Rendering
+    class Compiler < ::Herb::Engine::Compiler
+      def visit_erb_control_node(node)
+        @tokens << [:block_start]
+        super
+        @tokens << [:block_end]
+      end
+
+      def visit_erb_block_node(node)
+        @tokens << [:block_start]
+        super
+        @tokens << [:block_end]
+      end
+
+      def generate_output
+        tokens = optimize_tokens(@tokens)
+
+        tokens.map do |type, value, context|
+          if type == :block
+            value.map { |token| generate_for_token(*token) }
+          else
+            generate_for_token(type, value, context)
+          end
+
+          @engine.send(:finish_method, type)
+        end
+      end
+
+      def generate_for_token(type, value, context)
+        case type
+        when :text
+          @engine.send(:add_text, value)
+        when :code
+          @engine.send(:add_code, value)
+        when :expr
+          indicator = @escape ? '==' : '='
+          @engine.send(:add_expression, indicator, value)
+        when :expr_escaped
+          indicator = @escape ? '=' : '=='
+          @engine.send(:add_expression, indicator, value)
+        when :expr_block
+          indicator = @escape ? '==' : '='
+          @engine.send(:add_expression_block, indicator, value)
+        when :expr_block_escaped
+          indicator = @escape ? '=' : '=='
+          @engine.send(:add_expression_block, indicator, value)
+        end
+      end
+
+      def optimize_tokens(unoptimized_tokens)
+        tokens = super
+        optimized_tokens = []
+        block_count = 0
+        current_block = []
+
+        tokens.each do |token|
+          if token[0] == :block_start
+            block_count += 1
+          elsif token[0] == :block_end
+            block_count -= 1
+
+            if block_count.zero?
+              optimized_tokens << [:block, current_block]
+              current_block = []
+            end
+          elsif block_count.zero?
+            optimized_tokens << token
+          else
+            current_block << token
+          end
+        end
+
+        optimized_tokens
+      end
+    end
+  end
+end

data/lib/live_cable/rendering/dependency_visitor.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module LiveCable
+  module Rendering
+    class DependencyVisitor < Prism::Visitor
+      # @return [Array<Symbol>]
+      attr_reader :local_reads
+
+      # @return [Array<Symbol>]
+      attr_reader :local_writes
+
+      # @return [Set<Symbol>]
+      attr_reader :component_method_calls
+
+      def initialize
+        super
+        @local_reads = []
+        @local_writes = []
+        @component_method_calls = Set.new
+      end
+
+      # Track all local variable reads
+      # @param node [Prism::LocalVariableReadNode]
+      # @return [void]
+      def visit_local_variable_read_node(node)
+        @local_reads |= [node.name]
+        super
+      end
+
+      # Track variable method calls (e.g., `foo` without parens)
+      # Also track component.method_name calls
+      # @param node [Prism::CallNode]
+      # @return [void]
+      def visit_call_node(node)
+        # Track variable calls (implicit self)
+        @local_reads |= [node.name] if node.variable_call?
+
+        # Track component.method_name calls
+        if component_receiver?(node.receiver)
+          @component_method_calls << node.name
+        end
+
+        super
+      end
+
+      # Track local variable writes
+      # @param node [Prism::LocalVariableWriteNode]
+      # @return [void]
+      def visit_local_variable_write_node(node)
+        @local_writes |= [node.name]
+        super
+      end
+
+      # Track local variable operator writes (+=, ||=, etc)
+      # @param node [Prism::LocalVariableOperatorWriteNode]
+      # @return [void]
+      def visit_local_variable_operator_write_node(node)
+        @local_writes |= [node.name]
+        @local_reads |= [node.name] # Reads before writing
+        super
+      end
+
+      # Track local variable and writes (&&=)
+      # @param node [Prism::LocalVariableAndWriteNode]
+      # @return [void]
+      def visit_local_variable_and_write_node(node)
+        @local_writes |= [node.name]
+        @local_reads |= [node.name]
+        super
+      end
+
+      # Track local variable or writes (||=)
+      # @param node [Prism::LocalVariableOrWriteNode]
+      # @return [void]
+      def visit_local_variable_or_write_node(node)
+        @local_writes |= [node.name]
+        @local_reads |= [node.name]
+        super
+      end
+
+      private
+
+      # Check if receiver is a reference to 'component'
+      # @param receiver [Prism::Node, nil]
+      # @return [Boolean]
+      def component_receiver?(receiver)
+        # No receiver, calling something lke live_id or any component method
+        return true if receiver.nil?
+
+        # Ignore these because they're not component methods, just output methods
+        return false if receiver.try(:name) == :@output_buffer
+
+        # If there is a receiver, it must be a component method call or local variable read
+        return false unless receiver.try(:name) == :component
+
+        receiver.is_a?(Prism::CallNode) || receiver.is_a?(Prism::LocalVariableReadNode)
+      end
+    end
+  end
+end

data/lib/live_cable/rendering/handler.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module LiveCable
+  module Rendering
+    class Handler < ActionView::Template::Handlers::ERB
+      def call(template, source)
+        parse_result = ::Herb.parse(source, track_whitespace: true)
+        ast = parse_result.value
+
+        engine = Renderer.new
+        compiler = Compiler.new(engine)
+        ast.accept(compiler)
+
+        compiler.generate_output
+        engine.src
+      end
+    end
+  end
+end