orb_template 0.1.0

data/lib/orb/ast/attribute.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module ORB
+  module AST
+    class Attribute
+      attr_reader :name, :type
+
+      def initialize(name, type = :str, value = nil)
+        @name = name
+        @type = type
+        @value = value
+      end
+
+      def value
+        if @type == :bool || @type == :boolean
+          true
+        else
+          @value
+        end
+      end
+
+      def bool?
+        @type == :bool || @type == :boolean
+      end
+
+      def expression?
+        @type == :expr || @type == :expression
+      end
+
+      def string?
+        @type == :str || @type == :string
+      end
+
+      def splat?
+        @type == :splat
+      end
+
+      def static?
+        string? || bool?
+      end
+
+      def dynamic?
+        expression?
+      end
+
+      def directive?
+        @name&.start_with?(":")
+      end
+    end
+  end
+end

data/lib/orb/ast/block_node.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ORB
+  module AST
+    class BlockNode < AbstractNode
+      def initialize(token)
+        super
+        @name = token.value
+        @meta = token.meta
+      end
+
+      def name
+        @name.to_sym
+      end
+
+      def expression
+        @meta.fetch(:expression, false)
+      end
+
+      # TODO: Support render to text for different block types
+      def render(_context)
+        raise "BlockNode#render not implemented."
+      end
+    end
+  end
+end

data/lib/orb/ast/control_expression_node.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ORB
+  module AST
+    # A node representing a non-printing expression
+    # Non-printing expressions are used for control flow and variable assignment.
+    # Any output from a non-printing expression is captured and discarded.
+    class ControlExpressionNode < AbstractNode
+      BLOCK_RE = /\A(if|unless)\b|\bdo\s*(\|[^|]*\|)?\s*$/
+
+      attr_reader :expression
+
+      def initialize(token)
+        super
+        @expression = token.value
+      end
+
+      def block?
+        @expression =~ BLOCK_RE
+      end
+
+      def end?
+        @expression.strip == 'end'
+      end
+    end
+  end
+end

data/lib/orb/ast/newline_node.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ORB
+  module AST
+    class NewlineNode < AbstractNode
+      attr_accessor :text
+
+      def initialize(token)
+        super
+        @text = token.value
+      end
+
+      def render(_context)
+        @text
+      end
+
+      def ==(other)
+        super && @text == other.text
+      end
+    end
+  end
+end

data/lib/orb/ast/printing_expression_node.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ORB
+  module AST
+    # A node representing a printing expression
+    class PrintingExpressionNode < AbstractNode
+      BLOCK_RE = /\A(if|unless)\b|\bdo\s*(\|[^|]*\|)?\s*$/
+
+      attr_reader :expression
+
+      def initialize(token)
+        super
+        @expression = token.value
+      end
+
+      def block?
+        @expression =~ BLOCK_RE
+      end
+
+      def end?
+        @expression.strip == 'end'
+      end
+
+      def render(_context)
+        "NOT IMPLEMENTED"
+      end
+    end
+  end
+end

data/lib/orb/ast/private_comment_node.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ORB
+  module AST
+    class PrivateCommentNode < AbstractNode
+      attr_accessor :text
+
+      def initialize(token)
+        super
+        @text = token.value
+      end
+
+      def render(_context)
+        "{!-- #{@text} --}"
+      end
+
+      def ==(other)
+        super && @text == other.text
+      end
+    end
+  end
+end

data/lib/orb/ast/public_comment_node.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ORB
+  module AST
+    class PublicCommentNode < AbstractNode
+      attr_accessor :text
+
+      def initialize(token)
+        super
+        @text = token.value
+      end
+
+      def render(_context)
+        "<!-- #{@text} -->"
+      end
+
+      def ==(other)
+        super && @text == other.text
+      end
+    end
+  end
+end

data/lib/orb/ast/root_node.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ORB
+  module AST
+    class RootNode < AbstractNode
+      def render(context = {})
+        @children.map { |child| child.render(context) }.join
+      end
+    end
+  end
+end

