antlers 0.8.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d3bcf6e14ade37294793b87b3ab3ab152e519f8c081a130644b0d28d489b63b
-  data.tar.gz: d9886a3044fb8654b37f111a9536ba7dfef4945c26fb08112e400ab14e76d8e7
+  metadata.gz: f16d22b587d7dbdc07a0a51fc19032271be9347e90eb09c77541a56099f8088f
+  data.tar.gz: b1437b4cac8a748fc23fc6eaf06c07e5d3111d63d5100651afb9195f488dacfb
 SHA512:
-  metadata.gz: a4179e613ca96ea49fdbc7d991a627a45640182ae5aaa5f01dc935396586ba8b583df469113c26c7a139308956bc18980cdbd04877c73a9b7cd14617682dd2d3
-  data.tar.gz: 698769c0d6bfd0e9872c5022f72555290acff3888615f44061ed10847af8f97af58477c35059678c2e02a2bdafc16d3f06ff514ab80aa539abc2de7cbfeda6bd
+  metadata.gz: ecc5de204a45f9cda60f03aeefc49aee735fc9aa3da5fd20b1d12959497bfb4683ab299bd64d4ae8795b3296ab9e018c8b8eb70672f3788aeeeaf8355f03d07e
+  data.tar.gz: 0b14edede169971914c9958f4b3369c361271566d36c883dd3c1774ef968e8299d2d95c58a90e921ea2bbae5d70f4a2634c8ce00217e058c2ee6c71a9ec3a42f

data/lib/antlers/elements.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'plugs'
+
+module Antlers
+  class Elements
+    include Plugs
+
+    plug(:root) do
+      plug(:node) do
+        require_relative '../nodes/root_node'
+        RootNode
+      end
+    end
+
+    plug(:html) do
+      plug(:node) do
+        lazy do
+          require_relative '../nodes/html_node'
+          HTMLNode
+        end
+      end
+    end
+
+    plug(:form) do
+      plug(:lexeme) do
+        lazy do
+          require_relative '../lexemes/form_lexeme'
+          FormLexeme
+        end
+      end
+
+      plug(:node) do
+        lazy do
+          require_relative '../nodes/form_node'
+          FormNode
+        end
+      end
+    end
+
+    plug(:for) do
+      plug(:lexeme) do
+        lazy do
+          require_relative '../lexemes/for_lexeme'
+          ForLexeme
+        end
+      end
+
+      plug(:node) do
+        lazy do
+          require_relative '../nodes/for_node'
+          ForNode
+        end
+      end
+    end
+
+    plug(:if) do
+      plug(:lexeme) do
+        lazy do
+          require_relative '../lexemes/if_lexeme'
+          IfLexeme
+        end
+      end
+
+      plug(:node) do
+        lazy do
+          require_relative '../nodes/if_node'
+          IfNode
+        end
+      end
+    end
+
+    plug(:prop) do
+      plug(:lexeme) do
+        lazy do
+          require_relative '../lexemes/prop_lexeme'
+          PropLexeme
+        end
+      end
+
+      plug(:node) do
+        lazy do
+          require_relative '../nodes/prop_node'
+          PropNode
+        end
+      end
+    end
+
+    plug(:slot) do
+      plug(:lexeme) do
+        lazy do
+          require_relative '../lexemes/slot_lexeme'
+          SlotLexeme
+        end
+      end
+
+      plug(:node) do
+        lazy do
+          require_relative '../nodes/slot_node'
+          SlotNode
+        end
+      end
+    end
+
+    plug(:yield) do
+      plug(:lexeme) do
+        lazy do
+          require_relative '../lexemes/yield_lexeme'
+          YieldLexeme
+        end
+      end
+
+      plug(:node) do
+        lazy do
+          require_relative '../nodes/yield_node'
+          YieldNode
+        end
+      end
+    end
+
+    plug(:var) do
+      plug(:node) do
+        lazy do
+          require_relative '../nodes/var_node'
+          VarNode
+        end
+      end
+
+      plug(:lexeme) do
+        lazy do
+          require_relative '../lexemes/var_lexeme'
+          VarLexeme
+        end
+      end
+    end
+  end
+end

