opulent 0.0.9 → 1.0.2

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

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

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

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

data/.libold/opulent/parser/define.rb

@@ -0,0 +1,39 @@
+# @Opulent
+module Opulent
+  # @Parser
+  module Parser
+    # @Define
+    module Define
+      # Match a definition node with its parameters and body
+      #
+      # def node_name[ parameters ]
+      #   body nodes
+      #
+      # @param parent [Node] Parent node to which we append the definition
+      #
+      def define(parent)
+        if lookahead :def_lookahead
+          # Get current line's indentation
+          indent = accept_unstripped(:indent) || ""
+
+          if accept :def
+            # Get definition name
+            def_name = accept :identifier, :*
+
+            # Get element attributes
+            atts = attributes({}) || {}
+
+            # Create a new node
+            node = @create.definition def_name.to_sym, atts, parent, indent.size
+
+            # Consume the newline from the end of the element
+            error :define unless accept_unstripped(:line_feed).strip.empty?
+            accept_unstripped :newline
+
+            return node
+          end
+        end
+      end
+    end
+  end
+end

data/.libold/opulent/parser/eval.rb

@@ -0,0 +1,33 @@
+# @SugarCube
+module Opulent
+  # @Parser
+  module Parser
+    # @Text
+    module Evaluate
+      # Match one line or multiline, escaped or unescaped text
+      #
+      def evaluate(parent)
+        indent = indent || accept_unstripped(:indent) || ""
+
+        # Accept eval or multiline eval syntax and return a new node,
+        if (evaluate = accept_unstripped(:eval))
+          eval_node = @create.evaluate(evaluate.strip, parent, indent.size)
+          accept_unstripped :newline
+        elsif (evaluate = accept_unstripped(:eval_multiline))
+          # Get all the lines which are more indented than the current one
+          eval_node = @create.evaluate(evaluate.strip, parent, indent.size)
+          eval_node.value += accept_unstripped(:newline) || ""
+          eval_node.value += get_indented_lines(indent.size)
+        end
+
+        if eval_node
+          # Return the found eval node
+          return eval_node
+        else
+          # Undo by adding the found intentation back
+          return undo indent
+        end
+      end
+    end
+  end
+end

data/.libold/opulent/parser/expression.rb