data/lib/orb/ast/tag_node.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module ORB
+  module AST
+    ##
+    # Represents a tag node in the AST.
+    # A tag node is used to represent an HTML tag or a component tag.
+    # The tag node contains information about the tag name, attributes, and directives.
+    #
+    # It is created by the parser from a Token object produced by the tokenizer.
+    class TagNode < AbstractNode
+      attr_reader :tag, :meta
+
+      SLOT_SEPARATOR = ':'
+
+      ##
+      # Create a new TagNode from the given token
+      #
+      # @param token [Token] the token to create the node from
+      #
+      # @return [TagNode] the new node
+      def initialize(token)
+        super
+        @tag = token.value
+        @meta = token.meta
+
+        # Parse attributes from the metadata
+        @raw_attributes = @meta.fetch(:attributes, []).map do |attr|
+          name, type, value = attr
+          Attribute.new(name, type, value)
+        end
+      end
+
+      ##
+      # Render the node to a string
+      # @api private
+      def render(_context)
+        raise "Not implemented"
+      end
+
+      ##
+      # Determine whether the TagNode represents an HTML tag
+      #
+      # @return [Boolean] true if the tag is an HTML tag, false otherwise
+      def html_tag?
+        @tag.start_with?(/[a-z]/)
+      end
+
+      ##
+      # Determine whether the TagNode represents a self-closing (void) tag
+      #
+      # @return [Boolean] true if the tag is self-closing, false otherwise
+      def self_closing?
+        @meta.fetch(:self_closing, false)
+      end
+
+      ##
+      # Retrieve the attributes for the tag. Parses the internal representation
+      # of attributes in the metadata payload and constructs an array of Attribute objects.
+      #
+      # Use this method rather than attempting to parse the +meta+ object directly.
+      #
+      # @return [Array<Attribute>] the attributes for the tag
+      def attributes
+        @attributes ||= @raw_attributes.reject(&:directive?)
+        @attributes
+      end
+
+      ##
+      # Retrieve the directives for the tag
+      #
+      # @return [Array<Array<Attribute>>] the directives for the tag
+      def directives
+        @directives ||= @raw_attributes
+          .select(&:directive?)
+          .to_h { |attr| [attr.name[1..], attr.value] }
+          .transform_keys(&:to_sym)
+        @directives
+      end
+
+      ##
+      # Remove a directive from the tag, i.e. when it is consumed by the compiler
+      #
+      def remove_directive(name)
+        @directives.delete(name)
+      end
+
+      ##
+      # Clear all directives from the tag
+      #
+      def clear_directives
+        @directives = {}
+      end
+
+      ##
+      # Retrieve all the static attributes for the tag.
+      # A static attribute is one that has a string or boolean value.
+      #
+      # @return [Array<Attribute>] the static attributes for the tag
+      def static_attributes
+        attributes.select(&:static?)
+      end
+
+      ##
+      # Retrieve all the dynamic attributes for the tag.
+      # A dynamic attribute is one that has an expression value.
+      #
+      # @return [Array<Attribute>] the dynamic attributes for the tag
+      def dynamic_attributes
+        attributes.select(&:dynamic?)
+      end
+
+      ##
+      # Retrieve all the splat attributes for the tag.
+      # A splat attribute is one that has a splat type.
+      # The splat attribute is used to pass a hash of attributes to the tag at runtime.
+      #
+      # @return [Array<Attribute>] the splat attributes for the tag
+      def splat_attributes
+        attributes.select(&:splat?)
+      end
+
+      ##
+      # Determine whether the TagNode represents a component tag
+      # A component tag is one that starts with an uppercase letter and
+      # may contain a slot call on the component.
+      #
+      # @return [Boolean] true if the tag is a component tag, false otherwise
+      def component_tag?
+        @tag.start_with?(/[A-Z]/) && @tag.exclude?(SLOT_SEPARATOR)
+      end
+
+      ##
+      # Determine whether the TagNode represents a component slot tag
+      # A component slot tag is of the form +Component:slot+ and is used to
+      # render a slot within a component.
+      #
+      # @return [Boolean] true if the tag is a component slot tag, false otherwise
+      def component_slot_tag?
+        @tag.start_with?(/[A-Z]/) && @tag.include?(SLOT_SEPARATOR)
+      end
+
+      ##
+      # Retrieve the component name from the tag
+      #
+      # @return [String] the component name
+      def component
+        @tag.split(SLOT_SEPARATOR).first
+      end
+
+      ##
+      # Retrieve the slot name from the tag
+      #
+      # @return [String] the slot name
+      def slot
+        @tag.split(SLOT_SEPARATOR).last.underscore
+      end
+
+      ##
+      # Retrieve the module name from the component name
+      # The module name is the first part of the component name
+      # separated by a period.
+      #
+      # For example: +MyApp::UI::Button+ would return +MyApp.UI+
+      #
+      # @return [String] the module name
+      def component_module
+        component.rsplit('.').first
+      end
+
+      ##
+      # Determine whether the tag can be compiled as static HTML
+      #
+      # @return [Boolean] true if the tag can be compiled as static HTML, false otherwise
+      def static?
+        splat_attributes.empty?
+      end
+
+      ##
+      # Determine whether the tag needs to be compiled as dynamic HTML
+      #
+      # @return [Boolean] true if the tag needs to be compiled as dynamic HTML, false otherwise
+      def dynamic?
+        splat_attributes.any?
+      end
+
+      ##
+      # Check whether the node has any directives
+      #
+      # @return [Boolean] true if the directives are present, false otherwise
+      def directives?
+        directives.any?
+      end
+
+      def compiler_directives?
+        directives.any? { |k, _v| k == :if || k == :for }
+      end
+
+      ##
+      # Determine whether the tag content should be escaped or treated as verbatim
+      #
+      # @return [Boolean] true if the tag content should be escaped, false otherwise
+      def verbatim?
+        @meta.fetch(:verbatim, false)
+      end
+    end
+  end
+end

