antlers 0.8.0 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0d88855d8351d4ce9b4ebf2bfeaf0fc05faef8a33a882ffd206fa1c8241ec9e
-  data.tar.gz: e72f72db347e9f0f442e0a15cb4dce3f2c7405bf1bd7da6b33ab919a7003785b
+  metadata.gz: e0dbec268b4fe0b7966b5f7161c61b16c155695ae10ab9c16d66ea67462348f4
+  data.tar.gz: a5ef4b1479077100df98ebf33a16379cf934cecbb980184008b5ecb86c3bcbb0
 SHA512:
-  metadata.gz: 6f1e6d6f8f512d327ee25068a3286d8f1e557407bf99f4ec274cd8c8e7336ef9c2d9db9980e66d13ce58b8055d07f6908108afcb8cd91d2da65224ac567946d4
-  data.tar.gz: 27520e044188ae13cde780d7438286e510dae3874cd2218debf2901a1b3c7e9909847c44ae38ce4353e8b0482afa2516fa47857836070a58e8683934865a58c7
+  metadata.gz: e8e4537ad73ba6356a5ce6a4632da46113374c21e6449ba9f744f9166e47ec93fcb619cab17d536d0b6413145c11e91f726b0a48e6b628af35c3662ec55e2970
+  data.tar.gz: 34b6b683e8ca4d3b736efa8684d049064032abf7ca081d2791370e0135b8ff7adc02e67dcf22a3c32dbe616b84302882b5346cc28c0915145e5278252cab5048

data/lib/antlers/elements.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'plugs'
+
+module Antlers
+  class Elements
+    include Plugs
+
+    plug(:root) do
+      plug(:node) do
+        lazy do
+          require_relative '../nodes/root_node'
+          RootNode
+        end
+      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
+    end
+  end
+end

data/lib/antlers/lexer.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative '../support/queries'
+
+module Antlers
+  extend Queries
+
+  class LexerError < StandardError; end
+
+  class Lexer
+    def initialize(lexeme_types:)
+      @delimiters = ['<{', '}>', '{', '}']
+      @lexeme_types = lexeme_types
+      @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 (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 = @lexeme_types.find { it.match?(name:, keywords:) }
+      return lexeme.lexeme(name:, props:, keywords:) if lexeme
+      return var(antlers_segment:, raw: true) if deerheads?(segments:)
+
+      raise LexerError, "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/antlers/parser.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Antlers
+  class Parser
+    class ParserError < StandardError; end
+
+    def initialize(namespace: nil, node_types:)
+      @namespace = namespace
+      @node_types = node_types
+    end
+
+    def parse(sequence:, id: :root_node)
+      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)
+        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.0'
+  VERSION = '0.8.2'
 end

data/lib/antlers.rb

@@ -1,15 +1,22 @@
 # 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
+  DEFAULT_ELEMENTS = [:root, :html, :form, :for, :if, :prop, :slot, :yield, :var]
+
   class << self
-    def ast(template:, namespace: nil)
+    def ast(template:, namespace: nil, elements: Elements[*DEFAULT_ELEMENTS])
       return template unless template.include?('<{') || template.include?('{')
 
-      sequence = Lexer.new.parse(template)
-      Parser.new(namespace:).parse(sequence:)
+      sequence = Lexer.new(lexeme_types: elements[:lexeme].to_a).parse(template:)
+      Parser.new(namespace:, node_types: elements[:node].to_a).parse(sequence:)
     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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Antlers