data/lib/antlers/lexer.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative '../lexemes/var_lexeme'
+
+module Antlers
+  class LexerError < StandardError; end
+
+  class Lexer
+    def initialize(lexeme_types:)
+      @lexeme_types = lexeme_types.to_a
+      @var_lexeme = @lexeme_types.find { it == VarLexeme }
+
+      @delimiters = ['<{', '}>']
+      @delimiters = [*@delimiters, '{', '}'] if @var_lexeme
+
+      @keywords = @lexeme_types.flat_map { |lexeme| lexeme.const_get(:KEYWORDS) }
+      @cursor = 0
+    end
+
+    def parse(template:)
+      @cursor = 0
+      sequence = []
+
+      # Split on delimiters and retain capture groups.
+      segments = template.split(/(#{Regexp.union(@delimiters)})/).map(&:strip)
+
+      until segments[@cursor].nil?
+        if (segment = antlers_segment(segments:))
+          sequence << antlers_lexeme(segment:, segments:)
+          # Skipping: ['{', 'expression', '}']
+          # Skipping: ['<{', 'name + props + keywords', '}>']
+          @cursor += 3
+        else
+          segment = segments[@cursor]
+          sequence << segment unless segment.empty?
+          @cursor += 1
+        end
+      end
+
+      sequence
+    end
+
+    private
+
+    def antlers_segment(segments:)
+      next_segment = segments[@cursor + 1]
+      return nil unless next_segment && (segments[@cursor] == '<{' || brackets?(segments:))
+
+      next_segment
+    end
+
+    def antlers_lexeme(segment:, segments:)
+      name, props, keywords = parse_antlers_segment(segment:)
+
+      return @var_lexeme.lexeme(segment:, raw: false) if @var_lexeme && brackets?(segments:)
+
+      lexeme = @lexeme_types.find { it.match?(name:, keywords:) }
+      return lexeme.lexeme(name:, props:, keywords:) if lexeme
+
+      return @var_lexeme.lexeme(segment:, raw: true) if @var_lexeme && deerheads?(segments:)
+
+      raise LexerError, "Unrecognised syntax: '#{segment}'"
+    end
+
+    def parse_antlers_segment(segment:)
+      name_and_props, *keywords = segment.split(/(#{Regexp.union(@keywords)})/)
+      name, *props = name_and_props.split(' ')
+      [name, props, parse_keywords(keywords:)]
+    end
+
+    def parse_keywords(keywords:)
+      key_values = {}
+
+      while (keyword = keywords.shift)
+        keyword.strip!
+        value = keyword.end_with?(':') && value?(keywords.first.strip) ? keywords.shift.strip : nil
+        key_values[keyword] = value
+      end
+
+      key_values
+    end
+
+    def value?(string)
+      !(string.start_with?(':') || string.end_with?(':'))
+    end
+
+    def brackets?(segments:)
+      first, _, last = segments[@cursor..@cursor + 3].map(&:strip)
+      first == '{' && last == '}'
+    end
+
+    def deerheads?(segments:)
+      first, _, last = segments[@cursor..@cursor + 3].map(&:strip)
+      first == '<{' && last == '}>'
+    end
+  end
+end

data/lib/antlers/parser.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Antlers
+  class Parser
+    class ParserError < StandardError; end
+
+    def initialize(node_types:, namespace: nil)
+      @node_types = node_types.to_a
+      @namespace = namespace
+      @template = nil
+    end
+
+    def parse(sequence:, template: nil, id: :root_node)
+      @template = template
+
+      branch(node: RootNode.new(name: id), sequence:)
+    end
+
+    def branch(node:, sequence:)
+      until sequence.empty?
+        segment = sequence.shift
+
+        child_class = @node_types.find { |n| n.match?(segment:) }
+        raise(ParserError, "No node matches #{segment}") unless child_class
+
+        child = child_class.build(segment:, namespace: @namespace, template: @template)
+        node.children << child
+
+        if (end_key = child_class::END_KEY)
+          sub_branch(node: child, sequence:, end_key:, end_name: child.end_name)
+        end
+      end
+
+      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
+      # Remove the end tag we just stopped before.
+      sequence.shift
+
+      branch(node:, sequence: sub_sequence)
+    end
+  end
+end

data/lib/{version.rb → antlers/version.rb}

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

data/lib/antlers.rb

@@ -1,15 +1,20 @@
 # frozen_string_literal: true
 
-require_relative 'lexer'
-require_relative 'parser'
+require_relative 'antlers/elements'
+require_relative 'antlers/lexer'
+require_relative 'antlers/parser'
+
+# These requires allow downstream libraries to build their own antlers nodes.
+require_relative 'interfaces/branch_node'
+require_relative 'interfaces/leaf_node'
 
 module Antlers
-  class << self
-    def ast(template:, namespace: nil)
-      return template unless template.include?('<{') || template.include?('{')
+  DEFAULT_ELEMENTS = [:root, :html, :form, :for, :if, :prop, :slot, :yield, :var]
 
-      sequence = Lexer.new.parse(template)
-      Parser.new(namespace:).parse(sequence:)
+  class << self
+    def ast(template:, namespace: nil, elements: Elements[*DEFAULT_ELEMENTS])
+      sequence = Lexer.new(lexeme_types: elements[:lexeme]).parse(template:)
+      Parser.new(namespace:, node_types: elements[:node]).parse(sequence:, template:)
     end
 
     def render(ast:, current_binding:, parent_binding: nil, slot_node: nil)

data/lib/interfaces/antler_node.rb

@@ -4,6 +4,9 @@ module Antlers
   class AntlerNode
     attr_reader :name
 
+    DEF_KEY = nil
+    END_KEY = nil
+
     def initialize(name:)
       @name = name
     end
@@ -12,7 +15,21 @@ module Antlers
       raise NotImplementedError
     end
 
-    # Consider instance a value object on comparison.
+    def end_name
+      'level_1'
+    end
+
+    class << self
+      def match?(segment:)
+        raise NotImplementedError
+      end
+
+      def build(segment:, namespace:)
+        raise NotImplementedError
+      end
+    end
+
+    # Compare instance as a value object.
     def ==(other) = other.class == self.class
     def eql?(other) = self == other
     def hash = [self.class].hash

data/lib/interfaces/branch_node.rb

@@ -16,8 +16,7 @@ module Antlers
       output = ''
 
       @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:) : child) || ''
+        output += child.render(current_binding:, parent_binding:, slot_node:) || ''
       end
 
       output

data/lib/interfaces/lexeme.rb

@@ -6,8 +6,31 @@ module Antlers
 
     def match?(name: nil, keywords: {}) = false
 
-    def lexeme(name:, props:, keywords:)
+    def lexeme(name:, props:, keywords:, segment: nil, raw: false)
       raise NotImplementedError
     end
+
+    private
+
+    def props(props)
+      odd_props = props.join(' ').split(/(=)|\s/)
+
+      return {} unless odd_props.any?
+
+      props = {}
+      until odd_props.empty?
+        prop = odd_props.shift
+        value = nil
+
+        if odd_props.first == '='
+          odd_props.shift
+          value = odd_props.shift
+        end
+
+        props[prop.to_sym] = value
+      end
+
+      props
+    end
   end
 end

data/lib/lexemes/prop_lexeme.rb

@@ -16,28 +16,5 @@ module Antlers
       prop[:props] = props(props) unless props.empty?
       prop
     end
-
-    private
-
-    def props(props)
-      odd_props = props.join(' ').split(/(=)|\s/)
-
-      return {} unless odd_props.any?
-
-      props = {}
-      until odd_props.empty?
-        prop = odd_props.shift
-        value = nil
-
-        if odd_props.first == '='
-          odd_props.shift
-          value = odd_props.shift
-        end
-
-        props[prop.to_sym] = value
-      end
-
-      props
-    end
   end
 end

data/lib/lexemes/var_lexeme.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/lexeme'
+require_relative '../support/queries'
+
+module Antlers
+  module VarLexeme
+    include Lexeme
+    extend Queries
+    extend self
+
+    # Variables are special and are matched by the lexer.
+    def match?(**)
+      false
+    end
+
+    def lexeme(segment:, raw:, **)
+      # String is already interpolated or not depending on user input on the template layer, now we store it without those template quotes.
+      segment = segment[1..-2] if Queries.user_defined_string?(segment)
+
+      return { raw_var: segment } if raw
+
+      { var: segment }
+    end
+  end
+end

data/lib/modules/variables.rb

@@ -6,7 +6,7 @@ module Antlers
   module Variables
     extend Queries
 
-    # Evaluation limited to the following for security and to prevent a templating language becoming a programming language.
+    # Evaluation limited to the following for security and to stop a templating language becoming a programming language.
     #  1. An instance variable
     #  2. A method call/local variable
     #  3. A method chain

data/lib/nodes/for_node.rb

@@ -9,6 +9,9 @@ module Antlers
     include Props
     include Variables
 
+    DEF_KEY = :for_def
+    END_KEY = :for_end
+
     def initialize(name:, items:, value:, key: nil, props: [], children: [])
       super(name:, props:, children:)
 
@@ -28,12 +31,22 @@ module Antlers
         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:) : child) || ''
