antlers 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eca914b3e0a81f538aaa1e4db0b477a9b46c0934d365786962d2a391c957b3ee
-  data.tar.gz: 7f46ddc34ff748822e99537b59e0300fe6c094abe79d2cd042ad78ad7cb9068d
+  metadata.gz: 581b3e4990e2c5279c26989e05e545f61a80a3fb8590c8a4bfd058878f2684f8
+  data.tar.gz: 5135d9c10a19fa9bb80c79694f998287c1dad614514a6d22c915cfc371d54b71
 SHA512:
-  metadata.gz: ca62292741c30d4a3ed0a0c0b62dcb20a895eb3018d55b179ef3512f47e078628eff04089b285490add876d1cfa5ca473a4b85b7bdf01d69d56e459b0364e1bb
-  data.tar.gz: db84676dac56bce48b73b1019d73924c7c82c7e4c98d6b5a9c9dddbae2e8defd68336f8ec83e64154403a2f9d1fe611d441ebec99f5f2c2a899bb2fe6a7acfc4
+  metadata.gz: 4e85dd8fc504c21fe4c71f692203dc695fd60834e2f2f33185c1daf6edbf3e64c4c8eccf29710d899f5beab1c348cac1c9fe6a8350778b7563cd4d879cef78e2
+  data.tar.gz: 5b4853ba5e0d0749d4305c57923d6488ddcd5b05892aa2e274dd3683519ae85fcbd9a84b117e9c453a9b1ab256c814cd6f6d35b71db76935e30f0c86d17852ba

data/lib/antlers.rb

@@ -3,11 +3,9 @@
 require_relative 'lexer'
 require_relative 'parser'
 
-require 'low_event'
-
 module Antlers
   class << self
-    def parse(template)
+    def ast(template)
       return template unless template.include?('<{') || template.include?('{')
 
       lexemes = Lexer.new.parse(template)

data/lib/factories/node_factory.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative '../nodes/for_node'
 require_relative '../nodes/prop_node'
 require_relative '../nodes/slot_node'
 require_relative '../nodes/var_node'
@@ -8,6 +9,11 @@ require_relative '../nodes/yield_node'
 module Antlers
   class NodeFactory
     class << self
+      def for_node(segment:)
+        value, key, items = segment.values_at(:for_def, :key, :in)
+        ForNode.new(name: value, key:, value:, items:)
+      end
+
       def prop_node(segment:)
         PropNode.new(name: segment[:prop], props: segment[:props])
       end

data/lib/lexer.rb

@@ -10,7 +10,7 @@ module Antlers
   class Lexer
     def initialize
       @delimiters = ['<{', '}>', '{', '}']
-      @keywords = ['if:', 'for:', 'in:', 'slot:', ':slot']
+      @keywords = ['if:', 'for:', 'in:', ':for', 'slot:', ':slot']
       @cursor = 0
     end
 
@@ -54,22 +54,27 @@ module Antlers
       return slot_yield if slot_yield?(keywords)
       return slot(name:, props:) if slot?(name)
       return prop(name:, props:) if prop?(name)
+      return for_loop(keywords:) if for_loop?(keywords:)
 
