antlers 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7aef5ead7628092869dbae7f4ae7fee7bea88a69e1c3ee2e9ebd5fd6ace600ea
-  data.tar.gz: a96ba7818b542305105305c9c7cbc73a6c4962b118e6f0686f1eb73cfda59a56
+  metadata.gz: eca914b3e0a81f538aaa1e4db0b477a9b46c0934d365786962d2a391c957b3ee
+  data.tar.gz: 7f46ddc34ff748822e99537b59e0300fe6c094abe79d2cd042ad78ad7cb9068d
 SHA512:
-  metadata.gz: ff1db9dd204501ae40f3ccc43ebf56b236aa1776ef233edd7a982d34ca5ad5d5486aaad29de46f6f382adc092cb54d5169a6a84443faae5799eb26cb7a9c96ee
-  data.tar.gz: 5637d1f3cb287c70b7f47d0cb7405c594b98fc3858a624e10302ef935e88872f07fa5a67403bbb091a7ec29af758161f8effa9c2055ddd3a12ec2aa32d1d470a
+  metadata.gz: ca62292741c30d4a3ed0a0c0b62dcb20a895eb3018d55b179ef3512f47e078628eff04089b285490add876d1cfa5ca473a4b85b7bdf01d69d56e459b0364e1bb
+  data.tar.gz: db84676dac56bce48b73b1019d73924c7c82c7e4c98d6b5a9c9dddbae2e8defd68336f8ec83e64154403a2f9d1fe611d441ebec99f5f2c2a899bb2fe6a7acfc4

data/lib/antlers.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require_relative 'lexer'
+require_relative 'parser'
+
+require 'low_event'
+
 module Antlers
   class << self
     def parse(template)
@@ -9,7 +14,8 @@ module Antlers
       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

@@ -3,14 +3,11 @@
 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])
-      end
-
       def prop_node(segment:)
         PropNode.new(name: segment[:prop], props: segment[:props])
       end
@@ -18,6 +15,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:', '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,16 +41,17 @@ 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)
 
@@ -60,21 +65,30 @@ module Antlers
       [name, props, keywords]
     end
 
-    def ivar?(segments:)
-      first, second, third = segments[@cursor..@cursor + 3].map(&:strip)
-      first == '{' && second&.start_with?('@') && third == '}'
+    def var?(segments:)
+      first, middle, last = segments[@cursor..@cursor + 3].map(&:strip)
+      first == '{' && last == '}'
     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 slot(name:, props:)
@@ -87,6 +101,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 +126,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,47 @@
+# frozen_string_literal: true
+
+module Antlers
+  module Props
+    attr_accessor :props
+
+    def initialize(name:, props: {}, **)
+      super(name:, **)
+
+      @props = props
+    end
+
+    private
+
+    def create_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/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_event(props:)
 
-      @props = 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:, props:) if klass.template
+
+      props.empty? ? instance.render(event:) : 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_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,40 @@
 # frozen_string_literal: true
 
-require_relative '../interfaces/antler_node'
+require 'erb'
+
+require_relative '../interfaces/leaf_node'
 
 module Antlers
-  class VarNode < AntlerNode
+  class VarNode < LeafNode
+    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_value(current_binding))
+    end
+
+    private
+
+    # A variable is deliberately limited in what it can represent.
+    #  1. An instance/local variable
+    #  2. A method call
+    #  3. A static string
+    def evaluate_value(current_binding)
+      if current_binding
+        return current_binding.receiver.instance_variable_get(@value) if @value.start_with?('@')
+        return current_binding.local_variable_get(@value) if current_binding.local_variable_defined?(@value)
+        return current_binding.receiver.send(@value.to_sym) if current_binding.receiver.respond_to?(@value.to_sym)
+      end
+
+      @value
+    rescue NameError => e
+      # TODO: Must be a better way to handle variables input as literal strings.
+      @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

@@ -16,16 +16,18 @@ module Antlers
 
           if segment.is_a?(String)
             branch_node.children << segment
-          elsif segment[:ivar]
+          elsif segment[:var]
             branch_node.children << NodeFactory.var_node(segment:)
           elsif segment[:prop]
             branch_node.children << NodeFactory.prop_node(segment:)
+          elsif segment[:slot]
+            branch_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
+            sub_sequence << sequence.shift until sequence.first.is_a?(Hash) && sequence.first[:slot_end] == slot_node.name
 
             branch(branch_node: slot_node, sequence: sub_sequence)
           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.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: antlers
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.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,17 @@ 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/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: []