+          output += child.render(current_binding:, parent_binding:, slot_node:) || ''
         end
       end
 
       output
     end
+
+    class << self
+      def match?(segment:)
+        segment[DEF_KEY]
+      end
+
+      def build(segment:, **)
+        value, key, items = segment.values_at(DEF_KEY, :key, :in)
+        new(name: value, key:, value:, items:)
+      end
+    end
   end
 end

data/lib/nodes/form_node.rb

@@ -9,6 +9,9 @@ module Antlers
     include Props
     include Variables
 
+    DEF_KEY = :form_def
+    END_KEY = :form_end
+
     def initialize(name:, action: nil, method: 'POST', props: [], children: [])
       super(name:, props:, children:)
 
@@ -20,12 +23,24 @@ module Antlers
       output = "<form action='#{@action}' method='#{@method}'>"
 
       @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:) : child) || ''
+        output += child.render(current_binding:, parent_binding:, slot_node:) || ''
       end
 
       output += '</form>'
       output
     end
+
+    class << self
+      def match?(segment:)
+        segment[DEF_KEY]
+      end
+
+      def build(segment:, **)
+        action, method = segment.values_at(DEF_KEY, :method)
+        return new(name: action, action:, method:) if method
+
+        new(name: action, action:)
+      end
+    end
   end
 end

