antlers 1.2.0 → 1.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 6ce3c9ccc84415933ff474d8187c420e28618fa7c15c56bffe0060e2364750d2
4
- data.tar.gz: cc69421e1365a4c3f38975aadd7eee7390797ba48c2aff399ad425f2bb05160e
3
+ metadata.gz: 418d2a128f90c866b14dbe4b0141aadfdd5c5e8cc1f52dc6bae38306b91be598
4
+ data.tar.gz: 8af5a64067ab89aa7d554e75005b42f1dec893788c000642cbcc89a9b1f54b7e
5
5
  SHA512:
6
- metadata.gz: da91462599377c23cc6cfc92fe4fa74e917a216a6378f1ef353ac3fcd6c53a947644dfc9cb3c2bb3937adaf33c5644d28a1f9698ea570c31de36479a8964301e
7
- data.tar.gz: 6c46c7a4aa39005d09ba125a7b2f4a1129383ade80691fffbe0757c3a19683144ecbbe12392ab22814b5894c83a3d489701ccdaa1da116e927881816e2cc4ad9
6
+ metadata.gz: b3e1b9a04c8d86e64480fd176364b5efcca374858f8eaed06a5f58853a06cf3cb76380f7f1ca97ad7c5f0fee77e283156d20889f9df0d35a2f3b93074bdbd84a
7
+ data.tar.gz: e1434fa1503d07c7754b68baaf8c8c7e60c29c9e46c29ea17f384dde53e311b4776c59a7f8685a2abb22740d937525e0e59c9588fc5ff5ceaefcdcbf0f5e7bb1
@@ -0,0 +1,27 @@
1
+ # frozen_string_literal: true
2
+
3
+ module Antlers
4
+ # Gives a method only the keywords it takes like initialize(limit:) and render(event:, slot:).
5
+ # LowNode uses the Method Factory pattern but the *instance* methods behave as the actualy method definitions.
6
+ module Keywords
7
+ module_function
8
+
9
+ # The keywords the method declares, or all of them when it takes **.
10
+ def accepted(method, keywords)
11
+ parameters = method.parameters
12
+ return keywords if parameters.any? { |type, _| type == :keyrest }
13
+
14
+ keywords.slice(*declared(parameters))
15
+ end
16
+
17
+ # Whether the method takes the keyword, by name or with **.
18
+ def takes?(method, name)
19
+ parameters = method.parameters
20
+ parameters.any? { |type, _| type == :keyrest } || declared(parameters).include?(name)
21
+ end
22
+
23
+ def declared(parameters)
24
+ parameters.filter_map { |type, name| name if %i[key keyreq].include?(type) }
25
+ end
26
+ end
27
+ end
data/lib/antlers/lexer.rb CHANGED
@@ -6,6 +6,9 @@ module Antlers
6
6
  class LexerError < StandardError; end
7
7
 
8
8
  class Lexer
