live_cable 0.3.0 → 0.4.0

data/lib/live_cable/observer_tracking.rb

@@ -51,12 +51,21 @@ module LiveCable
       observers.delete(observer)
     end
 
+    # @api private
+    # @param other [ObserverTracking] starts notifying this object's observers too
+    # @return [void]
+    def share_live_cable_observers_with(other)
+      live_cable_observers.each do |variable, observers|
+        observers.each { |observer| other.add_live_cable_observer(observer, variable) }
+      end
+    end
+
     def initialize_dup(other)
       super
       @live_cable_observers = {}
     end
 
-    def initialize_clone(other)
+    def initialize_clone(other, **)
       super
       @live_cable_observers = {}
     end

data/lib/live_cable/predicate_builder.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module LiveCable
+  # Lets where(column: value) see the Array or Hash inside a reactive value
+  # instead of treating the wrapper as a single scalar.
+  module PredicateBuilder
+    def initialize(...)
+      super
+
+      register_handler(Delegator, ->(attribute, value) { build(attribute, value.__getobj__) })
+    end
+  end
+end

data/lib/live_cable/render_context.rb

@@ -30,16 +30,17 @@ module LiveCable
       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.
+    # Carried children stay out of #children, which broadcast_changeset reads as
+    # "rendered this cycle": a child there gets no render of its own that cycle.
     #
-    # @param previous_context [RenderContext]
+    # @param previous [RenderContext]
+    def inherit_skipped(previous)
+      @children_by_part.reverse_merge!(previous.children_by_part)
+    end
+
     # @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
+    def owned_children
+      children_by_part.values.flatten.uniq
     end
 
     def root?
@@ -78,9 +79,82 @@ module LiveCable
       component.live_connection
     end
 
+    # @param delegator [LiveCable::Delegator]
+    # @return [Object] the value the template sees
+    def unwrap(delegator)
+      value = delegator.__getobj__
+
+      unless tracked_values.key?(value)
+        tracked_values[value] = [delegator, []]
+        unindexed << delegator
+      end
+
+      value
+    end
+
+    # Maps a prop back to tracked values, so a child's changes still mark this
+    # component's variables, even through a collection built in the template.
+    def track(value)
+      return value unless Delegator.supported?(value)
+
+      while (delegator = unindexed.shift)
+        index_nested(delegator, delegator.__getobj__, [])
+      end
+
+      delegator, path = tracked_values[value]
+      return path.reduce(delegator) { |nested, key| nested[key] } if delegator
+
+      sources = sources_within(value)
+      return value if sources.empty?
+
+      Delegator.new(value).tap do |wrapped|
+        sources.each_key { |source| source.share_live_cable_observers_with(wrapped) }
+      end
+    end
+
     private
 
     # @return [LiveCable::RenderContext, nil]
     attr_reader :root
+
+    # @return [Hash{Object => Array(LiveCable::Delegator, Array)}] by identity
+    def tracked_values
+      @tracked_values ||= {}.compare_by_identity
+    end
+
+    # @return [Array<LiveCable::Delegator>]
+    def unindexed
+      @unindexed ||= []
+    end
+
+    def index_nested(delegator, value, path)
+      nested_entries(value).each do |key, child|
+        next if !Delegator.supported?(child) || tracked_values.key?(child)
+
+        tracked_values[child] = [delegator, path + [key]]
+        index_nested(delegator, child, path + [key])
+      end
+    end
+
+    # @return [Hash{LiveCable::Delegator => true}] by identity
+    def sources_within(value, sources = {}.compare_by_identity, seen = {}.compare_by_identity)
+      nested_entries(value).map(&:last).each do |child|
+        next if !Delegator.supported?(child) || seen.key?(child)
+
+        seen[child] = true
+        delegator, = tracked_values[child]
+        delegator ? sources[delegator] = true : sources_within(child, sources, seen)
+      end
+
+      sources
+    end
+
+    def nested_entries(value)
+      case value
+      when Hash then value.each_pair
+      when Array then value.each_with_index.map { |child, index| [index, child] }
+      else []
+      end
+    end
   end
 end

