opulent 0.0.9 → 1.0.2

data/.libold/opulent/nodes/helper.rb

@@ -0,0 +1,69 @@
+# @Opulent
+module Opulent
+  # @Nodes
+  module Nodes
+    # @NodeFactory
+    class Helper
+      def root
+        Root.new
+      end
+
+      def node(name = '', atts = {}, parent = nil, indent = 0, children = [])
+        Node.new name, atts, parent, indent, children
+      end
+
+      def block_yield(name = '', parent = nil, indent = 0, children = [])
+        Yield.new name, {}, parent, indent, children
+      end
+
+      def block(name = '', parent = nil, indent = 0, children = [])
+        Block.new name, {}, parent, indent, children
+      end
+
+      def theme(name = '', parent = nil, indent = 0, children = [])
+        Theme.new name, parent, indent, children
+      end
+
+      def filter(name = '', atts = {}, parent = nil, indent = 0, value = '')
+        Filter.new name, atts, parent, indent, value
+      end
+
+      def evaluate(value, parent = nil, indent = 0, children = [])
+        Evaluate.new value, parent, indent, children
+      end
+
+      def control(name, value = '', parent = nil, indent = 0, children = [[]])
+        case name
+        when :if, :unless
+          CnditionalControl.new name, value, parent, indent, children
+        when :case
+          CaseControl.new name, value, parent, indent, children.first
+        when :while, :until
+          LoopControl.new name, value, parent, indent, children.first
+        when :each
+          EachControl.new name, value, parent, indent, children.first
+        end
+      end
+
+      def expression(value = [])
+        Expression.new value
+      end
+
+      def definition(name, params = [], parent = nil, indent = 0)
+        Define.new name, params, parent, indent
+      end
+
+      def text(value = nil, escaped = true, parent = nil, indent = 0)
+        Text.new value, escaped, parent, indent
+      end
+
+      def print(value = nil, escaped = true, parent = nil, indent = 0)
+        Print.new value, escaped, parent, indent
+      end
+
+      def comment(value = nil, parent = nil, indent = 0)
+        Comment.new value, parent, indent
+      end
+    end
+  end
+end

data/.libold/opulent/nodes/node.rb

@@ -0,0 +1,101 @@
+# @Opulent
+module Opulent
+  # @Nodes
+  module Nodes
+    # @Node
+    #
+    # Node class used to describe a HTML Element used for building a
+    # page model during the parsing process
+    #
+    class Node
+      # Allow direct access to node variables
+      attr_accessor :name, :attributes, :children, :whitespace, :parent, :indent, :extension, :theme, :blocks, :yields, :self_enclosing
+
+      # Initialize node instance variables
+      #
+      # @param name [String] name of the html node
+      # @param indentation [Fixnum] node indentation for restructuring
+      # @param attributes [Hash] stores key="value" attributes
+      # @param children [Array] collection of the node's child elements
+      #
+      def initialize(name = '', attributes = {}, parent = nil, indent = 0, children = [])
+        @name = name
+        @parent = parent
+        @indent = indent
+        @attributes = attributes
+        @children = children
+        @extension = nil
+        @theme = Engine::DEFAULT_THEME
+        @self_enclosing = Engine::SELF_ENCLOSING.include? name
+        @whitespace = [nil, nil]
+        @blocks = {
+          Engine::DEFAULT_YIELD => @children
+        }
+        @yields = []
+      end
+
+      # Add a new node to the nodes array
+      #
+      def push(node)
+        @children << node
+        self
+      end
+
+      # Return extended attributes if an extension was set using the [extend]
+      # identifier of the node
+      #
+      def extend_attributes(attributes, extension)
+        return attributes if extension.nil?
+
+        extension.each do |key, value|
+          case attributes[key]
+          when Array
+            attributes[key] = (attributes[key] << value).flatten
+          when Hash
+            attributes[key] = value.merge attributes[key]
+          when nil
+            attributes[key] = value
+          end
+        end
+
+        attributes
+      end
+
+      # Node evaluation method which goes through all the child nodes and evaluates
+      # them using their own eval method
+      #
+      def evaluate(context)
+        # Set attributes for current context
+        attributes = Runtime.attributes @attributes, @extension, context
+
+        # Evaluate all provided blocks
+        blocks = Hash[@blocks.map{ |key, value|
+          children = value.map do |child|
+            child.evaluate context
+          end.flatten.compact
+
+          [key, children]
+        }]
+
+        # Map self to a different node and set evaluated children nodes and
+        # evaluated attributes and add a pointer to the children block
+        mapped_node = self.dup
+        mapped_node.attributes = attributes
+        mapped_node.blocks = blocks
+        mapped_node.children = mapped_node.blocks[Engine::DEFAULT_YIELD]
+
+        # Replace node with its definition if it has one
+        if Runtime[@theme]
+          if Runtime[@theme][@name] && @name != context.name
+            return Runtime.define mapped_node, attributes, context
+          else
+            return mapped_node
+          end
+        else
+          # Theme does not exist
+          Runtime.error :theme, @theme
+        end
+      end
+    end
+  end
+end