data/lib/orb/ast/text_node.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ORB
+  module AST
+    class TextNode < AbstractNode
+      attr_accessor :text
+
+      def initialize(token)
+        super
+        @text = token.value
+      end
+
+      def render(_context)
+        @text
+      end
+
+      def ==(other)
+        super && @text == other.text
+      end
+    end
+  end
+end

data/lib/orb/ast.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ORB
+  module AST
+    extend ActiveSupport::Autoload
+
+    autoload :AbstractNode
+    autoload :RootNode
+    autoload :PublicCommentNode
+    autoload :PrivateCommentNode
+    autoload :TextNode
+    autoload :TagNode
+    autoload :Attribute
+    autoload :PrintingExpressionNode
+    autoload :ControlExpressionNode
+    autoload :BlockNode
+    autoload :NewlineNode
+  end
+end

data/lib/orb/document.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ORB
+  class Document
+    attr_reader :root
+
+    def initialize(tokens)
+      parse(tokens)
+    end
+
+    def parse(tokens)
+      @root ||= Parser.parse(tokens)
+    end
+
+    def render(context)
+      @root.render(context)
+    end
+  end
+end

data/lib/orb/errors.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ORB
+  class Error < StandardError
+    attr_reader :line
+
+    def initialize(message = nil, line = nil)
+      super(message)
+      @line = line
+    end
+  end
+
+  # class SyntaxError < StandardError
+  #   attr_reader :error, :file, :line, :lineno, :column
+
+  #   def initialize(error, file, line, lineno, column)
+  #     @error = error
+  #     @file = file || '(__TEMPLATE__)'
+  #     @line = line.to_s
+  #     @lineno = lineno
+  #     @column = column
+  #   end
+
+  #   def to_s
+  #     line = @line.lstrip
+  #     column = @column + line.size - @line.size
+  #     message = <<~STR
+  #       #{error}
+  #       in #{file}, Line #{lineno}, Column #{@column}
+
+  #       #{line}
+  #       #{' ' * column}^
+  #     STR
+  #   end
+  # end
+
+  class SyntaxError < Error; end
+  class ParserError < Error; end
+  class CompilerError < Error; end
+end