data/lib/nodes/html_node.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/leaf_node'
+
+module Antlers
+  class HTMLNode < LeafNode
+    def initialize(html:)
+      super(name: nil)
+
+      @html = html
+    end
+
+    def render(**)
+      @html
+    end
+
+    class << self
+      def match?(segment:)
+        segment.is_a?(String)
+      end
+
+      def build(segment:, **)
+        new(html: segment)
+      end
+    end
+  end
+end

data/lib/nodes/if_node.rb

@@ -9,6 +9,9 @@ module Antlers
     include Props
     include Variables
 
+    DEF_KEY = :if_def
+    END_KEY = :if_end
+
     def initialize(name:, value:, props: [], children: [])
       super(name:, props:, children:)
 
@@ -20,12 +23,21 @@ module Antlers
 
       if evaluate(name: @value, current_binding:)
         @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:) : child) || ''
+          output += child.render(current_binding:, parent_binding:, slot_node:) || ''
         end
       end
 
       output
     end
+
+    class << self
+      def match?(segment:)
+        segment[DEF_KEY]
+      end
+
+      def build(segment:, **)
+        new(name: segment[DEF_KEY], value: segment[DEF_KEY])
+      end
+    end
   end
 end

data/lib/nodes/prop_node.rb

@@ -30,6 +30,16 @@ module Antlers
       render_args(class_proxy:, instance:, event:, props:)
     end
 