data/lib/live_cable/rendering/controller_renderer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module LiveCable
+  module Rendering
+    # Builds the controller ApplicationController.renderer renders with, from
+    # the same env, so a connection can keep one and take a view from it per
+    # render instead of paying for a controller, request and response each time.
+    class ControllerRenderer < ActionController::Renderer
+      # @param controller_class [Class]
+      # @return [ActionController::Base]
+      def self.controller_for(controller_class)
+        self.for(controller_class, nil, controller_class.renderer.defaults).build_controller
+      end
+
+      def build_controller
+        request = ActionDispatch::Request.new(env_for_request)
+        request.routes = controller._routes
+
+        controller.new.tap do |instance|
+          instance.set_request!(request)
+          instance.set_response!(controller.make_response!(request))
+        end
+      end
+    end
+  end
+end

data/lib/live_cable/rendering/dependency_visitor.rb

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
 
+require 'prism'
+
 module LiveCable
   module Rendering
     class DependencyVisitor < Prism::Visitor
+      # @return [Array<Symbol>]
+      attr_reader :variable_calls
+
       # @return [Array<Symbol>]
       attr_reader :local_reads
 
@@ -14,32 +19,40 @@ module LiveCable
 
       def initialize
         super
+        @variable_calls = []
         @local_reads = []
         @local_writes = []
         @component_method_calls = Set.new
+        @scope_depth = 0
       end
 
-      # Track all local variable reads
+      def visit_block_node(node) = nested_scope { super }
+
+      def visit_lambda_node(node) = nested_scope { super }
+
+      # Prism never resolves a name past a def, so nothing inside one counts as top level
+      def visit_def_node(node) = nested_scope { super }
+
+      # Track reads of top-level locals
       # @param node [Prism::LocalVariableReadNode]
       # @return [void]
       def visit_local_variable_read_node(node)
-        @local_reads |= [node.name]
+        @local_reads |= [node.name] if top_level?(node)
         super
       end
 
-      # Track variable method calls (e.g., `foo` without parens)
-      # Also track component.method_name calls
+      # Track argument-less receiverless calls (e.g., `foo`, `foo()` or the value
+      # of a `foo:` hash shorthand) and calls on component or self (e.g.,
+      # `component.foo`), which read the component too
       # @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
+        if node.variable_call? || bare_call?(node) || explicit_component_receiver?(node.receiver)
+          @variable_calls |= [node.name]
         end
 
+        @component_method_calls << node.name if component_receiver?(node.receiver)
+
         super
       end
 
@@ -47,7 +60,15 @@ module LiveCable
       # @param node [Prism::LocalVariableWriteNode]
       # @return [void]
       def visit_local_variable_write_node(node)
-        @local_writes |= [node.name]
+        @local_writes |= [node.name] if top_level?(node)
+        super
+      end
+
+      # Track multiple assignment, rescue and pattern targets
+      # @param node [Prism::LocalVariableTargetNode]
+      # @return [void]
+      def visit_local_variable_target_node(node)
+        @local_writes |= [node.name] if top_level?(node)
         super
       end
 
@@ -55,8 +76,7 @@ module LiveCable
       # @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
+        read_and_write(node)
         super
       end
 
@@ -64,8 +84,7 @@ module LiveCable
       # @param node [Prism::LocalVariableAndWriteNode]
       # @return [void]
       def visit_local_variable_and_write_node(node)
-        @local_writes |= [node.name]
-        @local_reads |= [node.name]
+        read_and_write(node)
         super
       end
 
@@ -73,24 +92,49 @@ module LiveCable
       # @param node [Prism::LocalVariableOrWriteNode]
       # @return [void]
       def visit_local_variable_or_write_node(node)
-        @local_writes |= [node.name]
-        @local_reads |= [node.name]
+        read_and_write(node)
         super
       end
 
       private
 