-      raise LexerParseError, "Couldn't parse antlers syntax: '#{antlers_segment}'"
+      raise LexerParseError, "Unrecognised syntax: '#{antlers_segment}'"
     end
 
     def parse_segment(antlers_segment:)
       name_and_props, *keywords = antlers_segment.split(/(#{Regexp.union(@keywords)})/)
       name, *props = name_and_props.split(' ')
 
-      [name, props, keywords]
+      [name, props, keywords.map(&:strip)]
     end
 
     def var?(segments:)
-      first, middle, last = segments[@cursor..@cursor + 3].map(&:strip)
+      first, _, last = segments[@cursor..@cursor + 3].map(&:strip)
       first == '{' && last == '}'
     end
 
+    def for_loop?(keywords:)
+      ['for:', ':for'].include?(keywords.first)
+    end
+
     def slot?(name)
       name && (name.start_with?(':') || name.end_with?(':'))
     end
@@ -84,13 +89,25 @@ module Antlers
 
     def var(antlers_segment:)
       # String is already interpolated or not depending on user input on the template layer, now we store it without those template quotes.
-      if Queries.user_defined_string?(antlers_segment)
-        antlers_segment = antlers_segment[1..-2]
-      end
+      antlers_segment = antlers_segment[1..-2] if Queries.user_defined_string?(antlers_segment)
 
       { var: antlers_segment }
     end
 
+    def for_loop(keywords:)
+      key_values = keywords.count.even? ? keywords.each_slice(2).to_h : {}
+
+      if key_values['for:']
+        *key, value = key_values['for:'].split(',').map(&:strip)
+        for_def = { for_def: value, in: key_values['in:'] }
+        for_def[:key] = key.first unless key.empty?
+        return for_def
+      end
+
+      # TODO: Keep track of which for loop we're in to allow nested for loops.
+      { for_end: 'level_1' }
+    end
+
     def slot(name:, props:)
       if name.end_with?(':')
         slot_def = { slot_def: name.delete_suffix(':') }

data/lib/modules/props.rb

@@ -1,7 +1,12 @@
 # frozen_string_literal: true
 
+require 'low_event'
+require_relative 'variables'
+
 module Antlers
   module Props
+    include Variables
+
     attr_accessor :props
 
     def initialize(name:, props: {}, **)
@@ -12,7 +17,7 @@ module Antlers
 
     private
 
-    def create_event(props:)
+    def create_render_event(props:)
       Low::Events::RenderEvent.new(action: :render, props:)
     end
 
@@ -22,13 +27,7 @@ module Antlers
       evaluated_props = {}
 
       props.each do |name, value|
-        receiver = current_binding.receiver
-        
-        if receiver.respond_to?(value.to_sym)
-          evaluated_props[name] = receiver.send(value.to_sym) 
-        elsif value.start_with?('@')
-          evaluated_props[name] = receiver.instance_variable_get(value)
-        end
+        evaluated_props[name] = evaluate(name: value, current_binding:)
       end
 
       evaluated_props

data/lib/modules/variables.rb

@@ -0,0 +1,38 @@
+module Antlers
+  module Variables
+    # Evaluation limited to the following for security and to prevent a templating language becoming a programming language.
+    #  1. An instance variable
+    #  2. A method call/local variable
+    #  3. A method chain
+    #  4. A static string
+    def evaluate(name:, current_binding:)
+      return @value.to_s unless current_binding
+
+      name, *chain = name.split('.')
+
+      result = method_var(name:, current_binding:)
+      return method_chain(result:, chain:, current_binding:) if chain.count > 0
+      return result if result
+
+      @value.to_s
+    rescue NameError
+      @value.to_s
+    end
+
+    private
+
+    def method_var(name:, current_binding:)
+      return current_binding.receiver.instance_variable_get(name) if name.start_with?('@')
+      return current_binding.local_variable_get(name) if current_binding.local_variable_defined?(name)
+      return current_binding.receiver.send(name.to_sym) if current_binding.receiver.respond_to?(name.to_sym)
+
+      nil
+    end
+
+    def method_chain(result:, chain:, current_binding:)
+      chain.reduce(result) do |result, method_call|
+        result.send(method_call.to_sym)
+      end
+    end
+  end
+end

data/lib/nodes/for_node.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/branch_node'
+require_relative '../modules/props'
+require_relative '../modules/variables'
+
+module Antlers
+  class ForNode < BranchNode
+    include Props
+    include Variables
+
+    attr_accessor :children
+
+    def initialize(name:, items:, value:, key: nil, props: [], children: [])
+      super(name:, props:, children:)
+
+      @items = items
+      @value = value
+      @key = key
+    end
+
+    def render(current_binding: nil, parent_binding: nil, slot_node: nil, namespace: nil)
+      output = ''
+
+      evaluate(name: @items, current_binding:).each do |value|
+        key, value = value if @key
+
+        # TODO: Parallelize by creating new bindings and ensuring children have any args they need via RenderEvent.
+        current_binding.local_variable_set(@value, value)
+        current_binding.local_variable_set(@key, key) if @key
+
+        @children.each do |child|
+          # Antlers nodes respond to "render", whereas HTML is stored as a string and output as is.
+          output += (child.respond_to?(:render) ? child.render(current_binding:, parent_binding:, slot_node:, namespace:) : child) || ''
+        end
+      end
+
+      output
+    end
+  end
+end

data/lib/nodes/prop_node.rb

@@ -9,15 +9,15 @@ module Antlers
 
     def render(current_binding: nil, parent_binding: nil, slot_node: nil, namespace: nil)
       props = evaluate_props(props: @props, current_binding:)
-      event = create_event(props:)
+      event = create_render_event(props:)
 
-      klass = class_from_namespace(namespace: namespace&.split('::') || [], name: @name)
-      instance = klass.new(event:)
+      renderable_klass = class_from_namespace(namespace: namespace&.split('::') || [], name: @name)
+      renderable_instance = renderable_klass.new(event:)
 
       # Classes referenced via "<{ ChildNode }>" must implement class/instance render/render_template methods (See LowNode).
-      return instance.render_template(event:, parent_binding:, props:) if klass.template
+      return renderable_instance.render_template(event:, parent_binding:, props:) if renderable_klass.template
 
-      props.empty? ? instance.render(event:) : instance.render(event:, **props)
+      props.empty? ? renderable_instance.render(event:) : renderable_instance.render(event:, **props)
     end
   end
 end

data/lib/nodes/slot_node.rb

@@ -15,7 +15,7 @@ module Antlers
 
     def render(current_binding: nil, parent_binding: nil, slot_node: nil, namespace: nil)
       props = evaluate_props(props: @props, current_binding:)
-      event = create_event(props:)
+      event = create_render_event(props:)
 
       klass = class_from_namespace(namespace: namespace&.split('::') || [], name: @name)
       instance = klass.new(event:)

data/lib/nodes/var_node.rb

@@ -3,38 +3,22 @@
 require 'erb'
 
 require_relative '../interfaces/leaf_node'
+require_relative '../modules/variables'
 
 module Antlers
   class VarNode < LeafNode
+    include Variables
+
     attr_reader :value
 
-    def initialize(name: :var, value:)
+    def initialize(value:, name: :var)
       super(name:)
 
       @value = value
     end
 
     def render(current_binding: nil, parent_binding: nil, slot_node: nil, namespace: nil)
-      ERB::Util.html_escape(evaluate_value(current_binding))
-    end
-
-    private
-
-    # A variable is deliberately limited in what it can represent.
-    #  1. An instance/local variable
-    #  2. A method call
-    #  3. A static string
-    def evaluate_value(current_binding)
-      if current_binding
-        return current_binding.receiver.instance_variable_get(@value) if @value.start_with?('@')
-        return current_binding.local_variable_get(@value) if current_binding.local_variable_defined?(@value)
-        return current_binding.receiver.send(@value.to_sym) if current_binding.receiver.respond_to?(@value.to_sym)
-      end
-
-      @value
-    rescue NameError => e
-      # TODO: Must be a better way to handle variables input as literal strings.
-      @value
+      ERB::Util.html_escape(evaluate(name: @value, current_binding:) || @value)
     end
   end
 end

data/lib/nodes/yield_node.rb

@@ -14,7 +14,11 @@ module Antlers
 
       slot_node.children.each do |child|
         # Antlers nodes respond to "render", whereas HTML is stored as a string and output as is.
-        output += (child.respond_to?(:render) ? child.render(current_binding: parent_binding, parent_binding: nil, slot_node: nil, namespace:) : child) || ''
+        if child.respond_to?(:render) # rubocop:disable Style/ConditionalAssignment
+          output += child.render(current_binding: parent_binding, parent_binding: nil, slot_node: nil, namespace:)
+        else
+          output += child || ''
+        end
       end
 
       output

data/lib/parser.rb

@@ -7,33 +7,40 @@ module Antlers
   module Parser
     class << self
       def parse(sequence, id: :root_node)
-        branch(branch_node: RootNode.new(name: id), sequence:)
+        branch(node: RootNode.new(name: id), sequence:)
       end
 
-      def branch(branch_node:, sequence:) # rubocop:disable Metrics/AbcSize
+      def branch(node:, sequence:) # rubocop:disable Metrics/AbcSize
         until sequence.empty?
           segment = sequence.shift
 
           if segment.is_a?(String)
-            branch_node.children << segment
+            node.children << segment
           elsif segment[:var]
-            branch_node.children << NodeFactory.var_node(segment:)
+            node.children << NodeFactory.var_node(segment:)
           elsif segment[:prop]
-            branch_node.children << NodeFactory.prop_node(segment:)
+            node.children << NodeFactory.prop_node(segment:)
           elsif segment[:slot]
-            branch_node.children << NodeFactory.yield_node(segment:)
+            node.children << NodeFactory.yield_node(segment:)
           elsif segment[:slot_def]
             slot_node = NodeFactory.slot_node(segment:)
-            branch_node.children << slot_node
-
-            sub_sequence = []
-            sub_sequence << sequence.shift until sequence.first.is_a?(Hash) && sequence.first[:slot_end] == slot_node.name
-
-            branch(branch_node: slot_node, sequence: sub_sequence)
+            node.children << slot_node
+            sub_branch(node: slot_node, sequence:, end_key: :slot_end, end_name: slot_node.name)
+          elsif segment[:for_def]
+            for_node = NodeFactory.for_node(segment:)
+            node.children << for_node
+            sub_branch(node: for_node, sequence:, end_key: :for_end, end_name: 'level_1')
           end
         end
 
-        branch_node
+        node
+      end
+
+      def sub_branch(node:, sequence:, end_key:, end_name: nil)
+        sub_sequence = []
+        sub_sequence << sequence.shift until sequence.first.is_a?(Hash) && sequence.first[end_key] == end_name
+
+        branch(node:, sequence: sub_sequence)
       end
     end
   end

data/lib/queries.rb

@@ -4,7 +4,7 @@ module Antlers
   module Queries
     class << self
       def user_defined_string?(string)
-        wrapped_in?(string, %q{'}) || wrapped_in?(string, %q{"})
+        wrapped_in?(string, "'") || wrapped_in?(string, '"')
       end
 
       def wrapped_in?(string, delimeter)

data/lib/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: antlers
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - maedi
@@ -10,7 +10,7 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: low_event
+  name: erb
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -24,7 +24,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: erb
+  name: low_event
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -51,6 +51,8 @@ files:
 - lib/interfaces/leaf_node.rb
 - lib/lexer.rb
 - lib/modules/props.rb
+- lib/modules/variables.rb
+- lib/nodes/for_node.rb
 - lib/nodes/prop_node.rb
 - lib/nodes/root_node.rb
 - lib/nodes/slot_node.rb
@@ -78,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Deer to be different
 test_files: []