data/.libold/opulent/nodes/root.rb

@@ -0,0 +1,62 @@
+# @Opulent
+module Opulent
+  # @Nodes
+  module Nodes
+    # @Root
+    #
+    # HTML Root from which the construction of the final page starts. The root
+    # stores all the node definitions that will be replaced in the components.
+    #
+    class Root
+      # Allow direct access to node variables
+      attr_accessor :themes, :children, :indent, :blocks, :yields
+
+      # Initialize node instance variables
+      #
+      # @param definitions [Hash] node definitions to be replaced in children
+      # @param children [Array] collection of the node's child elements
+      #
+      def initialize
+        @themes = {
+          Engine::DEFAULT_THEME => {}
+        }
+        @children = []
+        @blocks = {}
+        @yields = {}
+        @indent = -1
+      end
+
+      # Add a new node to the nodes array
+      #
+      # @param node [Node] Node to be added to the parent
+      #
+      def push(node)
+        @children << node
+        self
+      end
+
+      # Shorthand theme access for root definitions
+      #
+      # @param key [Symbol] definition or theme name
+      #
+      def [](key)
+        if @themes.has_key? key
+          @themes[key]
+        else
+          @themes[Engine::DEFAULT_THEME][key]
+        end
+      end
+
+      # Evaluate all child nodes using the given context and the
+      # node definitions from the root knowledgebase
+      #
+      # @param context [Context] Call environment binding object
+      #
+      def evaluate(context)
+        @children.map do |node|
+          node.evaluate(context)
+        end.flatten.compact
+      end
+    end
+  end
+end

data/.libold/opulent/nodes/text.rb

@@ -0,0 +1,54 @@
+# @Opulent
+module Opulent
+  # @Nodes
+  module Nodes
+    # @Text
+    #
+    # The text class will output raw or escaped HTML text
+    #
+    class Text
+      # Allow direct access to literal value and type
+      attr_accessor :value, :escaped, :parent, :indent, :name
+
+      # Initialize literal instance variables
+      #
+      # @param value stores the literal's explicit value
+      #
+      def initialize(value = nil, escaped = true, parent = nil, indent = 0)
+        @value = value
+        @escaped = escaped
+        @parent = parent
+        @indent = indent
+        @name = :text
+      end
+
+      # Value evaluation method which returns the processed value of the
+      # literal
+      #
+      def evaluate(context)
+        value = context.evaluate "\"#{@value}\""
+
+        evaluated_text = self.dup
+        evaluated_text.value = @escaped ? Runtime.escape(value) : value
+        return evaluated_text
+      end
+    end
+
+    # @Print
+    #
+    # The print class will evaluate the ruby code and return a new text
+    # node containing the escaped or unescaped eval sequence
+    #
+    class Print < Text
+      # Value evaluation method which returns the processed value of the literal
+      #
+      def evaluate(context)
+        value = context.evaluate @value
+
+        evaluated_text = self.dup
+        evaluated_text.value = @escaped ? Runtime.escape(value) : value
+        return evaluated_text
+      end
+    end
+  end
+end

data/.libold/opulent/nodes/theme.rb

@@ -0,0 +1,36 @@
+# @Opulent
+module Opulent
+  # @Nodes
+  module Nodes
+    # @Theme
+    #
+    # Node class used to describe a HTML Element used for building a
+    # page model during the parsing process
+    #
+    class Theme
+      # Allow direct access to node variables
+      attr_accessor :name, :indent, :parent, :children
+
+      # Initialize node instance variables
+      #
+      # @param name [String] name of the html node
+      # @param indentation [Fixnum] node indentation for restructuring
+      # @param attributes [Hash] stores key="value" attributes
+      # @param children [Array] collection of the node's child elements
+      #
+      def initialize(name = '', parent = nil, indent = 0, children = [])
+        @name = name
+        @parent = parent
+        @indent = indent
+        @children = children
+      end
+
+      # Add a new node to the nodes array
+      #
+      def push(node)
+        @children << node
+        self
+      end
+    end
+  end
+end

