antlers 0.8.2 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0dbec268b4fe0b7966b5f7161c61b16c155695ae10ab9c16d66ea67462348f4
-  data.tar.gz: a5ef4b1479077100df98ebf33a16379cf934cecbb980184008b5ecb86c3bcbb0
+  metadata.gz: f16d22b587d7dbdc07a0a51fc19032271be9347e90eb09c77541a56099f8088f
+  data.tar.gz: b1437b4cac8a748fc23fc6eaf06c07e5d3111d63d5100651afb9195f488dacfb
 SHA512:
-  metadata.gz: e8e4537ad73ba6356a5ce6a4632da46113374c21e6449ba9f744f9166e47ec93fcb619cab17d536d0b6413145c11e91f726b0a48e6b628af35c3662ec55e2970
-  data.tar.gz: 34b6b683e8ca4d3b736efa8684d049064032abf7ca081d2791370e0135b8ff7adc02e67dcf22a3c32dbe616b84302882b5346cc28c0915145e5278252cab5048
+  metadata.gz: ecc5de204a45f9cda60f03aeefc49aee735fc9aa3da5fd20b1d12959497bfb4683ab299bd64d4ae8795b3296ab9e018c8b8eb70672f3788aeeeaf8355f03d07e
+  data.tar.gz: 0b14edede169971914c9958f4b3369c361271566d36c883dd3c1774ef968e8299d2d95c58a90e921ea2bbae5d70f4a2634c8ce00217e058c2ee6c71a9ec3a42f

data/lib/antlers/elements.rb

@@ -8,10 +8,8 @@ module Antlers
 
     plug(:root) do
       plug(:node) do
-        lazy do
-          require_relative '../nodes/root_node'
-          RootNode
-        end
+        require_relative '../nodes/root_node'
+        RootNode
       end
     end
 
@@ -127,6 +125,13 @@ module Antlers
           VarNode
         end
       end
+
+      plug(:lexeme) do
+        lazy do
+          require_relative '../lexemes/var_lexeme'
+          VarLexeme
+        end
+      end
     end
   end
 end

data/lib/antlers/lexer.rb

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
-require_relative '../support/queries'
+require_relative '../lexemes/var_lexeme'
 
 module Antlers
-  extend Queries
-
   class LexerError < StandardError; end
 
   class Lexer
     def initialize(lexeme_types:)
-      @delimiters = ['<{', '}>', '{', '}']
-      @lexeme_types = 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
@@ -23,8 +25,8 @@ module Antlers
       segments = template.split(/(#{Regexp.union(@delimiters)})/).map(&:strip)
 
       until segments[@cursor].nil?
-        if (antlers_segment = antlers_segment(segments:))
-          sequence << antlers_lexeme(antlers_segment:, segments:)
+        if (segment = antlers_segment(segments:))
+          sequence << antlers_lexeme(segment:, segments:)
           # Skipping: ['{', 'expression', '}']
           # Skipping: ['<{', 'name + props + keywords', '}>']
           @cursor += 3
@@ -47,20 +49,21 @@ module Antlers
       next_segment
     end
 
-    def antlers_lexeme(antlers_segment:, segments:)
-      return var(antlers_segment:) if brackets?(segments:)
+    def antlers_lexeme(segment:, segments:)
+      name, props, keywords = parse_antlers_segment(segment:)
 
-      name, props, keywords = parse_segment(antlers_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(antlers_segment:, raw: true) if deerheads?(segments:)
 
-      raise LexerError, "Unrecognised syntax: '#{antlers_segment}'"
+      return @var_lexeme.lexeme(segment:, raw: true) if @var_lexeme && deerheads?(segments:)
+
+      raise LexerError, "Unrecognised syntax: '#{segment}'"
     end
 
-    def parse_segment(antlers_segment:)
-      name_and_props, *keywords = antlers_segment.split(/(#{Regexp.union(@keywords)})/)
+    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
@@ -81,8 +84,6 @@ module Antlers
       !(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 == '}'
@@ -92,14 +93,5 @@ module Antlers
       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

@@ -4,12 +4,15 @@ module Antlers
   class Parser
     class ParserError < StandardError; end
 
-    def initialize(namespace: nil, node_types:)
+    def initialize(node_types:, namespace: nil)
+      @node_types = node_types.to_a
       @namespace = namespace
-      @node_types = node_types
+      @template = nil
     end
 
-    def parse(sequence:, id: :root_node)
+    def parse(sequence:, template: nil, id: :root_node)
+      @template = template
+
       branch(node: RootNode.new(name: id), sequence:)
     end
 
@@ -20,7 +23,7 @@ module Antlers
         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)
+        child = child_class.build(segment:, namespace: @namespace, template: @template)
         node.children << child
 
         if (end_key = child_class::END_KEY)

data/lib/antlers/version.rb

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

data/lib/antlers.rb

@@ -13,10 +13,8 @@ module Antlers
 
   class << self
     def ast(template:, namespace: nil, elements: Elements[*DEFAULT_ELEMENTS])
-      return template unless template.include?('<{') || template.include?('{')
-
-      sequence = Lexer.new(lexeme_types: elements[:lexeme].to_a).parse(template:)
-      Parser.new(namespace:, node_types: elements[:node].to_a).parse(sequence:)
+      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/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/nodes/prop_node.rb

@@ -35,7 +35,7 @@ module Antlers
         segment[:prop]
       end
 
-      def build(segment:, namespace:)
+      def build(segment:, namespace:, **)
         new(name: segment[:prop], props: segment[:props], namespace:)
       end
     end

data/lib/nodes/slot_node.rb

@@ -14,7 +14,7 @@ module Antlers
 
     attr_accessor :children
 
-    def initialize(name:, namespace:, props: [], children: [], **)
+    def initialize(name:, namespace:, props: {}, children: [], **)
       super(name:, props:, children:)
 
       @namespace = namespace
@@ -43,7 +43,7 @@ module Antlers
         segment[DEF_KEY]
       end
 
-      def build(segment:, namespace:)
+      def build(segment:, namespace:, **)
         new(name: segment[DEF_KEY], props: segment[:props], namespace:)
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: antlers
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.9.0
 platform: ruby
 authors:
 - maedi
@@ -87,6 +87,7 @@ 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/modules/namespace.rb
 - lib/modules/props.rb