+    class << self
+      def match?(segment:)
+        segment[:prop]
+      end
+
+      def build(segment:, namespace:, **)
+        new(name: segment[:prop], props: segment[:props], namespace:)
+      end
+    end
+
     private
 
     def create_instance(class_proxy:, klass:, event:, props:)

data/lib/nodes/root_node.rb

@@ -7,5 +7,15 @@ module Antlers
     def initialize(name: :root_node, children: [])
       super(name:, children:)
     end
+
+    class << self
+      def match?(**)
+        false
+      end
+
+      def build(**)
+        new()
+      end
+    end
   end
 end

data/lib/nodes/slot_node.rb

@@ -7,11 +7,14 @@ require_relative '../modules/props'
 module Antlers
   class SlotNode < BranchNode
     include Namespace
-    include Props # Immediate parent ancestor which props are passed to.
+    include Props # The immediate ancestor which props are passed to.
+
+    DEF_KEY = :slot_def
+    END_KEY = :slot_end
 
     attr_accessor :children
 
-    def initialize(name:, namespace:, props: [], children: [], **)
+    def initialize(name:, namespace:, props: {}, children: [], **)
       super(name:, props:, children:)
 
       @namespace = namespace
@@ -30,5 +33,19 @@ module Antlers
 
       props.empty? ? instance.render(event:) : instance.render(event:, **props)
     end
+
+    def end_name
+      @name
+    end
+
+    class << self
+      def match?(segment:)
+        segment[DEF_KEY]
+      end
+
+      def build(segment:, namespace:, **)
+        new(name: segment[DEF_KEY], props: segment[:props], namespace:)
+      end
+    end
   end
 end

data/lib/nodes/var_node.rb

@@ -25,5 +25,15 @@ module Antlers
 
       ERB::Util.html_escape(result)
     end
+
+    class << self
+      def match?(segment:)
+        segment[:var] || segment[:raw_var]
+      end
+
+      def build(segment:, **)
+        new(value: segment[:var] || segment[:raw_var], raw: !!segment[:raw_var])
+      end
+    end
   end
 end

data/lib/nodes/yield_node.rb

@@ -8,20 +8,25 @@ module Antlers
       super(name:)
     end
 
-    # Renders the children of the parent node in the binding of the parent.
-    def render(current_binding: nil, parent_binding: nil, slot_node: nil)
+    # Render the children in the binding of the parent.
+    def render(current_binding: nil, parent_binding:, slot_node:)
       output = ''
 
       slot_node.children.each do |child|
-        # Antlers nodes respond to "render", whereas HTML is stored as a string and output as is.
-        if child.respond_to?(:render) # rubocop:disable Style/ConditionalAssignment
-          output += child.render(current_binding: parent_binding, parent_binding: nil, slot_node: nil)
-        else
-          output += child || ''
-        end
+        output += child.render(current_binding: parent_binding, parent_binding:, slot_node:) || ''
       end
 
       output
     end
+
+    class << self
+      def match?(segment:)
+        segment[:slot]
+      end
+
+      def build(segment:, **)
+        new(name: segment[:slot])
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: antlers
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.9.0
 platform: ruby
 authors:
 - maedi
@@ -51,6 +51,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: plugs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A templating language embedded within HTML that is itself embedded within
   Ruby/RBX
 email:
@@ -60,7 +74,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/antlers.rb
-- lib/factories/node_factory.rb
+- lib/antlers/elements.rb
+- lib/antlers/lexer.rb
+- lib/antlers/parser.rb
+- lib/antlers/version.rb
 - lib/interfaces/antler_node.rb
 - lib/interfaces/branch_node.rb
 - lib/interfaces/leaf_node.rb