-      # Check if receiver is a reference to 'component'
+      def nested_scope
+        @scope_depth += 1
+        yield
+      ensure
+        @scope_depth -= 1
+      end
+
+      # Prism's depth is how many scopes up it found the local
+      def top_level?(node)
+        node.depth == @scope_depth
+      end
+
+      def read_and_write(node)
+        return unless top_level?(node)
+
+        @local_reads |= [node.name]
+        @local_writes |= [node.name]
+      end
+
+      # @param node [Prism::CallNode]
+      # @return [Boolean]
+      def bare_call?(node)
+        node.receiver.nil? && node.arguments.nil? && node.block.nil?
+      end
+
       # @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
+        receiver.nil? || explicit_component_receiver?(receiver)
+      end
 
-        # If there is a receiver, it must be a component method call or local variable read
+      # Part code runs on the renderer, which hands unknown names to the component,
+      # so `self.foo` reads the component just as `component.foo` does
+      # @param receiver [Prism::Node, nil]
+      # @return [Boolean]
+      def explicit_component_receiver?(receiver)
+        return true if receiver.is_a?(Prism::SelfNode)
         return false unless receiver.try(:name) == :component
 
         receiver.is_a?(Prism::CallNode) || receiver.is_a?(Prism::LocalVariableReadNode)

data/lib/live_cable/rendering/handler.rb

@@ -7,7 +7,7 @@ module LiveCable
         parse_result = ::Herb.parse(source, track_whitespace: true)
         ast = parse_result.value
 
-        engine = Renderer.new
+        engine = Renderer.new(template.short_identifier)
         compiler = Compiler.new(engine)
         ast.accept(compiler)
 

data/lib/live_cable/rendering/method_analyzer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'prism'
+
 module LiveCable
   module Rendering
     # Analyzes component methods to track their dependencies on reactive variables
@@ -19,11 +21,15 @@ module LiveCable
       def analyze_all_methods
         return dependencies if analyzed
 
-        # Get the source file for this component
-        source_location = Object.const_source_location(component_class.name)
+        # Classes built with Class.new have no source file to analyze; see analyzable?
+        class_name = component_class.name
+        file_path = class_name && Object.const_source_location(class_name)&.first
 
-        file_path = source_location[0]
-        return {} unless File.exist?(file_path)
+        unless file_path && File.exist?(file_path)
+          @analyzed = true
+          @analyzable = false
+          return dependencies
+        end
 
         # Parse the entire file once
         source_code = File.read(file_path)
@@ -35,9 +41,17 @@ module LiveCable
 
         @dependencies = collector.dependencies
         @analyzed = true
+        @analyzable = true
         dependencies
       end
 
+      # @return [Boolean] false when the class has no source file, so method
+      #   dependencies are unknown and callers must assume any change matters
+      def analyzable?
+        analyze_all_methods unless analyzed
+        @analyzable
+      end
+
       # Get dependencies for a specific method (analyzes all if not done yet)
       # @param method_name [Symbol] The method name
       # @return [Hash, nil] { methods: Set, reactive_vars: Set }

data/lib/live_cable/rendering/method_collector.rb

@@ -15,7 +15,7 @@ module LiveCable
 
         @component_class = component_class
         @dependencies = {}
-        @reactive_vars = component_class.all_reactive_variables
+        @reactive_vars = component_class.all_reactive_variables | component_class.shared_variables
       end
 
       # Visit each method definition
@@ -24,6 +24,8 @@ module LiveCable
       def visit_def_node(node)
         method_name = node.name
 
+        return if node.receiver
+
         # Skip private/internal methods
         return super if %i[render render_in].include?(method_name)
 
@@ -31,14 +33,20 @@ module LiveCable
         visitor = MethodDependencyVisitor.new(component_class, reactive_vars)
         visitor.visit(node)
 
-        @dependencies[method_name] = {
-          methods: visitor.method_calls,
-          reactive_vars: visitor.reactive_var_reads,
-        }
+        # Nested and sibling classes in the same file share this table, so a
+        # clashing name may only add dependencies, never replace them.
+        entry = @dependencies[method_name] ||= { methods: Set.new, reactive_vars: Set.new }
+        entry[:methods].merge(visitor.method_calls)
+        entry[:reactive_vars].merge(visitor.reactive_var_reads)
 
         super
       end
 
