antlers 0.0.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1af03cc260e8dd49409f43d325fbf63271128bc55dcb9f9d8fa87151b2e4f3c9
-  data.tar.gz: f60f7b0ef2eef4c809a90d434b38e3dc20e0a7e2665633909b403433aa1a6726
+  metadata.gz: eca914b3e0a81f538aaa1e4db0b477a9b46c0934d365786962d2a391c957b3ee
+  data.tar.gz: 7f46ddc34ff748822e99537b59e0300fe6c094abe79d2cd042ad78ad7cb9068d
 SHA512:
-  metadata.gz: 1f7d7f8a0a141c2cb9bb8ccd4907b64d69a9d75cbf9fe98dfb8ddc4f3c37a175f38ae3e7dfb7798a9b2bcb07dd9abb7d537e472b62e534daeb7635a70bdcabc9
-  data.tar.gz: d333bc441ccf5531e22325c94ccffe0820215ce68be6bd3a4c512fe8e28c5fd5ff711e18fc81ec0a2336fff131cc281b2b348d6f893ce6f6407c5cb4e75ba424
+  metadata.gz: ca62292741c30d4a3ed0a0c0b62dcb20a895eb3018d55b179ef3512f47e078628eff04089b285490add876d1cfa5ca473a4b85b7bdf01d69d56e459b0364e1bb
+  data.tar.gz: db84676dac56bce48b73b1019d73924c7c82c7e4c98d6b5a9c9dddbae2e8defd68336f8ec83e64154403a2f9d1fe611d441ebec99f5f2c2a899bb2fe6a7acfc4

data/lib/antlers.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'lexer'
+require_relative 'parser'
+
+require 'low_event'
+
+module Antlers
+  class << self
+    def parse(template)
+      return template unless template.include?('<{') || template.include?('{')
+
+      lexemes = Lexer.new.parse(template)
+      Parser.parse(lexemes)
+    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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+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 prop_node(segment:)
+        PropNode.new(name: segment[:prop], props: segment[:props])
+      end
+
+      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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Antlers
+  class AntlerNode
+    attr_reader :name
+
+    def initialize(name:)
+      @name = name
+    end
+
+    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
+  end
+end

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative 'queries'
+
+module Antlers
+  extend Queries
+
+  class LexerParseError < StandardError; end
+
+  class Lexer
+    def initialize
+      @delimiters = ['<{', '}>', '{', '}']
+      @keywords = ['if:', 'for:', 'in:', 'slot:', ':slot']
+      @cursor = 0
+    end
+
+    def parse(template)
+      @cursor = 0
+      sequence = []
+
+      # Split on delimiters and retain capture groups.
+      segments = template.split(/(#{Regexp.union(@delimiters)})/).map(&:strip)
+
+      until segments[@cursor].nil?
+        if (antlers_segment = antlers_segment(segments:))
+          sequence << antlers_lexeme(antlers_segment:, segments:)
+          # Skipping: ['{', 'expression', '}']
+          # Skipping: ['<{', 'name + props + keywords', '}>']
+          @cursor += 3
+        else
+          segment = segments[@cursor]
+          sequence << segment unless segment.empty?
+          @cursor += 1
+        end
+      end
+
+      sequence
+    end
+
+    private
+
+    def antlers_segment(segments:)
+      next_segment = segments[@cursor + 1]
+      return nil unless next_segment && (segments[@cursor] == '<{' || var?(segments:))
+
+      next_segment
+    end
+
+    def antlers_lexeme(antlers_segment:, segments:)
+      return var(antlers_segment:) if var?(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)
+
+      raise LexerParseError, "Couldn't parse antlers 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]
+    end
+
+    def var?(segments:)
+      first, middle, last = segments[@cursor..@cursor + 3].map(&:strip)
+      first == '{' && last == '}'
+    end
+
+    def slot?(name)
+      name && (name.start_with?(':') || name.end_with?(':'))
+    end
+
+    def slot_yield?(keywords)
+      keywords.include?(':slot')
+    end
+
+    def prop?(name)
+      name && [*'A'..'Z'].include?(name[0])
+    end
+
+    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:)
+      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
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/leaf_node'
+require_relative '../modules/props'
+
+module Antlers
+  class PropNode < LeafNode
+    include Props
+
+    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:, props:) if klass.template
+
+      props.empty? ? instance.render(event:) : instance.render(event:, **props)
+    end
+  end
+end

data/lib/nodes/root_node.rb

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

data/lib/nodes/slot_node.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/branch_node'
+require_relative '../modules/props'
+
+module Antlers
+  class SlotNode < BranchNode
+    include Props
+
+    attr_accessor :children
+
+    def initialize(name:, props: [], children: [])
+      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
+
+      props.empty? ? instance.render(event:) : instance.render(event:, **props)
+    end
+  end
+end

data/lib/nodes/var_node.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+require_relative '../interfaces/leaf_node'
+
+module Antlers
+  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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'factories/node_factory'
+require_relative 'nodes/root_node'
+
+module Antlers
+  module Parser
+    class << self
+      def parse(sequence, id: :root_node)
+        branch(branch_node: RootNode.new(name: id), sequence:)
+      end
+
+      def branch(branch_node:, sequence:) # rubocop:disable Metrics/AbcSize
+        until sequence.empty?
+          segment = sequence.shift
+
+          if segment.is_a?(String)
+            branch_node.children << segment
+          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.is_a?(Hash) && sequence.first[:slot_end] == slot_node.name
+
+            branch(branch_node: slot_node, sequence: sub_sequence)
+          end
+        end
+
+        branch_node
+      end
+    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.0.0'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: antlers
 version: !ruby/object:Gem::Version
-  version: 0.0.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
@@ -30,6 +44,20 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 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: []