+  module Lexeme
+    KEYWORDS = []
+
+    def match?(name: nil, keywords: {}) = false
+
+    def lexeme(name:, props:, keywords:)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/lexemes/for_lexeme.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/lexeme'
+
+module Antlers
+  module ForLexeme
+    include Lexeme
+    extend self
+
+    KEYWORDS = ['for:', 'in:', ':for'].freeze
+
+    def match?(keywords:, **)
+      KEYWORDS.include?(keywords.keys.first)
+    end
+
+    def lexeme(keywords:, **)
+      if keywords['for:']
+        *key, value = keywords['for:'].split(',').map(&:strip)
+        for_def = { for_def: value, in: keywords['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
+  end
+end

data/lib/lexemes/form_lexeme.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/lexeme'
+
+module Antlers
+  module FormLexeme
+    include Lexeme
+    extend self
+
+    KEYWORDS = ['form:', ':form'].freeze
+
+    def match?(keywords:, **)
+      KEYWORDS.include?(keywords.keys.first)
+    end
+
+    def lexeme(keywords:, **)
+      if keywords.key?('form:')
+        action = keywords['form:'] ? keywords['form:'][1...-1] : nil
+        return { form_def: action }
+      end
+
+      { form_end: 'level_1' }
+    end
+  end
+end

data/lib/lexemes/if_lexeme.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/lexeme'
+
+module Antlers
+  module IfLexeme
+    include Lexeme
+    extend self
+
+    KEYWORDS = ['if:', ':if'].freeze
+
+    def match?(keywords:, **)
+      KEYWORDS.include?(keywords.keys.first)
+    end
+
+    def lexeme(keywords:, **)
+      return { if_def: keywords['if:'] } if keywords.key?('if:')
+
+      { if_end: 'level_1' }
+    end
+  end
+end

data/lib/lexemes/prop_lexeme.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/lexeme'
+
+module Antlers
+  module PropLexeme
+    include Lexeme
+    extend self
+
+    def match?(name:, **)
+      name && [*'A'..'Z'].include?(name[0]) && !(name.start_with?(':') || name.end_with?(':'))
+    end
+
+    def lexeme(name:, props:, **)
+      prop = { prop: name }
+      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/slot_lexeme.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/lexeme'
+
+module Antlers
+  module SlotLexeme
+    include Lexeme
+    extend self
+
+    KEYWORDS = ['slot:', ':slot'].freeze
+
+    def match?(name:, **)
+      name && (name.start_with?(':') || name.end_with?(':'))
+    end
+
+    def lexeme(name:, props:, **)
+      if name.end_with?(':')
+        slot_def = { slot_def: name.delete_suffix(':') }
+        slot_def[:props] = props(props) unless props.empty?
+        return slot_def
+      end
+
+      { slot_end: name.delete_prefix(':') }
+    end
+  end
+end

data/lib/lexemes/yield_lexeme.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/lexeme'
+
+module Antlers
+  module YieldLexeme
+    include Lexeme
+    extend self
+
+    def match?(keywords:, **)
+      keywords.keys.include?(':slot')
+    end
+
+    def lexeme(**)
+      { slot: :default }
+    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

@@ -23,18 +23,29 @@ module Antlers
       # 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: @name)
       class_proxy = Lowkey[klass.to_s].first[klass.to_s]
-      instance = create_instance(class_proxy:, klass:, event:)
 
+      instance = create_instance(class_proxy:, klass:, event:, props:)
       return instance.render_template(event:, parent_binding:, props:) if klass.template
 
       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:)
+    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

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,7 +7,10 @@ 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
 
@@ -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.0
+  version: 0.8.2
 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,25 +74,33 @@ 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
-- lib/lexer.rb
+- lib/interfaces/lexeme.rb
+- lib/lexemes/for_lexeme.rb
+- lib/lexemes/form_lexeme.rb
+- lib/lexemes/if_lexeme.rb
+- lib/lexemes/prop_lexeme.rb
+- lib/lexemes/slot_lexeme.rb
+- lib/lexemes/yield_lexeme.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,204 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'support/queries'
-
-module Antlers
-  extend Queries
-
-  class LexerParseError < StandardError; end
-
-  class Lexer
-    IF_KEYWORDS = ['if:', ':if'].freeze
-    FOR_KEYWORDS = ['for:', 'in:', ':for'].freeze
-    FORM_KEYWORDS = ['form:', ':form'].freeze
-
-    def initialize
-      @delimiters = ['<{', '}>', '{', '}']
-      @keywords = [*IF_KEYWORDS, *FORM_KEYWORDS, *FOR_KEYWORDS, 'slot:', ':slot']
-      @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:)
-
-      return slot_yield if slot_yield?(keywords:)
-      return slot(name:, props:) if slot?(name)
-      return prop(name:, props:) if prop?(name)
-      return if_block(keywords:) if if_block?(keywords:)
-      return for_loop(keywords:) if for_loop?(keywords:)
-      return form(keywords:) if form?(keywords:)
-      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 if_block?(keywords:)
-      IF_KEYWORDS.include?(keywords.keys.first)
-    end
-
-    def for_loop?(keywords:)
-      FOR_KEYWORDS.include?(keywords.keys.first)
-    end
-
-    def form?(keywords:)
-      FORM_KEYWORDS.include?(keywords.keys.first)
-    end
-
-    def slot?(name)
-      name && (name.start_with?(':') || name.end_with?(':'))
-    end
-
-    def slot_yield?(keywords:)
-      keywords.keys.include?(':slot')
-    end
-
-    def prop?(name)
-      name && [*'A'..'Z'].include?(name[0])
-    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
-
-    def if_block(keywords:)
-      return { if_def: keywords['if:'] } if keywords.key?('if:')
-
-      { if_end: 'level_1' }
-    end
-
-    def for_loop(keywords:)
-      if keywords['for:']
-        *key, value = keywords['for:'].split(',').map(&:strip)
-        for_def = { for_def: value, in: keywords['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 form(keywords:)
-      if keywords.key?('form:')
-        action = keywords['form:'] ? keywords['form:'][1...-1] : nil
-        return { form_def: action }
-      end
-
-      { form_end: 'level_1' }
-    end
-
-    def slot(name:, props:)
-      if name.end_with?(':')
-        slot_def = { slot_def: name.delete_suffix(':') }
-        slot_def[:props] = props(props) unless props.empty?
-        return slot_def
-      end
-
-      { slot_end: name.delete_prefix(':') }
-    end
-
-    def slot_yield
-      { slot: :default }
-    end
-
-    def prop(name:, props:)
-      prop = { prop: name }
-      prop[:props] = props(props) unless props.empty?
-      prop
-    end
-
-    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/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