antlers 0.8.1 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d3bcf6e14ade37294793b87b3ab3ab152e519f8c081a130644b0d28d489b63b
-  data.tar.gz: d9886a3044fb8654b37f111a9536ba7dfef4945c26fb08112e400ab14e76d8e7
+  metadata.gz: e0dbec268b4fe0b7966b5f7161c61b16c155695ae10ab9c16d66ea67462348f4
+  data.tar.gz: a5ef4b1479077100df98ebf33a16379cf934cecbb980184008b5ecb86c3bcbb0
 SHA512:
-  metadata.gz: a4179e613ca96ea49fdbc7d991a627a45640182ae5aaa5f01dc935396586ba8b583df469113c26c7a139308956bc18980cdbd04877c73a9b7cd14617682dd2d3
-  data.tar.gz: 698769c0d6bfd0e9872c5022f72555290acff3888615f44061ed10847af8f97af58477c35059678c2e02a2bdafc16d3f06ff514ab80aa539abc2de7cbfeda6bd
+  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/{lexer.rb → antlers/lexer.rb}

@@ -1,36 +1,21 @@
 # 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'
+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 LexerError < StandardError; end
 
   class Lexer
-    def initialize
+    def initialize(lexeme_types:)
       @delimiters = ['<{', '}>', '{', '}']
-      @keywords = LEXEMES.flat_map { |lexeme| lexeme.const_get(:KEYWORDS) }
+      @lexeme_types = lexeme_types
+      @keywords = @lexeme_types.flat_map { |lexeme| lexeme.const_get(:KEYWORDS) }
       @cursor = 0
     end
 
-    def parse(template)
+    def parse(template:)
       @cursor = 0
       sequence = []
 
@@ -67,11 +52,11 @@ module Antlers
 
       name, props, keywords = parse_segment(antlers_segment:)
 
-      lexeme = LEXEMES.find { it.match?(name:, keywords:) }
+      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 LexerParseError, "Unrecognised syntax: '#{antlers_segment}'"
+      raise LexerError, "Unrecognised syntax: '#{antlers_segment}'"
     end
 
     def parse_segment(antlers_segment:)

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.1'
+  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/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,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.1
+  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,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
@@ -71,21 +88,19 @@ files:
 - lib/lexemes/prop_lexeme.rb
 - lib/lexemes/slot_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/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