@@ -70,22 +87,21 @@ files:
 - lib/lexemes/if_lexeme.rb
 - lib/lexemes/prop_lexeme.rb
 - lib/lexemes/slot_lexeme.rb
+- lib/lexemes/var_lexeme.rb
 - lib/lexemes/yield_lexeme.rb
-- lib/lexer.rb
 - lib/modules/namespace.rb
 - lib/modules/props.rb
 - lib/modules/variables.rb
 - lib/nodes/for_node.rb
 - lib/nodes/form_node.rb
+- lib/nodes/html_node.rb
 - lib/nodes/if_node.rb
 - lib/nodes/prop_node.rb
 - lib/nodes/root_node.rb
 - lib/nodes/slot_node.rb
 - lib/nodes/var_node.rb
 - lib/nodes/yield_node.rb
-- lib/parser.rb
 - lib/support/queries.rb
-- lib/version.rb
 homepage: https://github.com/raindeer-rb/antlers
 licenses: []
 metadata:

data/lib/factories/node_factory.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../nodes/if_node'
-require_relative '../nodes/for_node'
-require_relative '../nodes/form_node'
-require_relative '../nodes/prop_node'
-require_relative '../nodes/slot_node'
-require_relative '../nodes/var_node'
-require_relative '../nodes/yield_node'
-
-module Antlers
-  class NodeFactory
-    def initialize(namespace:)
-      @namespace = namespace
-    end
-
-    def if_node(segment:)
-      IfNode.new(name: segment[:if_def], value: segment[:if_def])
-    end
-
-    def for_node(segment:)
-      value, key, items = segment.values_at(:for_def, :key, :in)
-      ForNode.new(name: value, key:, value:, items:)
-    end
-
-    def form_node(segment:)
-      action, method = segment.values_at(:form_def, :method)
-      return FormNode.new(name: action, action:, method:) if method
-
-      FormNode.new(name: action, action:)
-    end
-
-    def prop_node(segment:)
-      PropNode.new(name: segment[:prop], props: segment[:props], namespace:)
-    end
-
-    def slot_node(segment:)
-      SlotNode.new(name: segment[:slot_def], props: segment[:props], namespace:)
-    end
-
-    def var_node(segment:)
-      VarNode.new(value: segment[:var])
-    end
-
-    def raw_var_node(segment:)
-      VarNode.new(value: segment[:raw_var], raw: true)
-    end
-
-    def yield_node(segment:)
-      YieldNode.new(name: segment[:slot])
-    end
-
-    private
-
-    attr_reader :namespace
-  end
-end

