antlers 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eca914b3e0a81f538aaa1e4db0b477a9b46c0934d365786962d2a391c957b3ee
-  data.tar.gz: 7f46ddc34ff748822e99537b59e0300fe6c094abe79d2cd042ad78ad7cb9068d
+  metadata.gz: 57d224246ca8ba02aac3045b0f06904d8cebb0cfdb7f3d518d3c646324a1e3b6
+  data.tar.gz: e8b7787ccfc284dbb1d370292ba4238576e346c75bc957d5da70067220635ba7
 SHA512:
-  metadata.gz: ca62292741c30d4a3ed0a0c0b62dcb20a895eb3018d55b179ef3512f47e078628eff04089b285490add876d1cfa5ca473a4b85b7bdf01d69d56e459b0364e1bb
-  data.tar.gz: db84676dac56bce48b73b1019d73924c7c82c7e4c98d6b5a9c9dddbae2e8defd68336f8ec83e64154403a2f9d1fe611d441ebec99f5f2c2a899bb2fe6a7acfc4
+  metadata.gz: b4cb6632bbbafb3ec12cc27256b2ae9e2134e3b621e28a7edcfd269bfff828d128cd0f659d7135a734b7792d121477c0ca012c3215a1eef442d3106bb637e89d
+  data.tar.gz: 0a0f5f6fc83e72a7253a737956c3a4cff5961999722b23b96ad44716b3ad2b2e40ce7742145cea8610f9604467a438a12000a0609cd9408487f85472f362cb3d

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,10 @@ require_relative '../nodes/yield_node'
 module Antlers
   class NodeFactory
     class << self
+      def for_node(segment:)
+        ForNode.new(name: segment[:for_def], item: segment[:for_def], items: segment[:in])
+      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,15 +54,16 @@ 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:)
@@ -70,6 +71,10 @@ module Antlers
       first == '{' && last == '}'
     end
 
+    def for_loop?(keywords:)
+      keywords.first == 'for:' || keywords.first == ':for'
+    end
+
     def slot?(name)
       name && (name.start_with?(':') || name.end_with?(':'))
     end
@@ -91,6 +96,19 @@ module Antlers
       { var: antlers_segment }
     end
 
+    def for_loop(keywords:)
+      key_values = keywords.count % 2 == 0 ? keywords.each_slice(2).to_h : {}
+
+      if key_values['for:']
+        for_def = { for_def: key_values['for:'] }
+        for_def[:in] = key_values['in:']
+        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,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'low_event'
+
 module Antlers
   module Props
     attr_accessor :props
@@ -12,7 +14,7 @@ module Antlers
 
     private
 
-    def create_event(props:)
+    def create_render_event(props:)
       Low::Events::RenderEvent.new(action: :render, props:)
     end
 

data/lib/modules/variables.rb

@@ -0,0 +1,19 @@
+module Antlers
+  module Variables
+    # A variable is deliberately limited in what it can represent.
+    #  1. An instance variable
+    #  2. A method call/local variable
+    #  3. A static string
+    def evaluate_variable(name:, current_binding:)
+      if 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)
+      end
+
+      @value.to_s
+    rescue NameError
+      @value.to_s
+    end
+  end
+end

data/lib/nodes/for_node.rb

@@ -0,0 +1,36 @@
+# 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:, item:, items:, props: [], children: [])
+      super(name:, props:, children:)
+
+      @item = item
+      @items = items
+    end
+
+    def render(current_binding: nil, parent_binding: nil, slot_node: nil, namespace: nil)
+      output = ''
+
+      evaluate_variable(name: @items, current_binding:).each do |item|
+        current_binding.local_variable_set(@item, item)
+
+        @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,9 +3,12 @@
 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:)
@@ -15,26 +18,7 @@ module Antlers
     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_variable(name: @value, current_binding:) || @value)
     end
   end
 end

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/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: antlers
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - maedi
@@ -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: []