antlers 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7aef5ead7628092869dbae7f4ae7fee7bea88a69e1c3ee2e9ebd5fd6ace600ea
-  data.tar.gz: a96ba7818b542305105305c9c7cbc73a6c4962b118e6f0686f1eb73cfda59a56
+  metadata.gz: 57d224246ca8ba02aac3045b0f06904d8cebb0cfdb7f3d518d3c646324a1e3b6
+  data.tar.gz: e8b7787ccfc284dbb1d370292ba4238576e346c75bc957d5da70067220635ba7
 SHA512:
-  metadata.gz: ff1db9dd204501ae40f3ccc43ebf56b236aa1776ef233edd7a982d34ca5ad5d5486aaad29de46f6f382adc092cb54d5169a6a84443faae5799eb26cb7a9c96ee
-  data.tar.gz: 5637d1f3cb287c70b7f47d0cb7405c594b98fc3858a624e10302ef935e88872f07fa5a67403bbb091a7ec29af758161f8effa9c2055ddd3a12ec2aa32d1d470a
+  metadata.gz: b4cb6632bbbafb3ec12cc27256b2ae9e2134e3b621e28a7edcfd269bfff828d128cd0f659d7135a734b7792d121477c0ca012c3215a1eef442d3106bb637e89d
+  data.tar.gz: 0a0f5f6fc83e72a7253a737956c3a4cff5961999722b23b96ad44716b3ad2b2e40ce7742145cea8610f9604467a438a12000a0609cd9408487f85472f362cb3d

data/lib/antlers.rb

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 
+require_relative 'lexer'
+require_relative 'parser'
+
 module Antlers
   class << self
-    def parse(template)
+    def ast(template)
       return template unless template.include?('<{') || template.include?('{')
 
       lexemes = Lexer.new.parse(template)
       Parser.parse(lexemes)
     end
 
-    # TODO: Render the AST.
-    def render(antler_node); end
+    def render(ast:, current_binding:, parent_binding: nil, slot_node: nil, namespace: nil)
+      ast.render(current_binding:, parent_binding:, slot_node:, namespace:)
+    end
   end
 end

data/lib/factories/node_factory.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
+require_relative '../nodes/for_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
     class << self
-      def var_node(segment:)
-        VarNode.new(name: segment[:ivar])
+      def for_node(segment:)
+        ForNode.new(name: segment[:for_def], item: segment[:for_def], items: segment[:in])
       end
 
       def prop_node(segment:)
@@ -18,6 +20,14 @@ module Antlers
       def slot_node(segment:)
         SlotNode.new(name: segment[:slot_def], props: segment[:props])
       end
+
+      def var_node(segment:)
+        VarNode.new(value: segment[:var])
+      end
+
+      def yield_node(segment:)
+        YieldNode.new(name: segment[:slot])
+      end
     end
   end
 end

data/lib/interfaces/antler_node.rb

@@ -8,7 +8,11 @@ module Antlers
       @name = name
     end
 
-    # Consider this a value object on comparison.
+    def render(current_binding: nil, parent_binding: nil, slot_node: nil, namespace: nil)
+      raise NotImplementedError
+    end
+
+    # Consider instance a value object on comparison.
     def ==(other) = other.class == self.class
     def eql?(other) = self == other
     def hash = [self.class].hash

data/lib/interfaces/branch_node.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'antler_node'
+
+module Antlers
+  class BranchNode < AntlerNode
+    attr_accessor :children
+
+    def initialize(name:, children: [])
+      super(name:)
+
+      @children = children
+    end
+
+    def render(current_binding: nil, parent_binding: nil, slot_node: nil, namespace: 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) || ''
+      end
+
+      output
+    end
+  end
+end

data/lib/interfaces/leaf_node.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'antler_node'
+
+module Antlers
+  class LeafNode < AntlerNode
+  end
+end

data/lib/lexer.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
+require_relative 'queries'
+
 module Antlers