9
+ # Only matches when the rest of the segment has balanced quotes, so title='A title = good' isn't split inside its quotes.
10
+ OUTSIDE_QUOTES = /(?=(?:[^'"]|'[^']*'|"[^"]*")*\z)/
11
+
9
12
  def initialize(lexeme_types:)
10
13
  @lexeme_types = lexeme_types.to_a
11
14
  @var_lexeme = @lexeme_types.find { it == VarLexeme }
@@ -52,10 +55,10 @@ module Antlers
52
55
 
53
56
  def antlers_lexeme(segment:, segments:)
54
57
  segment = segment.strip
55
- name, props, keywords = parse_antlers_segment(segment:)
56
-
57
58
  return @var_lexeme.lexeme(segment:, raw: false) if @var_lexeme && brackets?(segments:)
58
59
 
60
+ name, props, keywords = parse_antlers_segment(segment:)
61
+
59
62
  lexeme = @lexeme_types.find { it.match?(name:, keywords:) }
60
63
  return lexeme.lexeme(name:, props:, keywords:) if lexeme
61
64
 
@@ -64,9 +67,11 @@ module Antlers
64
67
  raise LexerError, "Unrecognised syntax: '#{segment}'"
65
68
  end
66
69
 
70
+ # Keywords are whole words, so a name like "Plain::Card" isn't split on the "in:" in it.
71
+ # Props are split into tokens like ['title', '=', "'A title'", 'size', '=', '2'].
67
72
  def parse_antlers_segment(segment:)
68
- name_and_props, *keywords = segment.split(/(#{Regexp.union(@keywords)})/)
69
- name, *props = name_and_props.split(' ')
73
+ name_and_props, *keywords = segment.split(/(?<!\S)(#{Regexp.union(@keywords)})(?!\S)#{OUTSIDE_QUOTES}/)
74
+ name, *props = name_and_props.split(/(=)#{OUTSIDE_QUOTES}|\s+#{OUTSIDE_QUOTES}/).reject(&:empty?)
70
75
  [name, props, parse_keywords(keywords:)]
71
76
  end
72
77
 
@@ -1,5 +1,5 @@
1
1
  # frozen_string_literal: true
2
2
 
3
3
  module Antlers
4
- VERSION = '1.2.0'
4
+ VERSION = '1.2.2'
5
5
  end
data/lib/antlers.rb CHANGED
@@ -1,6 +1,7 @@
1
1
  # frozen_string_literal: true
2
2
 
3
3
  require_relative 'antlers/elements'
4
+ require_relative 'antlers/keywords'
4
5
  require_relative 'antlers/lexer'
5
6
  require_relative 'antlers/parser'
6
7
 
@@ -17,4 +18,10 @@ module Antlers
17
18
  def render(ast:, current_binding:, parent_binding: nil, slot_node: nil, metadata: {})
18
19
  ast.render(current_binding:, parent_binding:, slot_node:, metadata:)
19
20
  end
21
+
22
+ # Call once an app has loaded, to find prop nodes built before their class loaded.
23
+ # Returns the prop nodes whose class is still undefined, which look up their class when first rendered.
24
+ def resolve_nodes
25
+ PropNode.resolve
26
+ end
20
27
  end
@@ -21,9 +21,7 @@ module Antlers
21
21
 
22
22
  # Support sending an event to render_template hook when lowevent available. See lownode as an example implementation.
23
23
  def possible_render_event(props:)
24
- Low::Events::RenderEvent.new(action: :render, props:) if defined?(LowEvent)
25
-
26
- nil
24
+ Low::Events::RenderEvent.new(action: :render, props:) if defined?(Low::Events::RenderEvent)
27
25
  end
28
26
 
29
27
  class << self
@@ -12,11 +12,9 @@ module Antlers
12
12
 
13
13
  private
14
14
 
15
- def props(props)
16
- odd_props = props.join(' ').split(/(=)|\s/)
17
-
18
- return {} unless odd_props.any?
19
-
15
+ # Takes tokens already split by the lexer, like ['title', '=', "'A title'", 'size', '=', '2'].
16
+ def props(tokens)
17
+ odd_props = tokens.dup
20
18
  props = {}
21
19
  until odd_props.empty?
22
20
  prop = odd_props.shift
@@ -8,12 +8,13 @@ module Antlers
8
8
  class_from_namespace(namespace:, name:)
9
9
  end
10
10
 
11
+ # Nil when the class isn't defined in the namespace or any of its parents.
11
12
  def class_from_namespace(namespace:, name:)
12
- namespace_with_name = [namespace, name].join('::')
13
+ namespace_with_name = [*namespace, name].join('::')
13
14
  return Object.const_get(namespace_with_name) if Object.const_defined?(namespace_with_name)
15
+ return nil if namespace.empty?
14
16
 
15
- namespace.pop
16
- class_from_namespace(namespace:, name:)
17
+ class_from_namespace(namespace: namespace[0...-1], name:)
17
18
  end
18
19
  end
19
20
  end
data/lib/modules/props.rb CHANGED
@@ -22,7 +22,7 @@ module Antlers
22
22
  evaluated_props = {}
23
23
 
24
24
  props.each do |name, value|
25
- evaluated_props[name] = evaluate(value:, current_binding:)
25
+ evaluated_props[name] = evaluate(value:, current_binding:, escape: false)
26
26
  end
27
27
 
28
28
  evaluated_props
@@ -1,6 +1,7 @@
1
1
  # frozen_string_literal: true
2
2
 
3
3
  require 'erb'
4
+ require 'lowkey'
4
5
  require_relative '../support/queries'
5
6
 
6
7
  module Antlers
@@ -8,10 +9,11 @@ module Antlers
8
9
  extend Queries
9
10
 
10
11
  # Evaluation limited to the following for security and to stop a templating language becoming a programming language.
11
- # 1. A static string
12
- # 2. An instance variable
13
- # 3. A method call/local variable
14
- # 4. A method chain
12
+ # 1. A value ('string', 3, 1.5, true, nil or :symbol)
13
+ # 2. Invalid string ("Hi #{name}", 'it's', 'a' + 'b')
14
+ # 3. An instance variable
15
+ # 4. A method call/local variable
16
+ # 5. A method chain
15
17
  def evaluate(value:, current_binding:, escape: true)
16
18
  result = result(value:, current_binding:)
17
19
 
@@ -21,20 +23,25 @@ module Antlers
21
23
  end
22
24
 
23
25
  def result(value:, current_binding:)
24
- return value[1..-2] if Queries.user_defined_string?(value)
25
- return value unless current_binding
26
+ Lowkey::ValueParser.parse(value) do
27
+ next value[1..-2] if Queries.user_defined_string?(value)
28
+ next value unless current_binding
26
29
 
30
+ variable(value:, current_binding:)
31
+ end
32
+ end
33
+
34
+ private
35
+
36
+ def variable(value:, current_binding:)
27
37
  name, *chain = value.split('.')
28
38
 
29
39
  result = method_var(name:, current_binding:)
30
40
  return method_chain(result:, chain:) if chain.count > 0
31
- return result if result
32
41
 
33
- nil
42
+ result
34
43
  end
35
44
 
36
- private
37
-
38
45
  def method_var(name:, current_binding:)
39
46
  return current_binding.receiver.instance_variable_get(name) if name.start_with?('@')
40
47
  return current_binding.local_variable_get(name) if current_binding.local_variable_defined?(name)
@@ -45,7 +52,7 @@ module Antlers
45
52
 
46
53
  def method_chain(result:, chain:)
47
54
  chain.reduce(result) do |result, method_call|
48
- result.send(method_call.to_sym)
55
+ result&.send(method_call.to_sym)
49
56
  end
50
57
  end
51
58
  end
@@ -1,5 +1,6 @@
1
1
  # frozen_string_literal: true
2
2
 
3
+ require_relative '../antlers/keywords'
3
4
  require_relative '../interfaces/leaf_node'
4
5
  require_relative '../modules/namespace'
5
6
  require_relative '../modules/props'
@@ -13,6 +14,14 @@ module Antlers
13
14
  super(name:, props:)
14
15
 
15
16
  @namespace = namespace
17
+
18
+ # A class defined in a file that hasn't loaded yet is pending until "Antlers.resolve_nodes" or its first render.
19
+ PropNode.pending << self unless resolve
20
+ end
21
+
22
+ # Whether the prop's class is defined.
23
+ def resolve
24
+ !node_class.nil?
16
25
  end
17
26
 
18
27
  # Classes referenced via "<{ MyNode }>" must implement class/instance and render/render_template methods (See lownode).
@@ -20,17 +29,28 @@ module Antlers
20
29
  props = evaluate_props(props: @props, current_binding:)
21
30
  event = possible_render_event(props:)
22
31
 
23
- # TODO: Get dirload to load constants defined in "<{ MyNode }>" syntax so that we can resolve namespace/params on class load.
24
- klass = class_constant(namespace: @namespace&.split('::') || [], name: @name)
25
- class_proxy = Lowkey[klass.to_s].first[klass.to_s]
32
+ klass = node_class || raise(NameError, "uninitialized constant #{@name}")
26
33
 
27
- instance = create_instance(class_proxy:, klass:, event:, props:)
28
- return instance.render_template(event:, parent_binding:, props:) if klass.template
34
+ # Initialize and render each get the props they take, and the event if they take it.
35
+ keywords = props.merge(event:)
36
+ instance = klass.new(**Keywords.accepted(klass.instance_method(:initialize), keywords))
37
+ return instance.render_template(event:, parent_binding:, props:) if klass.respond_to?(:template) && klass.template
29
38
 
30
- render_args(class_proxy:, instance:, event:, props:)
39
+ instance.render(**Keywords.accepted(instance.method(:render), keywords))
31
40
  end
32
41
 
33
42
  class << self
43
+ # Prop nodes whose class wasn't defined when their template was built.
44
+ def pending
45
+ @pending ||= []
46
+ end
47
+
48
+ # Resolves pending prop nodes once every class has loaded, returning those whose class is still undefined.
49
+ def resolve
50
+ pending.reject!(&:resolve)
51
+ pending
52
+ end
53
+
34
54
  def match?(segment:)
35
55
  segment[:prop]
36
56
  end
@@ -42,22 +62,8 @@ module Antlers
42
62
 
43
63
  private
44
64
 
45
- def create_instance(class_proxy:, klass:, event:, props:)
46
- initialize_params = class_proxy.instance_methods[:initialize]&.tagged_params(:keyword)&.map(&:name) || []
47
-
48
- return klass.new(event:, **props) if initialize_params.include?(:event) && initialize_params.count > 1
49
- return klass.new(**props) if initialize_params.count > 1
50
- return klass.new(event:) if initialize_params.include?(:event)
51
-
52
- klass.new
53
- end
54
-
55
- def render_args(class_proxy:, instance:, event:, props:)
56
- render_params = class_proxy.instance_methods[:render]&.tagged_params(:keyword)&.map(&:name) || []
57
- return instance.render(event:, **props) if render_params.include?(:event) && render_params.count > 1
58
- return instance.render(event:) if render_params.include?(:event)
59
-
60
- instance.render
65
+ def node_class
66
+ class_constant(namespace: @namespace&.split('::') || [], name: @name)
61
67
  end
62
68
  end
63
69
  end
@@ -1,5 +1,6 @@
1
1
  # frozen_string_literal: true
2
2
 
3
+ require_relative '../antlers/keywords'
3
4
  require_relative '../interfaces/branch_node'
4
5
  require_relative '../modules/namespace'
5
6
  require_relative '../modules/props'
@@ -24,14 +25,24 @@ module Antlers
24
25
  props = evaluate_props(props: @props, current_binding:)
25
26
  event = possible_render_event(props:)
26
27
 
27
- # TODO: Get LowLoad to load constants defined in "<{ MyNode }>" syntax so that we can resolve namespace/params on class load.
28
28
  klass = class_constant(namespace: @namespace&.split('::') || [], name:)
29
- instance = klass.new(event:)
29
+ keywords = props.merge(event:)
30
+ instance = klass.new(**Keywords.accepted(klass.instance_method(:initialize), keywords))
30
31
 
31
32
  # Classes referenced via "<{ ChildNode }>" must implement class/instance render/render_template methods (See LowNode).
32
- return instance.render_template(event:, parent_binding: current_binding, slot_node: self, props:) if klass.template
33
+ if klass.respond_to?(:template) && klass.template
34
+ return instance.render_template(event:, parent_binding: current_binding, slot_node: self, props:)
35
+ end
36
+
37
+ # Without a class template, a component's own render method can receive its slot's rendered children as slot:.
38
+ render_method = instance.method(:render)
39
+ keywords[:slot] = slot(current_binding:, metadata:) if Keywords.takes?(render_method, :slot)
40
+ instance.render(**Keywords.accepted(render_method, keywords))
41
+ end
33
42
 
34
- props.empty? ? instance.render(event:) : instance.render(event:, **props)
43
+ # The children rendered in the binding the slot is in, like a yield in a template renders them.
44
+ def slot(current_binding:, metadata:)
45
+ @children.map { |child| child.render(current_binding:, parent_binding: current_binding, slot_node: self, metadata:) || '' }.join
35
46
  end
36
47
 
37
48
  def end_name
metadata CHANGED
@@ -1,13 +1,13 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: antlers
3
3
  version: !ruby/object:Gem::Version
4
- version: 1.2.0
4
+ version: 1.2.2
5
5
  platform: ruby
6
6
  authors:
7
7
  - maedi
8
8
  bindir: exe
9
9
  cert_chain: []
10
- date: 2026-10-13 00:00:00.000000000 Z
10
+ date: 2026-10-20 00:00:00.000000000 Z
11
11
  dependencies:
12
12
  - !ruby/object:Gem::Dependency
13
13
  name: erb
@@ -29,14 +29,14 @@ dependencies:
29
29
  requirements:
30
30
  - - ">="
31
31
  - !ruby/object:Gem::Version
32
- version: '0'
32
+ version: 0.7.0
33
33
  type: :runtime
34
34
  prerelease: false
35
35
  version_requirements: !ruby/object:Gem::Requirement
36
36
  requirements:
37
37
  - - ">="
38
38
  - !ruby/object:Gem::Version
39
- version: '0'
39
+ version: 0.7.0
40
40
  - !ruby/object:Gem::Dependency
41
41
  name: plugs
42
42
  requirement: !ruby/object:Gem::Requirement
@@ -62,6 +62,7 @@ files:
62
62
  - lib/antlers.rb
63
63
  - lib/antlers/api.rb
64
64
  - lib/antlers/elements.rb
65
+ - lib/antlers/keywords.rb
65
66
  - lib/antlers/lexer.rb
66
67
  - lib/antlers/parser.rb
67
68
  - lib/antlers/version.rb