+      # Methods in `class << self` are never instance methods a template calls
+      # @param node [Prism::SingletonClassNode]
+      # @return [void]
+      def visit_singleton_class_node(node); end
+
       private
 
       # @return [Class]

data/lib/live_cable/rendering/partial.rb

@@ -5,9 +5,10 @@ require_relative 'partial_renderer'
 module LiveCable
   module Rendering
     class Partial
-      def initialize(parts, metadata)
+      def initialize(parts, metadata, identifier)
         @parts = parts
         @metadata = metadata
+        @identifier = identifier
         @renderer_class = build_renderer_class
       end
 
@@ -16,6 +17,14 @@ module LiveCable
         renderer_class.new(component, parts, view_context)
       end
 
+      # ActionView calls this when a template is rendered as a partial or a plain
+      # template; only Component#render_in can render a Partial.
+      def to_s
+        raise LiveCable::Error,
+          "#{identifier} is a component template and can only be rendered by its component. " \
+          'Render the component with live(...) or render(component), or make the partial a .html.erb template.'
+      end
+
       private
 
       # @return [Array]
@@ -24,6 +33,9 @@ module LiveCable
       # @return [Array]
       attr_reader :metadata
 
+      # @return [String]
+      attr_reader :identifier
+
       # @return [Class<PartialRenderer>]
       attr_reader :renderer_class
 

data/lib/live_cable/rendering/partial_renderer.rb

@@ -11,6 +11,7 @@ module LiveCable
         @component = component
         @parts = parts
         @view_context = view_context
+        bind_shadowed_names
       end
 
       def render_changes(changes = :all)
@@ -25,15 +26,19 @@ module LiveCable
         @method_deps_cache = {}  # Cache method dependency expansion for this render cycle
         parts.each_with_index.with_object([]) do |item, acc|
           part, index = item
-          result = view_context.render_part(index) { send("render_part_#{index}", changes) }
+          result = view_context.render_part(index) { __send__("render_part_#{index}", changes) }
           acc << result unless part[0] == :code
         end
       end
 
       # Pass through renders to the view context, otherwise method_missing will pass
       # to the component instead since it also has a render method
-      def render(*)
-        view_context.render(*)
+      def render(*, &block)
+        return view_context.render(*) unless block
+
+        view_context.render(*) do |*args|
+          with_view_buffer { block.call(*args) }
+        end
       end
 
       def mark_locals_dirty(locals)
@@ -80,6 +85,8 @@ module LiveCable
         # Always render on template switch (all dynamic parts must render)
         return false if changes == :dynamic
 
+        return false if component_method_calls.any? && !component.class.method_dependencies_analyzer.analyzable?
+
         # Expand component.method_name calls to their transitive dependencies
         expanded_deps = expand_component_method_dependencies(component_method_calls)
         all_component_deps = component_dependencies | expanded_deps
@@ -94,17 +101,18 @@ module LiveCable
         true
       end
 
-      def method_missing(method, ...)
-        if locals.key?(method)
+      def method_missing(method, *args, **kwargs, &block)
+        # A local is only ever a bare name; with arguments it's a method call, as in plain ERB
+        if locals.key?(method) && args.empty? && kwargs.empty? && block.nil?
           return locals[method]
         end
 
         if component.respond_to?(method)
-          return component.public_send(method, ...)
+          return view_context.live_cable_unwrap(component.public_send(method, *args, **kwargs, &block))
         end
 
         if view_context.respond_to?(method)
-          return view_context.public_send(method, ...)
+          return forwarding_to_view_buffer { view_context.public_send(method, *args, **kwargs, &block) }
         end
 
         super
@@ -137,9 +145,53 @@ module LiveCable
         view_context.with_output_buffer(@output_buffer, &).to_s
       end
 
+      # Template blocks write to this renderer's @output_buffer, but a partial
+      # yields them while its own buffer is the one capturing.
+      def with_view_buffer
+        buffer = @output_buffer
+        @output_buffer = view_context.output_buffer
+        yield
+      ensure
+        @output_buffer = buffer
+      end
+
+      def forwarding_to_view_buffer
+        buffer = @output_buffer
+        @output_buffer = ViewBuffer.new(view_context)
+        yield
+      ensure
+        @output_buffer = buffer
+      end
+
       def store_local(name, value)
         locals[name] = value
       end