+  extend Queries
+
   class LexerParseError < StandardError; end
 
   class Lexer
     def initialize
       @delimiters = ['<{', '}>', '{', '}']
-      @keywords = ['if:', 'for:', 'in:']
+      @keywords = ['if:', 'for:', 'in:', ':for', 'slot:', ':slot']
       @cursor = 0
     end
 
@@ -20,7 +24,7 @@ module Antlers
       until segments[@cursor].nil?
         if (antlers_segment = antlers_segment(segments:))
           sequence << antlers_lexeme(antlers_segment:, segments:)
-          # Skipping: ['{', '@ivar', '}']
+          # Skipping: ['{', 'expression', '}']
           # Skipping: ['<{', 'name + props + keywords', '}>']
           @cursor += 3
         else
@@ -37,44 +41,72 @@ module Antlers
 
     def antlers_segment(segments:)
       next_segment = segments[@cursor + 1]
-      return nil unless next_segment && (segments[@cursor] == '<{' || ivar?(segments:))
+      return nil unless next_segment && (segments[@cursor] == '<{' || var?(segments:))
 
       next_segment
     end
 
     def antlers_lexeme(antlers_segment:, segments:)
-      return ivar(antlers_segment:) if ivar?(segments:)
+      return var(antlers_segment:) if var?(segments:)
 
-      name, props, _keywords = parse_segment(antlers_segment:)
+      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:)
 
