antlers 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ce3c9ccc84415933ff474d8187c420e28618fa7c15c56bffe0060e2364750d2
-  data.tar.gz: cc69421e1365a4c3f38975aadd7eee7390797ba48c2aff399ad425f2bb05160e
+  metadata.gz: f686ef1d7e193fd0f89d1193b2eaca591adeb32b4d3ab4921b8f720b344b4d1c
+  data.tar.gz: 39c5d31434df9e67ad4ba47e8f3e3af3598baa61a5c4faffee4645361f3a2d44
 SHA512:
-  metadata.gz: da91462599377c23cc6cfc92fe4fa74e917a216a6378f1ef353ac3fcd6c53a947644dfc9cb3c2bb3937adaf33c5644d28a1f9698ea570c31de36479a8964301e
-  data.tar.gz: 6c46c7a4aa39005d09ba125a7b2f4a1129383ade80691fffbe0757c3a19683144ecbbe12392ab22814b5894c83a3d489701ccdaa1da116e927881816e2cc4ad9
+  metadata.gz: f4b39cece90d9435ef99132ea4c0fa1e013876343c50266502e2e4a53dfc7116d8a371f2d6ff69a791e01a622ad85ef3c15ecf62e69541630ddbafc51f8a59f7
+  data.tar.gz: 8afff52daeebd8f5546d64b0db202e2b75f452cece2d3395873ddf6fac8b1855ba032b433ff876344538dd9a068bb6aed6ce425eb13a43ae2f7e30fdbdef4104

data/lib/antlers/keywords.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Antlers
+  # Gives a method only the keywords it takes like initialize(limit:) and render(event:, slot:).
+  # LowNode uses the Method Factory pattern but the *instance* methods behave as the actualy method definitions.
+  module Keywords
+    module_function
+
+    # The keywords the method declares, or all of them when it takes **.
+    def accepted(method, keywords)
+      parameters = method.parameters
+      return keywords if parameters.any? { |type, _| type == :keyrest }
+
+      keywords.slice(*declared(parameters))
+    end
+
+    # Whether the method takes the keyword, by name or with **.
+    def takes?(method, name)
+      parameters = method.parameters
+      parameters.any? { |type, _| type == :keyrest } || declared(parameters).include?(name)
+    end
+
+    def declared(parameters)
+      parameters.filter_map { |type, name| name if %i[key keyreq].include?(type) }
+    end
+  end
+end

data/lib/antlers/lexer.rb

@@ -64,8 +64,9 @@ module Antlers
       raise LexerError, "Unrecognised syntax: '#{segment}'"
     end
 
+    # Keywords are whole words, so a name like "Plain::Card" isn't split on the "in:" in it.
     def parse_antlers_segment(segment:)