+
+      # Kernel and Object names never reach method_missing. Bind the ones the component
+      # or view context define themselves; a wrapper falling back to Kernel breaks lambda.
+      def bind_shadowed_names
+        names = self.class.metadata.compact.flat_map { |part| part[:component_method_calls] || [] }.uniq
+        names = names.select { |name| Object.method_defined?(name) || Object.private_method_defined?(name) }
+
+        # The renderer's respond_to? already checks locals, the component and the view context.
+        (names - [:respond_to?]).each do |name|
+          target = [component, view_context].find do |object|
+            if Object.private_method_defined?(name)
+              object.respond_to?(name)
+            else
+              object.class.public_method_defined?(name) &&
+                object.class.instance_method(name).owner != Object.instance_method(name).owner
+            end
+          end
+          next unless target
+
+          define_singleton_method(name) do |*args, **kwargs, &block|
+            next target.public_send(name, *args, **kwargs, &block) if target.equal?(component)
+
+            forwarding_to_view_buffer { target.public_send(name, *args, **kwargs, &block) }
+          end
+        end
+      end
     end
   end
 end

data/lib/live_cable/rendering/render_result.rb

@@ -26,6 +26,11 @@ module LiveCable
         parts.compact.empty?
       end
 
+      # Nothing re-rendered here or in any child
+      def blank?
+        empty? && child_results.values.all?(&:blank?)
+      end
+
       def as_json
         {
           h: template_hash,

data/lib/live_cable/rendering/renderer.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
+require 'prism'
+
 module LiveCable
   module Rendering
     class Renderer < ::Herb::Engine
       # rubocop:disable Lint/MissingSuper
-      def initialize
+      def initialize(identifier = nil)
+        @identifier = identifier
         @newline_pending = 0
         @parts = []
         @src = +''
@@ -20,11 +23,14 @@ module LiveCable
 
       def src
         metadata = build_metadata
-        "::LiveCable::Rendering::Partial.new(#{parts.inspect}, #{metadata.inspect})"
+        "::LiveCable::Rendering::Partial.new(#{parts.inspect}, #{metadata.inspect}, #{identifier.inspect})"
       end
 
       private
 
+      # @return [String, nil]
+      attr_reader :identifier
+
       # @return [Integer]
       attr_reader :newline_pending
 
@@ -43,22 +49,20 @@ module LiveCable
         parts.map do |type, code|
           next nil if type == :static || code.nil? || code.empty?
 
-          parsed = Prism.parse(code).value
-          locals_defined_here = parsed.locals || []
-          local_check_code = +''
-
-          locals_defined_here.each do |local|
-            local_check_code << "store_local(:#{local}, #{local}) if defined?(#{local})\n"
-          end
+          # Earlier parts' locals are in scope, as they would be in one ERB method body
+          parsed = Prism.parse(code, scopes: [accumulated_locals]).value
 
           visitor = DependencyVisitor.new
           visitor.visit(parsed)
 
-          # Component/method dependencies: reads that aren't locals from previous parts
-          component_dependencies = visitor.local_reads - accumulated_locals
+          local_check_code = +''
+
+          visitor.local_writes.each do |local|
+            local_check_code << "store_local(:#{local}, #{local}) if defined?(#{local})\n"
+          end
 
-          # Local dependencies: reads that ARE from previous parts
-          local_dependencies = visitor.local_reads & accumulated_locals
+          # A write that doesn't run, such as one in a false `if`, keeps the earlier value
+          local_dependencies = (visitor.local_reads | visitor.local_writes) & accumulated_locals
 
           # Track component.method_name calls separately for runtime expansion
           component_method_calls = visitor.component_method_calls.to_a
@@ -69,7 +73,7 @@ module LiveCable
           {
             type:,
             code:,
-            component_dependencies: component_dependencies - [:component],
+            component_dependencies: visitor.variable_calls - [:component],
             component_method_calls:,
             local_dependencies:,
             defines_locals: visitor.local_writes,