antlers 0.7.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e01a292dd41ce2f99fd7a6bdd5a375d3d2c36a3e4d5280ccaaaf91be9bcde38
-  data.tar.gz: 84227a375d02da8663bfdf04efaf496be097f7898840d25bc4f02b0c62bc2fff
+  metadata.gz: 8d3bcf6e14ade37294793b87b3ab3ab152e519f8c081a130644b0d28d489b63b
+  data.tar.gz: d9886a3044fb8654b37f111a9536ba7dfef4945c26fb08112e400ab14e76d8e7
 SHA512:
-  metadata.gz: c449e355a550e43aa65e1e00ba482e858b07a1fb0f983325808a538769d6e8eb78ed5dad4a5a3fdd3f24348db7001e59876894b2a98d882e38dd9fa10078104a
-  data.tar.gz: 5f71032b3da08b3675f52045f513a810bf2228a1c3308ce7dcde2c53596f7525060dbbd34d05ffb1b04cf8672c045a9e117b727f58a972361a32603e53c2d6ff
+  metadata.gz: a4179e613ca96ea49fdbc7d991a627a45640182ae5aaa5f01dc935396586ba8b583df469113c26c7a139308956bc18980cdbd04877c73a9b7cd14617682dd2d3
+  data.tar.gz: 698769c0d6bfd0e9872c5022f72555290acff3888615f44061ed10847af8f97af58477c35059678c2e02a2bdafc16d3f06ff514ab80aa539abc2de7cbfeda6bd

data/lib/factories/node_factory.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative '../nodes/if_node'
 require_relative '../nodes/for_node'
 require_relative '../nodes/form_node'
 require_relative '../nodes/prop_node'
@@ -13,6 +14,10 @@ module Antlers
       @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:)
@@ -37,6 +42,10 @@ module Antlers
       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

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

@@ -1,5 +1,11 @@
 # 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
@@ -7,13 +13,20 @@ module Antlers
 
   class LexerParseError < StandardError; end
 
-  class Lexer
-    FOR_KEYWORDS = ['for:', 'in:', ':for'].freeze
-    FORM_KEYWORDS = ['form:', ':form'].freeze
+  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 = ['if:', *FORM_KEYWORDS, *FOR_KEYWORDS, 'slot:', ':slot']
+      @keywords = LEXEMES.flat_map { |lexeme| lexeme.const_get(:KEYWORDS) }
       @cursor = 0
     end
 
@@ -44,21 +57,19 @@ module Antlers
 
     def antlers_segment(segments:)
       next_segment = segments[@cursor + 1]
-      return nil unless next_segment && (segments[@cursor] == '<{' || var?(segments:))
+      return nil unless next_segment && (segments[@cursor] == '<{' || brackets?(segments:))
 
       next_segment
     end
 
     def antlers_lexeme(antlers_segment:, segments:)
-      return var(antlers_segment:) if var?(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 for_loop(keywords:) if for_loop?(keywords:)
-      return form(keywords:) if form?(keywords:)
+      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
@@ -87,98 +98,23 @@ module Antlers
 
     # TODO: Refactor every constant, match and result method into its own class. Loop through every class and return the first match.
 
-    def var?(segments:)
+    def brackets?(segments:)
       first, _, last = segments[@cursor..@cursor + 3].map(&:strip)
       first == '{' && last == '}'
     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])
+    def deerheads?(segments:)
+      first, _, last = segments[@cursor..@cursor + 3].map(&:strip)
+      first == '<{' && last == '}>'
     end
 
-    def var(antlers_segment:)
+    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)
 
-      { var: antlers_segment }
-    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
+      return { raw_var: antlers_segment } if raw
 
-      { 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
+      { var: antlers_segment }
     end
   end
 end

data/lib/nodes/if_node.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/branch_node'
+require_relative '../modules/props'
+require_relative '../modules/variables'
+
+module Antlers
+  class IfNode < BranchNode
+    include Props
+    include Variables
+
+    def initialize(name:, value:, props: [], children: [])
+      super(name:, props:, children:)
+
+      @value = value
+    end
+
+    def render(current_binding: nil, parent_binding: nil, slot_node: nil)
+      output = ''.dup
+
+      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) || ''
+        end
+      end
+
+      output
+    end
+  end
+end

data/lib/nodes/prop_node.rb

@@ -23,8 +23,8 @@ 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:)
@@ -32,9 +32,10 @@ module Antlers
 
     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/var_node.rb

@@ -11,14 +11,19 @@ module Antlers
 
     attr_reader :value
 
-    def initialize(value:, name: :var)
+    def initialize(value:, name: :var, raw: false)
       super(name:)
 
       @value = value
+      @raw = raw
     end
 
     def render(current_binding: nil, parent_binding: nil, slot_node: nil)
-      ERB::Util.html_escape(evaluate(name: @value, current_binding:) || fallback(@value))
+      result = evaluate(name: @value, current_binding:) || fallback(@value)
+
+      return result if @raw
+
+      ERB::Util.html_escape(result)
     end
   end
 end

data/lib/parser.rb

@@ -21,6 +21,8 @@ module Antlers
           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]
@@ -29,6 +31,10 @@ module Antlers
           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

data/lib/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: antlers
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.1
 platform: ruby
 authors:
 - maedi
@@ -64,12 +64,20 @@ files:
 - lib/interfaces/antler_node.rb
 - lib/interfaces/branch_node.rb
 - lib/interfaces/leaf_node.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/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/if_node.rb
 - lib/nodes/prop_node.rb
 - lib/nodes/root_node.rb
 - lib/nodes/slot_node.rb