-      raise LexerParseError, "Couldn't parse antlers syntax: '#{antlers_segment}'"
+      raise LexerParseError, "Unrecognised syntax: '#{antlers_segment}'"
     end
 
     def parse_segment(antlers_segment:)
       name_and_props, *keywords = antlers_segment.split(/(#{Regexp.union(@keywords)})/)
       name, *props = name_and_props.split(' ')
 
-      [name, props, keywords]
+      [name, props, keywords.map(&:strip)]
+    end
+
+    def var?(segments:)
+      first, middle, last = segments[@cursor..@cursor + 3].map(&:strip)
+      first == '{' && last == '}'
     end
 
-    def ivar?(segments:)
-      first, second, third = segments[@cursor..@cursor + 3].map(&:strip)
-      first == '{' && second&.start_with?('@') && third == '}'
+    def for_loop?(keywords:)
+      keywords.first == 'for:' || keywords.first == ':for'
     end
 
     def slot?(name)
-      name.start_with?(':') || name.end_with?(':')
+      name && (name.start_with?(':') || name.end_with?(':'))
+    end
+
+    def slot_yield?(keywords)
+      keywords.include?(':slot')
     end
 
     def prop?(name)
-      [*'A'..'Z'].include?(name[0])
+      name && [*'A'..'Z'].include?(name[0])
     end
 
-    def ivar(antlers_segment:)
-      { ivar: antlers_segment.delete_prefix('@') }
+    def var(antlers_segment:)
+      # String is already interpolated or not depending on user input on the template layer, now we store it without those template quotes.
+      if Queries.user_defined_string?(antlers_segment)
+        antlers_segment = antlers_segment[1..-2]
+      end
+
+      { var: antlers_segment }
+    end
+
+    def for_loop(keywords:)
+      key_values = keywords.count % 2 == 0 ? keywords.each_slice(2).to_h : {}
+
+      if key_values['for:']
+        for_def = { for_def: key_values['for:'] }
+        for_def[:in] = key_values['in:']
+        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 slot(name:, props:)
@@ -87,6 +119,10 @@ module Antlers
       { 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?
@@ -108,7 +144,7 @@ module Antlers
           value = odd_props.shift
         end
 
-        props[prop] = value
+        props[prop.to_sym] = value
       end
 
       props

data/lib/modules/props.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'low_event'
+
+module Antlers
+  module Props
+    attr_accessor :props
+
+    def initialize(name:, props: {}, **)
+      super(name:, **)
+
+      @props = props
+    end
+
+    private
+
+    def create_render_event(props:)
+      Low::Events::RenderEvent.new(action: :render, props:)
+    end
+
+    def evaluate_props(props:, current_binding:)
+      return {} if props.nil?
+
+      evaluated_props = {}
+
+      props.each do |name, value|
+        receiver = current_binding.receiver
+        
+        if receiver.respond_to?(value.to_sym)
+          evaluated_props[name] = receiver.send(value.to_sym) 
+        elsif value.start_with?('@')
+          evaluated_props[name] = receiver.instance_variable_get(value)
+        end
+      end
+
+      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

@@ -0,0 +1,19 @@
+module Antlers
+  module Variables
+    # A variable is deliberately limited in what it can represent.
+    #  1. An instance variable
+    #  2. A method call/local variable
+    #  3. A static string
+    def evaluate_variable(name:, current_binding:)
+      if current_binding
+        return current_binding.receiver.instance_variable_get(name) if name.start_with?('@')
+        return current_binding.local_variable_get(name) if current_binding.local_variable_defined?(name)
+        return current_binding.receiver.send(name.to_sym) if current_binding.receiver.respond_to?(name.to_sym)
+      end
+
+      @value.to_s
+    rescue NameError
+      @value.to_s
+    end
+  end
+end

data/lib/nodes/for_node.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/branch_node'
+require_relative '../modules/props'
+require_relative '../modules/variables'
+
+module Antlers
+  class ForNode < BranchNode
+    include Props
+    include Variables
+
+    attr_accessor :children
+
+    def initialize(name:, item:, items:, props: [], children: [])
+      super(name:, props:, children:)
+
+      @item = item
+      @items = items
+    end
+
+    def render(current_binding: nil, parent_binding: nil, slot_node: nil, namespace: nil)
+      output = ''
+
+      evaluate_variable(name: @items, current_binding:).each do |item|
+        current_binding.local_variable_set(@item, item)
+
+        @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) || ''
+        end
+      end
+
+      output
+    end
+  end
+end

data/lib/nodes/prop_node.rb

@@ -1,15 +1,23 @@
 # frozen_string_literal: true
 
-require_relative '../interfaces/antler_node'
+require_relative '../interfaces/leaf_node'
+require_relative '../modules/props'
 
 module Antlers
-  attr_accessor :props
+  class PropNode < LeafNode
+    include Props
 
-  class PropNode < AntlerNode
-    def initialize(name:, props: [])
-      super(name:)
+    def render(current_binding: nil, parent_binding: nil, slot_node: nil, namespace: nil)
+      props = evaluate_props(props: @props, current_binding:)
+      event = create_render_event(props:)
 
-      @props = props
+      renderable_klass = class_from_namespace(namespace: namespace&.split('::') || [], name: @name)
+      renderable_instance = renderable_klass.new(event:)
+
+      # 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
+
+      props.empty? ? renderable_instance.render(event:) : renderable_instance.render(event:, **props)
     end
   end
 end

data/lib/nodes/root_node.rb

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
-require_relative '../interfaces/antler_node'
+require_relative '../interfaces/branch_node'
 
 module Antlers
-  class RootNode < AntlerNode
-    attr_accessor :children
-
+  class RootNode < BranchNode
     def initialize(name: :root_node, children: [])
-      super(name:)
-
-      @children = children
+      super(name:, children:)
     end
   end
 end

data/lib/nodes/slot_node.rb

@@ -1,15 +1,29 @@
 # frozen_string_literal: true
 
-require_relative '../nodes/prop_node'
+require_relative '../interfaces/branch_node'
+require_relative '../modules/props'
 
 module Antlers
-  class SlotNode < PropNode
+  class SlotNode < BranchNode
+    include Props
+
     attr_accessor :children
 
     def initialize(name:, props: [], children: [])
-      super(name:, props:)
+      super(name:, props:, children:)
+    end
+
+    def render(current_binding: nil, parent_binding: nil, slot_node: nil, namespace: nil)
+      props = evaluate_props(props: @props, current_binding:)
+      event = create_render_event(props:)
+
+      klass = class_from_namespace(namespace: namespace&.split('::') || [], name: @name)
+      instance = klass.new(event:)
+
+      # Classes referenced via "<{ ChildNode }>" must implement class/instance render/render_template methods (See LowNode).
+      return instance.render_template(event:, parent_binding: current_binding, slot_node: self, props:) if klass.template
 
-      @children = children
+      props.empty? ? instance.render(event:) : instance.render(event:, **props)
     end
   end
 end

data/lib/nodes/var_node.rb

@@ -1,8 +1,24 @@
 # frozen_string_literal: true
 
-require_relative '../interfaces/antler_node'
+require 'erb'
+
+require_relative '../interfaces/leaf_node'
+require_relative '../modules/variables'
 
 module Antlers
-  class VarNode < AntlerNode
+  class VarNode < LeafNode
+    include Variables
+
+    attr_reader :value
+
+    def initialize(name: :var, value:)
+      super(name:)
+
+      @value = value
+    end
+
+    def render(current_binding: nil, parent_binding: nil, slot_node: nil, namespace: nil)
+      ERB::Util.html_escape(evaluate_variable(name: @value, current_binding:) || @value)
+    end
   end
 end

data/lib/nodes/yield_node.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/leaf_node'
+
+module Antlers
+  class YieldNode < BranchNode
+    def initialize(name: :default)
+      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, namespace: nil)
+      output = ''
+
+      slot_node.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, parent_binding: nil, slot_node: nil, namespace:) : child) || ''
+      end
+
+      output
+    end
+  end
+end