-      name_and_props, *keywords = segment.split(/(#{Regexp.union(@keywords)})/)
+      name_and_props, *keywords = segment.split(/(?<!\S)(#{Regexp.union(@keywords)})(?!\S)/)
       name, *props = name_and_props.split(' ')
       [name, props, parse_keywords(keywords:)]
     end

data/lib/antlers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Antlers
-  VERSION = '1.2.0'
+  VERSION = '1.2.1'
 end

data/lib/antlers.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'antlers/elements'
+require_relative 'antlers/keywords'
 require_relative 'antlers/lexer'
 require_relative 'antlers/parser'
 
@@ -17,4 +18,10 @@ module Antlers
   def render(ast:, current_binding:, parent_binding: nil, slot_node: nil, metadata: {})
     ast.render(current_binding:, parent_binding:, slot_node:, metadata:)
   end
+
+  # Call once an app has loaded, to find prop nodes built before their class loaded.
+  # Returns the prop nodes whose class is still undefined, which look up their class when first rendered.
+  def resolve_nodes
+    PropNode.resolve
+  end
 end

data/lib/interfaces/antler_node.rb

@@ -21,9 +21,7 @@ module Antlers
 
     # Support sending an event to render_template hook when lowevent available. See lownode as an example implementation.
     def possible_render_event(props:)
-      Low::Events::RenderEvent.new(action: :render, props:) if defined?(LowEvent)
-
-      nil
+      Low::Events::RenderEvent.new(action: :render, props:) if defined?(Low::Events::RenderEvent)
     end
 
     class << self

data/lib/modules/namespace.rb

@@ -8,12 +8,13 @@ module Antlers
       class_from_namespace(namespace:, name:)
     end
 
+    # Nil when the class isn't defined in the namespace or any of its parents.
     def class_from_namespace(namespace:, name:)
-      namespace_with_name = [namespace, name].join('::')
+      namespace_with_name = [*namespace, name].join('::')
       return Object.const_get(namespace_with_name) if Object.const_defined?(namespace_with_name)
+      return nil if namespace.empty?
 
-      namespace.pop
-      class_from_namespace(namespace:, name:)
+      class_from_namespace(namespace: namespace[0...-1], name:)
     end
   end
 end

data/lib/modules/props.rb

@@ -22,7 +22,7 @@ module Antlers
       evaluated_props = {}
 
       props.each do |name, value|
-        evaluated_props[name] = evaluate(value:, current_binding:)
+        evaluated_props[name] = evaluate(value:, current_binding:, escape: false)
       end
 
       evaluated_props

data/lib/modules/variables.rb

@@ -9,9 +9,10 @@ module Antlers
 
     # Evaluation limited to the following for security and to stop a templating language becoming a programming language.
     #  1. A static string
-    #  2. An instance variable
-    #  3. A method call/local variable
-    #  4. A method chain
+    #  2. A number, like 3 or 1.5
+    #  3. An instance variable
+    #  4. A method call/local variable
+    #  5. A method chain
     def evaluate(value:, current_binding:, escape: true)
       result = result(value:, current_binding:)
 
@@ -22,6 +23,7 @@ module Antlers
 
     def result(value:, current_binding:)
       return value[1..-2] if Queries.user_defined_string?(value)
+      return Queries.number(value) if Queries.number?(value)
       return value unless current_binding
 
       name, *chain = value.split('.')

data/lib/nodes/prop_node.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative '../antlers/keywords'
 require_relative '../interfaces/leaf_node'
 require_relative '../modules/namespace'
 require_relative '../modules/props'
@@ -13,6 +14,14 @@ module Antlers
       super(name:, props:)
 
       @namespace = namespace
+
+      # A class defined in a file that hasn't loaded yet is pending until "Antlers.resolve_nodes" or its first render.
+      PropNode.pending << self unless resolve
+    end
+
+    # Whether the prop's class is defined.
+    def resolve
+      !node_class.nil?
     end
 
     # Classes referenced via "<{ MyNode }>" must implement class/instance and render/render_template methods (See lownode).
@@ -20,17 +29,28 @@ module Antlers
       props = evaluate_props(props: @props, current_binding:)
       event = possible_render_event(props:)
 
-      # TODO: Get dirload to load constants defined in "<{ MyNode }>" syntax so that we can resolve namespace/params on class load.
-      klass = class_constant(namespace: @namespace&.split('::') || [], name: @name)
-      class_proxy = Lowkey[klass.to_s].first[klass.to_s]
+      klass = node_class || raise(NameError, "uninitialized constant #{@name}")
 
-      instance = create_instance(class_proxy:, klass:, event:, props:)
-      return instance.render_template(event:, parent_binding:, props:) if klass.template
+      # Initialize and render each get the props they take, and the event if they take it.
+      keywords = props.merge(event:)
+      instance = klass.new(**Keywords.accepted(klass.instance_method(:initialize), keywords))
+      return instance.render_template(event:, parent_binding:, props:) if klass.respond_to?(:template) && klass.template
 
-      render_args(class_proxy:, instance:, event:, props:)
+      instance.render(**Keywords.accepted(instance.method(:render), keywords))
     end
 
     class << self
+      # Prop nodes whose class wasn't defined when their template was built.
+      def pending
+        @pending ||= []
+      end
+
+      # Resolves pending prop nodes once every class has loaded, returning those whose class is still undefined.
+      def resolve
+        pending.reject!(&:resolve)
+        pending
+      end
+
       def match?(segment:)
         segment[:prop]
       end
@@ -42,22 +62,8 @@ module Antlers
 
     private
 
-    def create_instance(class_proxy:, klass:, event:, props:)
-      initialize_params = class_proxy.instance_methods[:initialize]&.tagged_params(:keyword)&.map(&:name) || []
-
-      return klass.new(event:, **props) if initialize_params.include?(:event) && initialize_params.count > 1
-      return klass.new(**props) if initialize_params.count > 1
-      return klass.new(event:) if initialize_params.include?(:event)
-
-      klass.new
-    end
-
-    def render_args(class_proxy:, instance:, event:, props:)
-      render_params = class_proxy.instance_methods[:render]&.tagged_params(:keyword)&.map(&:name) || []
-      return instance.render(event:, **props) if render_params.include?(:event) && render_params.count > 1
-      return instance.render(event:) if render_params.include?(:event)
-
-      instance.render
+    def node_class
+      class_constant(namespace: @namespace&.split('::') || [], name: @name)
     end
   end
 end

data/lib/nodes/slot_node.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative '../antlers/keywords'
 require_relative '../interfaces/branch_node'
 require_relative '../modules/namespace'
 require_relative '../modules/props'
@@ -24,14 +25,24 @@ module Antlers
       props = evaluate_props(props: @props, current_binding:)
       event = possible_render_event(props:)
 
-      # TODO: Get LowLoad to load constants defined in "<{ MyNode }>" syntax so that we can resolve namespace/params on class load.
       klass = class_constant(namespace: @namespace&.split('::') || [], name:)
-      instance = klass.new(event:)
+      keywords = props.merge(event:)
+      instance = klass.new(**Keywords.accepted(klass.instance_method(:initialize), keywords))
 
       # Classes referenced via "<{ ChildNode }>" must implement class/instance render/render_template methods (See LowNode).
-      return instance.render_template(event:, parent_binding: current_binding, slot_node: self, props:) if klass.template
+      if klass.respond_to?(:template) && klass.template
+        return instance.render_template(event:, parent_binding: current_binding, slot_node: self, props:)
+      end
+
+      # Without a class template, a component's own render method can receive its slot's rendered children as slot:.
+      render_method = instance.method(:render)
+      keywords[:slot] = slot(current_binding:, metadata:) if Keywords.takes?(render_method, :slot)
+      instance.render(**Keywords.accepted(render_method, keywords))
+    end
 
-      props.empty? ? instance.render(event:) : instance.render(event:, **props)
+    # The children rendered in the binding the slot is in, like a yield in a template renders them.
+    def slot(current_binding:, metadata:)
+      @children.map { |child| child.render(current_binding:, parent_binding: current_binding, slot_node: self, metadata:) || '' }.join
     end
 
     def end_name

data/lib/support/queries.rb

@@ -7,6 +7,15 @@ module Antlers
         wrapped_in?(string, "'") || wrapped_in?(string, '"')
       end
 
+      # A number literal, like 3, -2 or 1.5, rather than a variable or method name.
+      def number?(string)
+        string.match?(/\A-?\d+(\.\d+)?\z/)
+      end
+
+      def number(string)
+        string.include?('.') ? string.to_f : string.to_i
+      end
+
       def wrapped_in?(string, delimeter)
         string[0] == delimeter && string[-1] == delimeter
       end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: antlers
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - maedi
 bindir: exe
 cert_chain: []
-date: 2026-10-13 00:00:00.000000000 Z
+date: 2026-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: erb
@@ -62,6 +62,7 @@ files:
 - lib/antlers.rb
 - lib/antlers/api.rb
 - lib/antlers/elements.rb
+- lib/antlers/keywords.rb
 - lib/antlers/lexer.rb
 - lib/antlers/parser.rb
 - lib/antlers/version.rb