antlers 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e01a292dd41ce2f99fd7a6bdd5a375d3d2c36a3e4d5280ccaaaf91be9bcde38
-  data.tar.gz: 84227a375d02da8663bfdf04efaf496be097f7898840d25bc4f02b0c62bc2fff
+  metadata.gz: b0d88855d8351d4ce9b4ebf2bfeaf0fc05faef8a33a882ffd206fa1c8241ec9e
+  data.tar.gz: e72f72db347e9f0f442e0a15cb4dce3f2c7405bf1bd7da6b33ab919a7003785b
 SHA512:
-  metadata.gz: c449e355a550e43aa65e1e00ba482e858b07a1fb0f983325808a538769d6e8eb78ed5dad4a5a3fdd3f24348db7001e59876894b2a98d882e38dd9fa10078104a
-  data.tar.gz: 5f71032b3da08b3675f52045f513a810bf2228a1c3308ce7dcde2c53596f7525060dbbd34d05ffb1b04cf8672c045a9e117b727f58a972361a32603e53c2d6ff
+  metadata.gz: 6f1e6d6f8f512d327ee25068a3286d8f1e557407bf99f4ec274cd8c8e7336ef9c2d9db9980e66d13ce58b8055d07f6908108afcb8cd91d2da65224ac567946d4
+  data.tar.gz: 27520e044188ae13cde780d7438286e510dae3874cd2218debf2901a1b3c7e9909847c44ae38ce4353e8b0482afa2516fa47857836070a58e8683934865a58c7

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

@@ -8,12 +8,13 @@ module Antlers
   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:', *FORM_KEYWORDS, *FOR_KEYWORDS, 'slot:', ':slot']
+      @keywords = [*IF_KEYWORDS, *FORM_KEYWORDS, *FOR_KEYWORDS, 'slot:', ':slot']
       @cursor = 0
     end
 
@@ -44,21 +45,23 @@ 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 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
@@ -87,11 +90,20 @@ 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 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
@@ -112,13 +124,21 @@ module Antlers
       name && [*'A'..'Z'].include?(name[0])
     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)
 
+      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)

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/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.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: antlers
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - maedi
@@ -70,6 +70,7 @@ files:
 - 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