antlers 0.5.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 181c1f53191d4d32c458d74cc67b1d97082d0c023631b0af0fe726dc0db86d9e
-  data.tar.gz: 010ab20070af4634c783f2aa8573f8fa69be674bf96451df15e59f434cc8fa90
+  metadata.gz: b0d88855d8351d4ce9b4ebf2bfeaf0fc05faef8a33a882ffd206fa1c8241ec9e
+  data.tar.gz: e72f72db347e9f0f442e0a15cb4dce3f2c7405bf1bd7da6b33ab919a7003785b
 SHA512:
-  metadata.gz: d50a398b59defec9de55b59e45c3bd1b57d56f846221b6e00bbd080522909225f6a9e62cd6bc7326b30d60322faf30fbaecf41cada8ed04caa076bafc44be1d0
-  data.tar.gz: 4c8e9d78e0ee5ce5fbb6dcdb1c76e3ebd91f1c2600cd6accbb066cce81ccad9038aed99f65c6f3c28c99265dcfe7a95729bae02f07ca17283d81821153e7f9ae
+  metadata.gz: 6f1e6d6f8f512d327ee25068a3286d8f1e557407bf99f4ec274cd8c8e7336ef9c2d9db9980e66d13ce58b8055d07f6908108afcb8cd91d2da65224ac567946d4
+  data.tar.gz: 27520e044188ae13cde780d7438286e510dae3874cd2218debf2901a1b3c7e9909847c44ae38ce4353e8b0482afa2516fa47857836070a58e8683934865a58c7

data/lib/antlers.rb

@@ -5,15 +5,15 @@ require_relative 'parser'
 
 module Antlers
   class << self
-    def ast(template)
+    def ast(template:, namespace: nil)
       return template unless template.include?('<{') || template.include?('{')
 
-      lexemes = Lexer.new.parse(template)
-      Parser.parse(lexemes)
+      sequence = Lexer.new.parse(template)
+      Parser.new(namespace:).parse(sequence:)
     end
 
-    def render(ast:, current_binding:, parent_binding: nil, slot_node: nil, namespace: nil)
-      ast.render(current_binding:, parent_binding:, slot_node:, namespace:)
+    def render(ast:, current_binding:, parent_binding: nil, slot_node: nil)
+      ast.render(current_binding:, parent_binding:, slot_node:)
     end
   end
 end

data/lib/factories/node_factory.rb

@@ -1,6 +1,8 @@
 # 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'
@@ -8,27 +10,48 @@ require_relative '../nodes/yield_node'
 
 module Antlers
   class NodeFactory
-    class << self
-      def for_node(segment:)
-        value, key, items = segment.values_at(:for_def, :key, :in)
-        ForNode.new(name: value, key:, value:, items:)
-      end
+    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 prop_node(segment:)
-        PropNode.new(name: segment[:prop], props: segment[:props])
-      end
+    def form_node(segment:)
+      action, method = segment.values_at(:form_def, :method)
+      return FormNode.new(name: action, action:, method:) if method
 
-      def slot_node(segment:)
-        SlotNode.new(name: segment[:slot_def], props: segment[:props])
-      end
+      FormNode.new(name: action, action:)
+    end
 
-      def var_node(segment:)
-        VarNode.new(value: segment[:var])
-      end
+    def prop_node(segment:)
+      PropNode.new(name: segment[:prop], props: segment[:props], namespace:)
+    end
 
-      def yield_node(segment:)
-        YieldNode.new(name: segment[:slot])
-      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/interfaces/branch_node.rb

@@ -12,12 +12,12 @@ module Antlers
       @children = children
     end
 
-    def render(current_binding: nil, parent_binding: nil, slot_node: nil, namespace: nil)
+    def render(current_binding: nil, parent_binding: nil, slot_node: nil)
       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:, namespace:) : child) || ''
+        output += (child.respond_to?(:render) ? child.render(current_binding:, parent_binding:, slot_node:) : child) || ''
       end
 
       output

data/lib/lexer.rb

@@ -8,9 +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:', 'for:', 'in:', ':for', 'slot:', ':slot']
+      @keywords = [*IF_KEYWORDS, *FORM_KEYWORDS, *FOR_KEYWORDS, 'slot:', ':slot']
       @cursor = 0
     end
 
@@ -41,20 +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_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
@@ -62,44 +69,80 @@ module Antlers
     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
 
-      [name, props, keywords.map(&:strip)]
+    def value?(string)
+      !(string.start_with?(':') || string.end_with?(':'))
     end
 
-    def var?(segments:)
+    # 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:', ':for'].include?(keywords.first)
+      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.include?(':slot')
+    def slot_yield?(keywords:)
+      keywords.keys.include?(':slot')
     end
 
     def prop?(name)
       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 for_loop(keywords:)
-      key_values = keywords.count.even? ? keywords.each_slice(2).to_h : {}
+    def if_block(keywords:)
+      return { if_def: keywords['if:'] } if keywords.key?('if:')
+
+      { if_end: 'level_1' }
+    end
 