data/lib/parser.rb

@@ -7,31 +7,40 @@ module Antlers
   module Parser
     class << self
       def parse(sequence, id: :root_node)
-        branch(branch_node: RootNode.new(name: id), sequence:)
+        branch(node: RootNode.new(name: id), sequence:)
       end
 
-      def branch(branch_node:, sequence:) # rubocop:disable Metrics/AbcSize
+      def branch(node:, sequence:) # rubocop:disable Metrics/AbcSize
         until sequence.empty?
           segment = sequence.shift
 
           if segment.is_a?(String)
-            branch_node.children << segment
-          elsif segment[:ivar]
-            branch_node.children << NodeFactory.var_node(segment:)
+            node.children << segment
+          elsif segment[:var]
+            node.children << NodeFactory.var_node(segment:)
           elsif segment[:prop]
-            branch_node.children << NodeFactory.prop_node(segment:)
+            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:)
-            branch_node.children << slot_node
-
-            sub_sequence = []
-            sub_sequence << sequence.shift until sequence.first[:slot_end] == slot_node.name
-
-            branch(branch_node: slot_node, sequence: sub_sequence)
+            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
 
-        branch_node
+        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

data/lib/queries.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Antlers
+  module Queries
+    class << self
+      def user_defined_string?(string)
+        wrapped_in?(string, %q{'}) || wrapped_in?(string, %q{"})
+      end
+
+      def wrapped_in?(string, delimeter)
+        string[0] == delimeter && string[-1] == delimeter
+      end
+    end
+  end
+end

data/lib/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: antlers
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - maedi
@@ -10,19 +10,33 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: low_type
+  name: low_event
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: erb
+  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 new Ruby templating language. Coming soon...
 email:
 - maediprichard@gmail.com
@@ -33,12 +47,19 @@ files:
 - lib/antlers.rb
 - lib/factories/node_factory.rb
 - lib/interfaces/antler_node.rb
+- lib/interfaces/branch_node.rb
+- lib/interfaces/leaf_node.rb
 - lib/lexer.rb
+- lib/modules/props.rb
+- lib/modules/variables.rb
+- lib/nodes/for_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/queries.rb
 - lib/version.rb
 homepage: https://codeberg.org/raindeer/antlers
 licenses: []
@@ -59,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Deer to be different
 test_files: []