@@ -0,0 +1,350 @@
+# @Opulent
+module Opulent
+  # @Parser
+  module Parser
+    # @Expression
+    module Expression
+      # Check if the parser matches an expression node
+      #
+      def expression(allow_assignments = true, wrapped = true)
+        buffer = ""
+
+        # Build a ruby expression out of accepted literals
+        while (term = whitespace                                        ||
+                      modifier                                          ||
+                      identifier                                        ||
+                      method_call                                       ||
+                      paranthesis                                       ||
+                      array                                             ||
+                      hash                                              ||
+                      symbol                                            ||
+                      percent                                           ||
+                      primary_term                                      ||
+                      (allow_assignments ? accept(:exp_assignment) : nil))
+          buffer += term
+
+          # Accept operations which have a right term and raise an error if
+          # we have an unfinished expression such as "a +", "b - 1 >" and other
+          # expressions following the same pattern
+          if wrapped && (op = operation)
+            buffer += op
+            if (right_term = expression(allow_assignments, wrapped)).nil?
+              error :expression
+            else
+              buffer += right_term.value
+            end
+          elsif (conditional = ternary_operator allow_assignments, wrapped)
+            buffer += conditional
+          end
+
+          # Do not continue if the expression has whitespace method calls in
+          # an unwrapped context because this will confuse the parser
+          unless buffer.strip.empty?
+            break unless wrapped || lookahead(:exp_identifier_lookahead, false)
+          end
+        end
+
+        if buffer.strip.empty?
+          return undo buffer
+        else
+          return @create.expression buffer
+        end
+      end
+
+      # Check if it's possible to parse a ruby array literal. First, try to see
+      # if the next sequence is a hash_open token: "[", and if it is, then a
+      # hash_close: "]" token is required next
+      #
+      # [array_elements]
+      #
+      def array
+        if (buffer = accept :array_open)
+          accept_unstripped :newline
+          buffer += array_elements
+          buffer += accept :array_close, :*
+        end
+      end
+
+      # Recursively gather expressions separated by a comma and add them to the
+      # expression buffer
+      #
+      # experssion1, experssion2, experssion3
+      #
+      # @param buffer [String] Accumulator for the array elements
+      #
+      def array_elements(buffer = '')
+        if (term = expression)
+          buffer += term.value
+          # If there is an array_terminator ",", recursively gather the next
+          # array element into the buffer
+          if (terminator = accept :array_terminator) then
+            accept_unstripped :newline
+            buffer += array_elements terminator
+          end
+        end
+
+        # Array ended prematurely with a trailing comma, therefore the current
+        # parsing process will stop
+        if buffer.strip[-1] == ','
+          error :array_elements_terminator
+        end
+
+        buffer
+      end
+
+      # Check if it's possible to parse a ruby hash literal. First, try to see
+      # if the next sequence is a hash_open token: "{", and if it is, then a
+      # hash_close: "}" token is required next
+      #
+      # { hash_elements }
+      #
+      def hash
+        if (buffer = accept :hash_open)
+          accept_unstripped :newline
+          buffer += hash_elements
+          buffer += accept :hash_close, :*
+        end
+      end
+
+      # Recursively gather expression attributions separated by a comma and add
+      # them to the expression buffer
+      #
+      # key1: experssion1, key2 => experssion2, :key3 => experssion3
+      #
+      # @param buffer [String] Accumulator for the hash elements
+      #
+      def hash_elements(buffer = '')
+        value = Proc.new do
+          # Get the value associated to the current hash key
+          if (exp = expression)
+            buffer += exp.value
+          else
+            error :hash_elements
+          end
+
+          # If there is an hash_terminator ",", recursively gather the next
+          # array element into the buffer
+          if (terminator = accept :hash_terminator) then
+            accept_unstripped :newline
+            buffer += hash_elements terminator
+          end
+        end
+
+        # Accept both shorthand and default ruby hash style. Following DRY
+        # principles, a Proc is used to assign the value to the current key
+        #
+        # key:
+        # :key =>
+        if (symbol = accept :hash_symbol)
+          buffer += symbol
+          value[]
+        elsif (exp = expression)
+          buffer += exp.value
+          if(assign = accept :hash_assignment)
+            buffer += assign
+            value[]
+          else
+            error :hash_assignment
+          end
+        end
+
+        # Array ended prematurely with a trailing comma, therefore the current
+        # parsing process will stop
+        if buffer.strip[-1] == ','
+          error :hash_elements_terminator
+        end
+
+        buffer
+      end
+
+      # Accept a ruby identifier such as a class, module, method or variable
+      #
+      def identifier
+        if (buffer = accept_line_unstripped :exp_identifier)
+          if (args = call)
+            buffer += args
+          end
+          return buffer
+        end
+      end
+
+      # Check if it's possible to parse a ruby paranthesis expression wrapper.
+      #
+      def paranthesis
+        if (buffer = accept :round_bracket_open)
+          accept_unstripped :newline
+          buffer += expression.to_s
+          buffer += accept :round_bracket_close, :*
+        end
+      end
+
+      # Check if it's possible to parse a ruby call literal. First, try to see
+      # if the next sequence is a hash_open token: "(", and if it is, then a
+      # hash_close: ")" token is required next
+      #
+      # ( call_elements )
+      #
+      def call
+        if (buffer = accept_unstripped :round_bracket_open)
+          accept_unstripped :newline
+          buffer += call_elements
+          buffer += accept :round_bracket_close, :*
+        end
+      end
+
+      # Recursively gather expression attributes separated by a comma and add
+      # them to the expression buffer
+      #
+      # expression1, a: expression2, expression3
+      #
+      # @param buffer [String] Accumulator for the call elements
+      #
+      def call_elements(buffer = '')
+        # Accept both shorthand and default ruby hash style. Following DRY
+        # principles, a Proc is used to assign the value to the current key
+        #
+        # key: value
+        # :key => value
+        # value
+        if (symbol = accept :hash_symbol)
+          buffer += symbol
+
+          # Get the value associated to the current hash key
+          if (exp = expression(true))
+            buffer += exp.value
+          else
+            error :call_elements
+          end
+
+          # If there is an comma ",", recursively gather the next
+          # array element into the buffer
+          if (terminator = accept :comma) then
+            accept_unstripped :newline
+            buffer += call_elements terminator
+          end
+        elsif (exp = expression(true))
+          buffer += exp.value
+
+          if(assign = accept :hash_assignment)
+            buffer += assign
+
+            # Get the value associated to the current hash key
+            if (exp = expression(true))
+              buffer += exp.value
+            else
+              error :call_elements
+            end
+          end
+
+          # If there is an comma ",", recursively gather the next
+          # array element into the buffer
+          if (terminator = accept :comma) then
+            accept_unstripped :newline
+            buffer += call_elements terminator
+          end
+        end
+
+        buffer
+      end
+
+      # Accept a ruby symbol defined through a colon and a trailing expression
+      #
+      # :'symbol'
+      # :symbol
+      #
+      def symbol
+        if (colon = accept :colon)
+          return undo colon if lookahead(:whitespace_lookahead, false)
+
+          if (exp = expression).nil?
+            error :symbol
+          else
+            colon + exp.to_s
+          end
+        end
+      end
+
+      # Accept a ruby module, method or context modifier
+      #
+      # Module::
+      # @, @@, $
+      #
+      def modifier
+        accept(:exp_context) || accept(:exp_module)
+      end
+
+
+      # Accept a ruby percentage operator for arrays of strings, symbols and
+      # simple escaped strings
+      #
+      # %w(word1 word2 word3)
+      #
+      def percent
+        if (buffer = accept :exp_percent)
+          match_start = buffer[-1]
+          match_name = :"percent#{match_start}"
+
+          unless Tokens[match_name]
+            match_end = Tokens.bracket(match_start) || match_start
+
+            match_inner = "\\#{match_start}"
+            match_inner += "\\#{match_end}" unless match_end == match_start
+
+            pattern = /(((?:[^#{match_inner}\\]|\\.)*?)#{'\\' + match_end})/
+
+            Tokens[match_name] = Tokens::Token.new pattern
+          end
+
+          buffer += accept match_name
+        end
+      end
+
+      # Accept any primary term and return it without the leading whitespace to
+      # the expression buffer
+      #
+      # "string"
+      # 123
+      # 123.456
+      # nil
+      # true
+      # false
+      # /.*/
+      #
+      def primary_term
+        accept(:exp_string)     ||
+        accept(:exp_fixnum)     ||
+        accept(:exp_double)     ||
+        accept(:exp_nil)        ||
+        accept(:exp_regex)      ||
+        accept(:exp_boolean)
+      end
+
+      # Accept an operation between two or more expressions
+      #
+      def operation
+        accept_unstripped(:exp_operation)
+      end
+
+      # Accept a ruby method call modifier
+      #
+      def method_call
+        accept_unstripped(:exp_method_call)
+      end
+
+      # Accept ternary operator syntax
+      #
+      # condition ? expression1 : expression2
+      #
+      def ternary_operator(allow_assignments, wrapped)
+        if (buffer = accept_line_unstripped :exp_ternary)
+          buffer += expression(allow_assignments, wrapped).to_s
+          if (else_branch = accept_line_unstripped :exp_ternary_else)
+            buffer += else_branch
+            buffer += expression(allow_assignments, wrapped).to_s
+          end
+          return buffer
+        end
+      end
+    end
+  end
+end