-      if key_values['for:']
-        *key, value = key_values['for:'].split(',').map(&:strip)
-        for_def = { for_def: value, in: key_values['in:'] }
+    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
@@ -108,6 +151,15 @@ module Antlers
       { 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(':') }

data/lib/modules/namespace.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Antlers
+  module Namespace
+    def class_constant(namespace:, name:)
+      return Object.const_get(name) if name.start_with?('::')
+
+      class_from_namespace(namespace:, name:)
+    end
+
+    def class_from_namespace(namespace:, name:)
+      namespace_with_name = [namespace, name].join('::')
+      return Object.const_get(namespace_with_name) if Object.const_defined?(namespace_with_name)
+
+      namespace.pop
+      class_from_namespace(namespace:, name:)
+    end
+  end
+end

data/lib/modules/props.rb

@@ -32,15 +32,5 @@ module Antlers
 
       evaluated_props
     end
-
-    def class_from_namespace(namespace:, name:)
-      return Object.const_get(name) if Object.const_defined?(name) || name.start_with?('::') || namespace.empty?
-
-      namespace_with_name = [namespace, name].join('::')
-      return Object.const_get(namespace_with_name) if Object.const_defined?(namespace_with_name)
-
-      namespace.pop
-      class_from_namespace(namespace:, name:)
-    end
   end
 end

data/lib/modules/variables.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../support/queries'
 
 module Antlers
@@ -15,7 +17,7 @@ module Antlers
       name, *chain = name.split('.')
 
       result = method_var(name:, current_binding:)
-      return method_chain(result:, chain:, current_binding:) if chain.count > 0
+      return method_chain(result:, chain:) if chain.count > 0
       return result if result
 
       nil
@@ -39,7 +41,7 @@ module Antlers
       nil
     end
 
-    def method_chain(result:, chain:, current_binding:)
+    def method_chain(result:, chain:)
       chain.reduce(result) do |result, method_call|
         result.send(method_call.to_sym)
       end

data/lib/nodes/for_node.rb

@@ -9,8 +9,6 @@ module Antlers
     include Props
     include Variables
 
-    attr_accessor :children
-
     def initialize(name:, items:, value:, key: nil, props: [], children: [])
       super(name:, props:, children:)
 
@@ -19,7 +17,7 @@ module Antlers
       @key = key
     end
 
-    def render(current_binding: nil, parent_binding: nil, slot_node: nil, namespace: nil)
+    def render(current_binding: nil, parent_binding: nil, slot_node: nil)
       output = ''
 
       evaluate(name: @items, current_binding:).each do |value|
@@ -31,7 +29,7 @@ module Antlers
 
         @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:, namespace:) : child) || ''
+          output += (child.respond_to?(:render) ? child.render(current_binding:, parent_binding:, slot_node:) : child) || ''
         end
       end
 

data/lib/nodes/form_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 FormNode < BranchNode
+    include Props
+    include Variables
+
+    def initialize(name:, action: nil, method: 'POST', props: [], children: [])
+      super(name:, props:, children:)
+
+      @action = action
+      @method = method
+    end
+
+    def render(current_binding: nil, parent_binding: nil, slot_node: nil)
+      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) || ''
+      end
+
+      output += '</form>'
+      output
+    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

@@ -1,26 +1,51 @@
 # frozen_string_literal: true
 
 require_relative '../interfaces/leaf_node'
+require_relative '../modules/namespace'
 require_relative '../modules/props'
 
 module Antlers
   class PropNode < LeafNode
-    include Props
+    include Namespace
+    include Props # Immediate parent ancestor that super() refers to.
 
-    def render(current_binding: nil, parent_binding: nil, slot_node: nil, namespace: nil)
+    def initialize(name:, props: {}, namespace: nil, **)
+      super(name:, props:)
+
+      @namespace = namespace
+    end
+
+    # Classes referenced via "<{ MyNode }>" must implement class/instance and render/render_template methods (See LowNode).
+    def render(current_binding: nil, parent_binding: nil, slot_node: nil)
       props = evaluate_props(props: @props, current_binding:)
       event = create_render_event(props:)
 
-      renderable_klass = class_from_namespace(namespace: namespace&.split('::') || [], name: @name)
-      # TODO: There's currently 2 results for "Lowkey[renderable_klass.to_s]", this should not be.
-      # TODO: Only provide args that are defined, similar to how render_template does it.
-      initialize_method = Lowkey[renderable_klass.to_s].first[renderable_klass.to_s][:initialize]
-      renderable_instance = initialize_method ? renderable_klass.new(event:, **props) : renderable_klass.new(event:)
+      # 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:)
+
+      return instance.render_template(event:, parent_binding:, props:) if klass.template
+
+      render_args(class_proxy:, instance:, event:, props:)
+    end
+
+    private
+
+    def create_instance(class_proxy:, klass:, event:)
+      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(event:) if initialize_params.include?(:event)
+
+      klass.new
+    end
 
