opulent 1.5.5 → 1.6.0

data/lib/opulent/parser.rb

@@ -22,7 +22,7 @@ module Opulent
     #
     # [:node_type, :value, :attributes, :children, :indent]
     #
-    def initialize(file, definitions)
+    def initialize(settings = {})
       # Convention accessors
       @type = 0
       @value = 1
@@ -30,17 +30,20 @@ module Opulent
       @children = 3
       @indent = 4
 
+      # Inherit settings from Engine
+      @settings = settings
+
       # Set current compiled file as the first in the file stack together with
       # its base indentation. The stack is used to allow include directives to
       # be used with the last parent path found
-      @file = [[file, -1]]
+      @file = [[@settings.delete(:file), -1]]
 
       # Create a definition stack to disallow recursive calls. When inside a
       # definition and a named node is called, we render it as a plain node
       @definition_stack = []
 
       # Initialize definitions for the parser
-      @definitions = definitions
+      @definitions = @settings.delete(:def) || {}
     end
 
     # Initialize the parsing process by splitting the code into lines and
@@ -57,6 +60,9 @@ module Opulent
       # Current line index
       @i = -1
 
+      # Current character index
+      @j = 0
+
       # Initialize root node
       @root = [:root, nil, {}, [], -1]
 
@@ -64,7 +70,7 @@ module Opulent
       # nodes and definitions
       root @root
 
-      return @root, @definitions
+      [@root, @definitions]
     end
 
     # Check and accept or reject a given token as long as we have tokens
@@ -88,10 +94,11 @@ module Opulent
       if (match = @line[@offset..-1].match(Tokens[token]))
         # Advance current offset with match length
         @offset += match[0].size
+        @j += match[0].size
 
         return match[0]
       elsif required
-        error :expected, token
+        Logger.error :parse, @code, @i, @j, :expected, token
       end
     end
 
@@ -144,6 +151,7 @@ module Opulent
     def accept_newline
       return unless @line[@offset..-1].strip.empty?
       @line = @code[(@i += 1)]
+      @j = 0
       @offset = 0
     end
 
@@ -154,77 +162,7 @@ module Opulent
     #
     def indent_lines(text, indent)
       text ||= ''
-      text.lines.inject('') do |result, line|
-        result += indent + line
-      end
-    end
-
-    # Give an explicit error report where an unexpected sequence of tokens
-    # appears and give indications on how to solve it
-    #
-    # @param message [Symbol] Error message to display to the user
-    #
-    def error(error, *data)
-      message = case error
-      when :unknown_node_type
-        "An unknown node type has been encountered at:\n\n#{Logger.red @line}"
-      when :expected
-        if [:'(', :'{', :'[', :'<'].include? data[0]
-          data[0] = "#{Tokens.bracket data[0]}"
-        end
-        "Expected to find a :#{data[0]} token on line #{@i+1} of input at: " \
-        "\n\n#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
-      when :root
-        "Unknown node type encountered on line #{@i+1} of input at:\n\n" +
-        "#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
-      when :assignments_colon
-        "Unexpected end of element attributes reached on line #{@i+1} of input.\n\n" +
-        "Expected to find an attribute at:\n\n" +
-        "#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
-      when :assignments_comma
-        "Unexpected end of element attributes reached on line #{@i+1} of input.\n\n" +
-        "Expected to find an attribute value at:\n\n" +
-        "#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
-      when :expression
-        "Unexpected end of expression reached on line #{@i+1} of input.\n\n" +
-        "Expected to find another expression term at:\n\n" +
-        "#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
-      when :control_child
-        "Unexpected control structure child found on line #{@i+1} of input.\n\n" +
-        "Expected to find a parent #{data[0]} structure at:\n\n" +
-        "#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
-      when :case_children
-        "Unexpected control structure child found on line #{@i+1} of input.\n\n" +
-        "Case structure cannot have any child elements at:\n\n" +
-        "#{@code[@i-1][0..@offset-1]}#{Logger.red @code[@i][@offset..-1].rstrip}"
-      when :whitespace_expression
-        "Unexpected end of expression reached on line #{@i+1} of input.\n\n" +
-        "Please use paranthesis for method parameters at:\n\n" +
-        "#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
-      when :definition
-        "Unexpected start of definition on line #{@i+1} of input.\n\n" +
-        "Found a definition inside another definition or element at:\n\n" +
-        "#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
-      when :self_enclosing
-        "Unexpected content found after self enclosing node on line #{@i+1} of input at:\n\n" +
-        "#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
-      when :self_enclosing_children
-        "Unexpected child elements found for self enclosing node on line #{data[0]+1} of input at:\n\n" +
-        "#{@code[data[0]]}#{Logger.red @code[data[0] + 1]}"
-      when :include
-        "The included file #{data[0]} does not exist or an incorrect path has been specified."
-      when :include_dir
-        "The included file path #{data[0]} is a directory."
-      when :include_end
-        "Missing argument for include on line #{@i+1} of input at:\n\n" +
-        "#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
-      else
-        "#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
-      end
-
-      # Reconstruct lines to display where errors occur
-      fail "\n\nOpulent " + Logger.red('[Parser Error]') +
-      "\n---\n#{message}\n\n\n"
+      text.lines.map { |line| indent + line }.join
     end
   end
 end