data/lib/lexer.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'lexemes/for_lexeme'
-require_relative 'lexemes/form_lexeme'
-require_relative 'lexemes/if_lexeme'
-require_relative 'lexemes/prop_lexeme'
-require_relative 'lexemes/slot_lexeme'
-require_relative 'lexemes/yield_lexeme'
-require_relative 'support/queries'
-
-module Antlers
-  extend Queries
-
-  class LexerParseError < StandardError; end
-
-  LEXEMES = [
-    # FormLexeme must be ordered before ForLexeme for regex to work.
-    Antlers::FormLexeme,
-    Antlers::ForLexeme,
-    Antlers::IfLexeme,
-    Antlers::PropLexeme,
-    Antlers::SlotLexeme,
-    Antlers::YieldLexeme,
-  ]
-
-  class Lexer
-    def initialize
-      @delimiters = ['<{', '}>', '{', '}']
-      @keywords = LEXEMES.flat_map { |lexeme| lexeme.const_get(:KEYWORDS) }
-      @cursor = 0
-    end
-
-    def parse(template)
-      @cursor = 0
-      sequence = []
-
-      # Split on delimiters and retain capture groups.
-      segments = template.split(/(#{Regexp.union(@delimiters)})/).map(&:strip)
-
-      until segments[@cursor].nil?
-        if (antlers_segment = antlers_segment(segments:))
-          sequence << antlers_lexeme(antlers_segment:, segments:)
-          # Skipping: ['{', 'expression', '}']
-          # Skipping: ['<{', 'name + props + keywords', '}>']
-          @cursor += 3
-        else
-          segment = segments[@cursor]
-          sequence << segment unless segment.empty?
-          @cursor += 1
-        end
-      end
-
-      sequence
-    end
-
-    private
-
-    def antlers_segment(segments:)
-      next_segment = segments[@cursor + 1]
-      return nil unless next_segment && (segments[@cursor] == '<{' || brackets?(segments:))
-
-      next_segment
-    end
-
-    def antlers_lexeme(antlers_segment:, segments:)
-      return var(antlers_segment:) if brackets?(segments:)
-
-      name, props, keywords = parse_segment(antlers_segment:)
-
-      lexeme = LEXEMES.find { it.match?(name:, keywords:) }
-      return lexeme.lexeme(name:, props:, keywords:) if lexeme
-      return var(antlers_segment:, raw: true) if deerheads?(segments:)
-
-      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, parse_keywords(keywords:)]
-    end
-
-    def parse_keywords(keywords:)
-      key_values = {}
-
-      while (keyword = keywords.shift)
-        keyword.strip!
-        value = keyword.end_with?(':') && value?(keywords.first.strip) ? keywords.shift.strip : nil
-        key_values[keyword] = value
-      end
-
-      key_values
-    end
-
-    def value?(string)
-      !(string.start_with?(':') || string.end_with?(':'))
-    end
-
-    # TODO: Refactor every constant, match and result method into its own class. Loop through every class and return the first match.
-
-    def brackets?(segments:)
-      first, _, last = segments[@cursor..@cursor + 3].map(&:strip)
-      first == '{' && last == '}'
-    end
-
-    def deerheads?(segments:)
-      first, _, last = segments[@cursor..@cursor + 3].map(&:strip)
-      first == '<{' && last == '}>'
-    end
-
-    def var(antlers_segment:, raw: false)
-      # String is already interpolated or not depending on user input on the template layer, now we store it without those template quotes.
-      antlers_segment = antlers_segment[1..-2] if Queries.user_defined_string?(antlers_segment)
-
-      return { raw_var: antlers_segment } if raw
-
-      { var: antlers_segment }
-    end
-  end
-end

data/lib/parser.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'factories/node_factory'
-require_relative 'nodes/root_node'
-
-module Antlers
-  class Parser
-    def initialize(namespace: nil)
-      @factory = NodeFactory.new(namespace:)
-    end
-
-    def parse(sequence:, id: :root_node)
-      branch(node: RootNode.new(name: id), sequence:)
-    end
-
-    def branch(node:, sequence:) # rubocop:disable Metrics/AbcSize
-      until sequence.empty?
-        segment = sequence.shift
-
-        if segment.is_a?(String)
-          node.children << segment
-        elsif segment[:var]
-          node.children << @factory.var_node(segment:)
-        elsif segment[:raw_var]
-          node.children << @factory.raw_var_node(segment:)
-        elsif segment[:prop]
-          node.children << @factory.prop_node(segment:)
-        elsif segment[:slot]
-          node.children << @factory.yield_node(segment:)
-        elsif segment[:slot_def]
-          slot_node = @factory.slot_node(segment:)
-          node.children << slot_node
-          sub_branch(node: slot_node, sequence:, end_key: :slot_end, end_name: slot_node.name)
-        elsif segment[:if_def]
-          if_node = @factory.if_node(segment:)
-          node.children << if_node
-          sub_branch(node: if_node, sequence:, end_key: :if_end, end_name: 'level_1')
-        elsif segment[:for_def]
-          for_node = @factory.for_node(segment:)
-          node.children << for_node
-          sub_branch(node: for_node, sequence:, end_key: :for_end, end_name: 'level_1')
-        elsif segment[:form_def]
-          form_node = @factory.form_node(segment:)
-          node.children << form_node
-          sub_branch(node: form_node, sequence:, end_key: :form_end, end_name: 'level_1')
-        end
-      end
-
-      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