data/lib/orb/parser.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require 'strscan'
+
+module ORB
+  # The `Parser` is responsible for converting a list of tokens produced
+  # by the `Lexer` into an Abstract Syntax Tree (AST). Any errors encountered
+  # during parsing are stored in `@errors` and can be accessed after parsing.
+  class Parser
+    attr_reader :tokens, :errors
+
+    class << self
+      def parse(tokens, options = {})
+        new(tokens, options).parse
+      end
+    end
+
+    # Create a new parser instance, use `Parser.parse` instead.
+    def initialize(tokens, options = {})
+      @tokens = tokens
+      @options = options
+      @errors = []
+
+      @root = ORB::AST::RootNode.new
+      @nodes = [@root]
+    end
+
+    # Parse the tokens into a tree of nodes. The `@current` index is used to
+    # keep track of the current token being parsed within the stream of tokens.
+    def parse
+      return @root if @tokens.empty?
+
+      @current = 0
+      next_token while @current < @tokens.length
+
+      # If there are any nodes left in the stack, they are unmatched tokens
+      raise ORB::ParserError, "Unmatched #{@nodes.last.class}" if @nodes.length > 1
+
+      # Return the root node
+      @root
+    end
+
+    alias_method :parse!, :parse
+
+    private
+
+    def next_token
+      token = @tokens[@current]
+
+      case token.type
+      when :public_comment
+        parse_public_comment(token)
+      when :private_comment
+        parse_private_comment(token)
+      when :text
+        parse_text(token)
+      when :printing_expression
+        parse_printing_expression(token)
+      when :control_expression
+        parse_control_expression(token)
+      when :block_open
+        parse_block_open(token)
+      when :block_close
+        parse_block_close(token)
+      when :tag_open
+        parse_tag(token)
+      when :tag_close
+        parse_tag_close(token)
+      when :newline
+        parse_newline(token)
+      else
+        raise ORB::ParserError, "Unknown token type: #{token.inspect}"
+      end
+    end
+
+    def parse_public_comment(token)
+      node = ORB::AST::PublicCommentNode.new(token)
+      current_node.children << node
+
+      @current += 1
+    end
+
+    def parse_private_comment(token)
+      node = ORB::AST::PrivateCommentNode.new(token)
+      current_node.children << node
+
+      @current += 1
+    end
+
+    def parse_text(token)
+      node = ORB::AST::TextNode.new(token)
+      current_node.children << node
+
+      @current += 1
+    end
+
+    def parse_tag(token)
+      node = ORB::AST::TagNode.new(token)
+
+      if node.self_closing?
+        current_node.children << node
+      else
+        @nodes << node
+      end
+
+      @current += 1
+    end
+
+    def parse_tag_close(token)
+      node = @nodes.pop
+      raise(ORB::ParserError, "Unmatched closing tag '#{token.value}'") unless node.is_a?(ORB::AST::TagNode)
+
+      current_node.children << node
+
+      @current += 1
+    end
+
+    def parse_printing_expression(token)
+      node = ORB::AST::PrintingExpressionNode.new(token)
+
+      if node.block?
+        @nodes << node
+      elsif node.end?
+        node = @nodes.pop
+        current_node.children << node
+      else
+        current_node.children << node
+      end
+
+      @current += 1
+    end
+
+    def parse_control_expression(token)
+      node = ORB::AST::ControlExpressionNode.new(token)
+
+      if node.block?
+        @nodes << node
+      elsif node.end?
+        node = @nodes.pop
+        current_node.children << node
+      else
+        current_node.children << node
+      end
+
+      @current += 1
+    end
+
+    def parse_block_open(token)
+      node = ORB::AST::BlockNode.new(token)
+      @nodes << node
+
+      @current += 1
+    end
+
+    def parse_block_close(token)
+      node = @nodes.pop
+      raise(ORB::ParserError, "Unmatched closing block '#{token.value}'") unless node.is_a?(ORB::AST::BlockNode)
+
+      current_node.children << node
+
+      @current += 1
+    end
+
+    def parse_newline(token)
+      node = ORB::AST::NewlineNode.new(token)
+      current_node.children << node
+
+      @current += 1
+    end
+
+    # Helpers
+
+    def current_node
+      @nodes.last
+    end
+
+    # Helper for raising exceptions during parsing
+    def parser_error!(message)
+      raise ORB::ParserError.new(message, @tokens[@current].line)
+    end
+  end
+end