data/lib/opulent/parser/comment.rb

@@ -1,34 +1,45 @@
-# @Opulent
-module Opulent
-  # @Parser
-  class Parser
-    # Match one line or multiline comments
-    #
-    def comment(parent, indent)
-      if (accept :comment)
-        multiline = true if (accept :comment)
-
-        buffer = accept(:line_feed)
-        buffer += accept(:newline) || ""
-        buffer += get_indented_lines indent if multiline
-
-
-        # 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 buffer[0] == '!'
-          offset = 1; options = {}
-
-          # Allow leading comment newline
-          if buffer[1] == '^'
-            offset = 2; options[:newline] = true
-          end
-
-          parent[@children] << [:comment, buffer[offset..-1].strip, options, nil, indent]
-        end
-
-        return parent
-      end
-    end
-  end
-end
+# @Opulent
+module Opulent
+  # @Parser
+  class Parser
+    # Match one line or multiline comments
+    #
+    # @param parent [Node] Parent node of comment
+    # @param indent [Fixnum] Number of indentation characters
+    #
+    def comment(parent, indent)
+      return unless accept :comment
+
+      # Get first comment line
+      buffer = accept(:line_feed)
+      buffer += accept(:newline) || ''
+
+      # Get indented comment lines
+      buffer += 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 buffer[0] == '!'
+        offset = 1
+        options = {}
+
+        # Allow leading comment newline
+        if buffer[1] == '^'
+          offset = 2
+          options[:newline] = true
+        end
+
+        parent[@children] << [
+          :comment,
+          buffer[offset..-1].strip,
+          options,
+          nil,
+          indent
+        ]
+      end
+
+      parent
+    end
+  end
+end

data/lib/opulent/parser/control.rb

