opulent 1.5.5 → 1.6.0

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

@@ -1,36 +0,0 @@
-# @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

@@ -1,252 +0,0 @@
-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

data/.libold/opulent/parser/block.rb

@@ -1,70 +0,0 @@
-# @Opulent
-module Opulent
-  # @Parser
-  module Parser
-    # @Block
-    module Block
-      # Match a yield with a explicit or implicit target
-      #
-      # yield target
-      #
-      # @param parent [Node] Parent node to which we append the definition
-      #
-      def block_yield(parent)
-        if lookahead :yield_lookahead
-          # Get current line's indentation
-          indent = accept(:indent, false, false) || ""
-
-          if accept :yield
-            # Get definition name
-            yield_name = if(yield_name = accept(:yield_identifier, false, false))
-              yield_name.strip.to_sym
-            else
-              Engine::DEFAULT_YIELD
-            end
-
-            # Create a new node
-            node = @create.block_yield yield_name, parent, indent.size
-
-            # Consume the newline from the end of the element
-            error :yield unless accept(:line_feed, false, false).strip.empty?
-            accept :newline, false, false
-
-            return node
-          end
-        end
-      end
-
-      # Match a block with a explicit target
-      #
-      # block target
-      #
-      # @param parent [Node] Parent node to which we append the definition
-      #
-      def block(parent)
-        if lookahead :block_lookahead
-          # Get current line's indentation
-          indent = accept_unstripped(:indent) || ""
-
-          if accept :block
-            # Get definition name
-            block_name = if(block_name = accept_unstripped(:yield_identifier))
-              block_name.strip.to_sym
-            else
-              Engine::DEFAULT_YIELD
-            end
-
-            # Create a new node
-            node = @create.block block_name, parent, indent.size
-
-            # Consume the newline from the end of the element
-            error :block unless accept_unstripped(:line_feed).strip.empty?
-            accept_unstripped :newline
-
-            return node
-          end
-        end
-      end
-    end
-  end
-end

data/.libold/opulent/parser/comment.rb

@@ -1,32 +0,0 @@
-# @SugarCube
-module Opulent
-  # @Parser
-  module Parser
-    # @Text
-    module Comment
-      # Match one line or multiline comments
-      #
-      def comment(parent)
-        if lookahead(:comment_lookahead)
-          indent = accept_unstripped(:indent) || ""
-          indent = indent.size
-
-          if (comment_feed = accept_unstripped :comment)
-            comment_feed += accept_unstripped(:newline) || ""
-            comment_feed += get_indented_lines indent
-
-            # If we have a comment which is visible in the output, we will
-            # create a new comment element. Otherwise, we ignore the current
-            # gathered text and we simply begin the root parsing again
-            if comment_feed[0] == '!'
-              return @create.comment comment_feed[1..-1].strip, parent, indent
-            else
-              root parent
-              return nil
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/.libold/opulent/parser/control.rb

@@ -1,83 +0,0 @@
-# @SugarCube
-module Opulent
-  # @Parser
-  module Parser
-    # @Control
-    module Control
-      # Match an if-else control structure
-      #
-      def control(parent)
-        if lookahead :control_lookahead
-          indent = indent || accept_unstripped(:indent) || ""
-
-          # Accept eval or multiline eval syntax and return a new node,
-          if (structure = accept_unstripped(:control))
-            structure = structure.to_sym
-
-            # Handle each and the other control structures
-            condition = accept_unstripped(:line_feed).strip
-            accept_unstripped :newline
-
-            # Process each control structure condition
-            if structure == :each
-              # Check if arguments provided correctly
-              error :each_arguments unless condition.match Tokens[:each_pattern][:regex]
-
-              # Split provided arguments for the each structure
-              condition = condition.split('in').map(&:strip)
-              condition[0] = condition[0].split(',').map(&:strip).map(&:to_sym)
-            end
-
-            # Else and default structures are not allowed to have any condition
-            # set and the other control structures require a condition
-            if structure == :else
-              error :condition_exists unless condition.empty?
-            else
-              error :condition_missing if condition.empty?
-            end
-
-            # Add the condition and create a new child to the control parent.
-            # The control parent keeps condition -> children matches for our
-            # document's content
-            add_options = Proc.new do |control_parent|
-              control_parent.value << condition
-              control_parent.children << []
-
-              root control_parent
-            end
-
-            # If the current control structure has a matching parent, we search
-            # for that type of element in the siblings with the same indentation
-            # otherwise we return a new control structure parent
-            if (parent_type = control_parent structure)
-              begin
-                last = -1
-                until parent_type.include? parent.children[last].name
-                  last -= 1
-                end
-                add_options[parent.children[last]]
-              rescue NoMethodError
-                error :control_parent
-              end
-            else
-              control_node = @create.control(structure, condition, parent, indent.size)
-            end
-
-            control_node
-          end
-        end
-      end
-
-      # Check if the current control structure requires a parent node and
-      # return the parent's node type
-      #
-      def control_parent(structure)
-        case structure
-        when :else then [:if, :unless, :case]
-        when :elsif then [:if]
-        when :when then [:case]
-        end
-      end
-    end
-  end
-end