-      # Classes referenced via "<{ ChildNode }>" must implement class/instance render/render_template methods (See LowNode).
-      return renderable_instance.render_template(event:, parent_binding:, props:) if renderable_klass.template
+    def render_args(class_proxy:, instance:, event:, props:)
+      render_params = class_proxy.instance_methods[:render]&.tagged_params(:keyword)&.map(&:name) || []
+      return instance.render(event:, **props) if render_params.include?(:event) && render_params.count > 1
+      return instance.render(event:) if render_params.include?(:event)
 
-      props.empty? ? renderable_instance.render(event:) : renderable_instance.render(event:, **props)
+      instance.render
     end
   end
 end

data/lib/nodes/slot_node.rb

@@ -1,23 +1,28 @@
 # frozen_string_literal: true
 
 require_relative '../interfaces/branch_node'
+require_relative '../modules/namespace'
 require_relative '../modules/props'
 
 module Antlers
   class SlotNode < BranchNode
-    include Props
+    include Namespace
+    include Props # Immediate parent ancestor which props are passed to.
 
     attr_accessor :children
 
-    def initialize(name:, props: [], children: [])
+    def initialize(name:, namespace:, props: [], children: [], **)
       super(name:, props:, children:)
+
+      @namespace = namespace
     end
 
-    def render(current_binding: nil, parent_binding: nil, slot_node: nil, namespace: nil)
+    def render(current_binding: nil, parent_binding: nil, slot_node: nil)
       props = evaluate_props(props: @props, current_binding:)
       event = create_render_event(props:)
 
-      klass = class_from_namespace(namespace: namespace&.split('::') || [], name: @name)
+      # 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:)
       instance = klass.new(event:)
 
       # Classes referenced via "<{ ChildNode }>" must implement class/instance render/render_template methods (See LowNode).

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, namespace: nil)
-      ERB::Util.html_escape(evaluate(name: @value, current_binding:) || fallback(@value))
+    def render(current_binding: nil, parent_binding: nil, slot_node: nil)
+      result = evaluate(name: @value, current_binding:) || fallback(@value)
+
+      return result if @raw
+
+      ERB::Util.html_escape(result)
     end
   end
 end

data/lib/nodes/yield_node.rb

@@ -9,13 +9,13 @@ module Antlers
     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, namespace: nil)
+    def render(current_binding: nil, parent_binding: nil, slot_node: nil)
       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, namespace:)
+          output += child.render(current_binding: parent_binding, parent_binding: nil, slot_node: nil)
         else
           output += child || ''
         end

data/lib/parser.rb

@@ -4,44 +4,56 @@ require_relative 'factories/node_factory'
 require_relative 'nodes/root_node'
 
 module Antlers
-  module Parser
-    class << self
-      def parse(sequence, id: :root_node)
-        branch(node: RootNode.new(name: id), sequence:)
-      end
+  class Parser
+    def initialize(namespace: nil)
+      @factory = NodeFactory.new(namespace:)
+    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 << NodeFactory.var_node(segment:)
-          elsif segment[:prop]
-            node.children << NodeFactory.prop_node(segment:)
-          elsif segment[:slot]
-            node.children << NodeFactory.yield_node(segment:)
-          elsif segment[:slot_def]
-            slot_node = NodeFactory.slot_node(segment:)
-            node.children << slot_node
-            sub_branch(node: slot_node, sequence:, end_key: :slot_end, end_name: slot_node.name)
-          elsif segment[:for_def]
-            for_node = NodeFactory.for_node(segment:)
-            node.children << for_node
-            sub_branch(node: for_node, sequence:, end_key: :for_end, end_name: 'level_1')
-          end
-        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
 
-        node
+        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
 
-      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
+      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
+      branch(node:, sequence: sub_sequence)
     end
   end
 end

data/lib/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: antlers
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.8.0
 platform: ruby
 authors:
 - maedi
@@ -37,7 +37,22 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: A new Ruby templating language. Coming soon...
+- !ruby/object:Gem::Dependency
+  name: lowkey
+  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:
 - maediprichard@gmail.com
 executables: []
@@ -50,9 +65,12 @@ files:
 - lib/interfaces/branch_node.rb
 - lib/interfaces/leaf_node.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
@@ -61,11 +79,11 @@ files:
 - lib/parser.rb
 - lib/support/queries.rb
 - lib/version.rb
-homepage: https://codeberg.org/raindeer/antlers
+homepage: https://github.com/raindeer-rb/antlers
 licenses: []
 metadata:
-  homepage_uri: https://codeberg.org/raindeer/antlers
-  source_code_uri: https://codeberg.org/raindeer/antlers/src/branch/main
+  homepage_uri: https://github.com/raindeer-rb/antlers
+  source_code_uri: https://github.com/raindeer-rb/antlers/src/branch/main
 rdoc_options: []
 require_paths:
 - lib
@@ -80,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.6
 specification_version: 4
-summary: Deer to be different
+summary: Templating language inside HTML inside Ruby
 test_files: []