@@ -1,111 +1,132 @@
-# @Opulent
-module Opulent
-  # @Parser
-  class Parser
-    # Match an if-else control structure
-    #
-    def control(parent, indent)
-      # Accept eval or multiline eval syntax and return a new node,
-      if (structure = accept(:control))
-        structure = structure.to_sym
-
-        # Handle each and the other control structures
-        condition = accept(:line_feed).strip
-
-        # Process each control structure condition
-        if structure == :each
-          # Check if arguments provided correctly
-          error :each_arguments unless condition.match Tokens[:each_pattern]
-
-          condition = [$1.split(' '), $2.split(/,(.+)$/).map(&:strip).map(&:to_sym)]
-          condition[0].unshift '{}' if condition[0].length == 1 # Array loop as default
-        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 is a parent which allows multiple
-        # branches, such as an if or case, we create an array of conditions
-        # which can be matched and an array of children belonging to each
-        # conditional branch
-        if [:if, :unless].include? structure
-          # Create the control structure and get its child nodes
-          control_structure = [structure, [condition], {}, [], indent]
-          root control_structure, indent
-
-          # Turn children into an array because we allow multiple branches
-          control_structure[@children] = [control_structure[@children]]
-
-          # Add it to the parent node
-          parent[@children] << control_structure
-
-        elsif structure == :case
-          # Create the control structure and get its child nodes
-          control_structure = [structure, [], {condition: condition}, [], indent]
-
-
-          # Add it to the parent node
-          parent[@children] << control_structure
-
-        # If the control structure is a child structure, we need to find the
-        # node it belongs to amont the current parent. Search from end to
-        # beginning until we find the node parent
-        elsif control_child structure
-          # During the search, we try to find the matching parent type
-          unless control_parent(structure).include? parent[@children][-1][@type]
-            error :control_child, control_parent(structure)
-          end
-
-          # Gather child elements for current structure
-          control_structure = [structure, [condition], {}, [], indent]
-          root control_structure, indent
-
-          # Add the new condition and children to our parent structure
-          parent[@children][-1][@value] << condition
-          parent[@children][-1][@children] << control_structure[@children]
-
-        # When our control structure isn't a complex composite, we create
-        # it the same way as a normal node
-        else
-          control_structure = [structure, condition, {}, [], indent]
-          root control_structure, indent
-
-          parent[@children] << control_structure
-        end
-      end
-    end
-
-    # Check if the current control structure requires a parent node and
-    # return the parent's node type
-    #
-    def control_child(structure)
-      [:else, :elsif, :when].include? structure
-    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
+# @Opulent
+module Opulent
+  # @Parser
+  class Parser
+    # Match an if-else control structure
+    #
+    def control(parent, indent)
+      # Accept eval or multiline eval syntax and return a new node,
+      return unless (structure = accept(:control))
+      structure = structure.to_sym
+
+      # Handle each and the other control structures
+      condition = accept(:line_feed).strip
+
+      # Process each control structure condition
+      if structure == :each
+        # Check if arguments provided correctly
+        unless condition.match Tokens[:each_pattern]
+          Logger.error :parse, @code, @i, @j, :each_arguments
+        end
+
+        # Conditions for each iterator
+        condition = [
+          Regexp.last_match[1].split(' '),
+          Regexp.last_match[2].split(/,(.+)$/).map(&:strip).map(&:to_sym)
+        ]
+
+        # Array loop as default
+        condition[0].unshift '{}' if condition[0].length == 1
+      end
+
+      # Else and default structures are not allowed to have any condition
+      # set and the other control structures require a condition
+      if structure == :else
+        unless condition.empty?
+          Logger.error :parse, @code, @i, @j, :condition_exists
+        end
+      else
+        if condition.empty?
+          Logger.error :parse, @code, @i, @j, :condition_missing
+        end
+      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 do |control_parent|
+      #   control_parent.value << condition
+      #   control_parent.children << []
+      #
+      #   root control_parent
+      # end
+
+      # If the current control structure is a parent which allows multiple
+      # branches, such as an if or case, we create an array of conditions
+      # which can be matched and an array of children belonging to each
+      # conditional branch
+      if [:if, :unless].include? structure
+        # Create the control structure and get its child nodes
+        control_structure = [structure, [condition], {}, [], indent]
+        root control_structure, indent
+
+        # Turn children into an array because we allow multiple branches
+        control_structure[@children] = [control_structure[@children]]
+
+        # Add it to the parent node
+        parent[@children] << control_structure
+
+      elsif structure == :case
+        # Create the control structure and get its child nodes
+        control_structure = [
+          structure,
+          [],
+          { condition: condition },
+          [],
+          indent
+        ]
+
+        # Add it to the parent node
+        parent[@children] << control_structure
+
+      # If the control structure is a child structure, we need to find the
+      # node it belongs to amont the current parent. Search from end to
+      # beginning until we find the node parent
+      elsif control_child structure
+        # During the search, we try to find the matching parent type
+        unless control_parent(structure).include? parent[@children][-1][@type]
+          Logger.error :parse,
+                       @code,
+                       @i,
+                       @j,
+                       :control_child,
+                       control_parent(structure)
+        end
+
+        # Gather child elements for current structure
+        control_structure = [structure, [condition], {}, [], indent]
+        root control_structure, indent
+
+        # Add the new condition and children to our parent structure
+        parent[@children][-1][@value] << condition
+        parent[@children][-1][@children] << control_structure[@children]
+
+      # When our control structure isn't a complex composite, we create
+      # it the same way as a normal node
+      else
+        control_structure = [structure, condition, {}, [], indent]
+        root control_structure, indent
+
+        parent[@children] << control_structure
+      end
+    end
+
+    # Check if the current control structure requires a parent node and
+    # return the parent's node type
+    #
+    def control_child(structure)
+      [:else, :elsif, :when].include? structure
+    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