data/.libold/opulent/parser.rb

@@ -0,0 +1,252 @@
+require_relative 'parser/root'
+require_relative 'parser/node'
+require_relative 'parser/eval'
+require_relative 'parser/expression'
+require_relative 'parser/define'
+require_relative 'parser/text'
+require_relative 'parser/filter'
+require_relative 'parser/control'
+require_relative 'parser/theme'
+require_relative 'parser/block'
+require_relative 'parser/comment'
+
+# @Opulent
+module Opulent
+  # @Lexer
+  module Parser
+    # @Singleton
+    class << self
+      # Include Opulent tokens regular expressions to be checked using the
+      # accept (or expect) method together with lookahead expressions
+      include Root
+      include Node
+      include Expression
+      include Evaluate
+      include Define
+      include Text
+      include Filter
+      include Control
+      include Theme
+      include Block
+      include Comment
+
+      # Analyze the input code and check for matching tokens.
+      # In case no match was found, throw an exception.
+      # In special cases, modify the token hash.
+      #
+      # @param code [String] Opulent code that needs to be analyzed
+      # @return Nodes array
+      #
+      def parse(code)
+        # Code to be parsed
+        @code = code
+
+        # Keeps track of consumed code
+        @consumed = ""
+
+        # Current line being parsed, used for error reporting
+        @current_line = 1
+
+        # Node creation wrapper for comprehensible node creation
+        @create = Nodes::Helper.new
+
+        # Create root node, our wrapper for all the HTML elements we use
+        # which knows how to evaluate each of them to output the final code
+        # The root also stores custom node definitions collection from which we
+        # replace the nodes which use them
+        @root = @create.root
+
+        # Loop until we have no tokens left to parse or we find an error
+        root @root
+
+        # We still have code left to parse
+        error :root unless @code.strip.empty?
+
+        return @root
+      end
+
+      # Accept and consume or reject a given token as long as we have tokens
+      # remaining. Shift the code with the match length plus any extra character
+      # count around the capture group
+      #
+      # @param identifier [RegEx] Token syntax to be accepted by the parser
+      # @param required [Boolean] Expect the given token syntax
+      # @param strip [Boolean] Left strip the current code to remove whitespace
+      #
+      def accept(identifier, required = false, strip = true)
+        # Get token from tokens knowledgebase
+        token = Tokens[identifier]
+
+        # If the token's capture group is smaller than the whole match,
+        # advance the code chunk with more spaces
+        extra = token[:extra] || 0
+
+        # Remove leading whitespace between expressions
+        if @code && strip
+          if (stripped = @code[/\A +/]) then @consumed += stripped end
+          @code.lstrip!
+        end
+
+        # Check to see if
+        if @code =~ token[:regex]
+          @current_line += 1 if identifier == :newline
+
+          shift = $1.size + extra
+
+          @consumed += @code[0..shift - 1] if shift > 0
+          @code = @code[shift..-1]
+
+          return $1
+        elsif required
+          error :expect, identifier
+        else
+          return nil
+        end
+      end
+
+      # Accept and consume or reject a given token as long as we have tokens
+      # remaining on the current line only. Shift the code with the match length
+      # plus any extra character count around the capture group
+      #
+      # @param identifier [RegEx] Token syntax to be accepted by the parser
+      # @param required [Boolean] Expect the given token syntax
+      # @param strip [Boolean] Left strip the current code to remove whitespace
+      #
+      def accept_line(identifier, required = false, strip = true)
+        # Get token from tokens knowledgebase
+        token = Tokens[identifier]
+
+        # If the token's capture group is smaller than the whole match,
+        # advance the code chunk with more spaces
+        extra = token[:extra] || 0
+
+        # Remove leading whitespace between expressions
+        if @code.lines.first && strip
+          if (stripped = @code.lines.first[/\A +/]) then @consumed += stripped end
+          @code.gsub! /\A +/, ''
+        end
+
+        # Check to see if
+        if @code.lines.first =~ token[:regex]
+          @current_line += 1 if identifier == :newline
+
+          shift = $1.size + extra
+
+          @consumed += @code[0..shift - 1] if shift > 0
+          @code = @code[shift..-1]
+
+          return $1
+        elsif required
+          error :expect, identifier
+        else
+          return nil
+        end
+      end
+
+      # Wrapper method for accepting unstripped tokens such as whitespace or a
+      # certain required sequence directly
+      #
+      # @param identifier [RegEx] Token syntax to be accepted by the parser
+      # @param required [Boolean] Expect the given token syntax
+      #
+      def accept_unstripped(identifier, required = false)
+        accept(identifier, required, false)
+      end
+
+      # Wrapper method for accepting unstripped tokens such as whitespace or a
+      # certain required sequence directly on the current line only
+      #
+      # @param identifier [RegEx] Token syntax to be accepted by the parser
+      # @param required [Boolean] Expect the given token syntax
+      #
+      def accept_line_unstripped(identifier, required = false)
+        accept_line(identifier, required, false)
+      end
+
+      # Look ahead in the current code to see if we can match an input token.
+      # No modifications will be done to the code.
+      #
+      # @param token [RegEx] Token syntax to be accepted by the parser
+      # @param strip [Boolean] Left strip the current code to remove whitespace
+      #
+      def lookahead(token, strip = true)
+        # Get token from tokens knowledgebase
+        token = Tokens[token]
+
+        # We don't want to modify anything in the code directly, so we use a
+        # local code variable
+        code = @code
+
+        # Remove leading whitespace between expressions
+        code = code.lstrip if code && strip
+
+        # Check to see if
+        if code =~ token[:regex]
+          return $~[:capture]
+        else
+          return nil
+        end
+      end
+
+      # Undo a found match by removing the token from the consumed code and
+      # adding it back to the code chunk
+      #
+      # @param match [String] Matched string to be undone
+      #
+      def undo(match)
+        unless match.empty?
+          @consumed = @consumed[0..-match.length]
+          @code = match + @code
+          return nil
+        end
+      end
+
+      # Give an explicit error report where an unexpected sequence of tokens
+      # appears and give indications on how to solve it
+      #
+      # @param context [Symbol] Context name in which the error happens
+      # @param data [Array] Additional error information
+      #
+      def error(context, *data)
+        consumed = @consumed.lines.last.strip if @consumed.lines.last
+        code = @code.empty? ? ' END' : @code.lines.first.strip
+
+        message = case context
+        when :root
+          "Unknown node type encountered on line #{@current_line} of input at:\n\n" +
+          "#{consumed}" + Logger.red(code)
+        when :expect
+          "Expected to find token :#{data[0]} on line #{@current_line} of input at:\n\n" +
+          "#{consumed}" + Logger.red(code)
+        when :assignments_colon
+          "Unexpected end of element attributes reached on line #{@current_line} of input.\n\n" +
+          "Expected to find an attribute at:\n\n" +
+          "#{consumed}" + Logger.red(code)
+        when :assignments_comma
+          "Unexpected end of element attributes reached on line #{@current_line} of input.\n\n" +
+          "Expected to find an attribute value at:\n\n" +
+          "#{consumed}" + Logger.red(code)
+        when :expression
+          "Unexpected end of expression reached on line #{@current_line} of input.\n\n" +
+          "Expected to find another expression term at:\n\n" +
+          "#{consumed}" + Logger.red(code)
+        when :whitespace_expression
+          "Unexpected end of expression reached on line #{@current_line} of input.\n\n" +
+          "Please use paranthesis for method parameters at:\n\n" +
+          "#{consumed}" + Logger.red(code)
+        when :definition
+          "Unexpected start of definition on line #{@current_line - 1} of input.\n\n" +
+          "Found a definition inside another definition or element at:\n\n" +
+          (@consumed.lines[-2] || "") + Logger.red(consumed + "\n  " + code)
+        else
+          "#{consumed}" + Logger.red(code)
+        end
+
+        # Reconstruct lines to display where errors occur
+        fail "\n\nOpulent " + Logger.red("[Parser Error]") + "\n---\n" +
+        "A parsing error has been encountered in the \"#{context}\" context.\n" +
+        "#{message}\n\n\n"
+      end
+    end
+  end
+end