opulent 1.5.5 → 1.6.0

data/lib/opulent/parser/include.rb

@@ -2,62 +2,58 @@
 module Opulent
   # @Parser
   class Parser
-    # Check if we match a new node definition to use within our page.
+    # Check if we have an include node, which will include a new file inside
+    # of the current one to be parsed
     #
-    # Definitions will not be recursive because, by the time we parse
-    # the definition children, the definition itself is not in the
-    # knowledgebase yet.
+    # @param parent [Array] Parent node to which we append to
     #
-    # However, we may use previously defined nodes inside new definitions,
-    # due to the fact that they are known at parse time.
-    #
-    # @param nodes [Array] Parent node to which we append to
-    #
-    def include_file(parent, indent)
-      if(match = accept :include)
+    def include_file(_parent, indent)
+      return unless accept :include
 
-        # Process data
-        name = accept :line_feed || ""
-        name.strip!
+      # Process data
+      name = accept :line_feed || ''
+      name.strip!
 
+      # Check if there is any string after the include input
+      Logger.error :parse, @code, @i, @j, :include_end if name.empty?
 
-        # Check if there is any string after the include input
-        if name.empty?
-          error :include_end
-        end
-
-        # Get the complete file path based on the current file being compiled
-        include_path = File.expand_path name, File.dirname(@file[-1][0])
-
-        # Try to see if it has any existing extension, otherwise add .op
-        include_path += Settings::FILE_EXTENSION if File.extname(name).empty?
-
-        # Throw an error if the file doesn't exist
-        error :include, name unless Dir[include_path].any?
+      # Get the complete file path based on the current file being compiled
+      include_path = File.expand_path name, File.dirname(@file[-1][0])
 
-        # include entire directory tree
-        Dir[include_path].each do |file|
-          # Skip current file when including from same directory
-          next if file == @file[-1][0]
+      # Try to see if it has any existing extension, otherwise add .op
+      include_path += Settings::FILE_EXTENSION if File.extname(name).empty?
 
-          @file << [include_path, indent]
+      # Throw an error if the file doesn't exist
+      unless Dir[include_path].any?
+        Logger.error :parse, @code, @i, @j, :include, name
+      end
 
-          # Throw an error if the file doesn't exist
-          error :include_dir, file if File.directory? file
+      # include entire directory tree
+      Dir[include_path].each do |file|
+        # Skip current file when including from same directory
+        next if file == @file[-1][0]
 
-          # Throw an error if the file doesn't exist
-          error :include, file unless File.file? file
+        @file << [include_path, indent]
 
-          # Indent all lines and prepare them for the parser
-          lines = indent_lines File.read(file), ' ' * indent
-          lines << ' '
+        # Throw an error if the file doesn't exist
+        if File.directory? file
+          Logger.error :parse, @code, @i, @j, :include_dir, file
+        end
 
-          # Indent all the output lines with the current indentation
-          @code.insert @i + 1, *lines.lines
+        # Throw an error if the file doesn't exist
+        unless File.file? file
+          Logger.error :parse, @code, @i, @j, :include, file
         end
 
-        return true
+        # Indent all lines and prepare them for the parser
+        lines = indent_lines File.read(file), ' ' * indent
+        lines << ' '
+
+        # Indent all the output lines with the current indentation
+        @code.insert @i + 1, *lines.lines
       end
+
+      true
     end
   end
 end

data/lib/opulent/parser/node.rb

@@ -10,83 +10,82 @@ module Opulent
     # @param parent [Node] Parent node to which we append the node
     #
     def node(parent, indent = nil)
-      if (name = lookahead(:node_lookahead) || lookahead(:shorthand_lookahead))
-        return nil if KEYWORDS.include? name[0].to_sym
-
-        # Accept either explicit node_name or implicit :div node_name
-        # with shorthand attributes
-        if (node_name = accept :node)
-          node_name = node_name.to_sym
-          shorthand = shorthand_attributes
-        elsif (shorthand = shorthand_attributes)
-          node_name = :div
-        end
+      return unless (name = lookahead(:node_lookahead) ||
+                            lookahead(:shorthand_lookahead))
+
+      return nil if KEYWORDS.include? name[0].to_sym
+
+      # Accept either explicit node_name or implicit :div node_name
+      # with shorthand attributes
+      if (node_name = accept :node)
+        node_name = node_name.to_sym
+        shorthand = shorthand_attributes
+      elsif (shorthand = shorthand_attributes)
+        node_name = :div
+      end
 
-        # Node creation options
-        options = {}
+      # Node creation options
+      options = {}
 
-        # Get leading and trailing whitespace
-        if accept_stripped :leading_whitespace
-          options[:leading_whitespace] = true
-          if accept :leading_trailing_whitespace
-            options[:trailing_whitespace] = true
-          end
-        elsif accept_stripped :trailing_whitespace
-          options[:trailing_whitespace] = true
-        end
+      # Get leading whitespace
+      options[:leading_whitespace] = accept_stripped(:leading_whitespace)
 
-        # Get wrapped node attributes
-        atts = attributes(shorthand) || {}
+      # Get trailing whitespace
+      options[:trailing_whitespace] = accept_stripped(:trailing_whitespace)
 
-        # Inherit attributes from definition
-        options[:extension] = extension = extend_attributes
+      # Get wrapped node attributes
+      atts = attributes(shorthand) || {}
 
-        # Get unwrapped node attributes
-        options[:attributes] = attributes_assignments atts, false
+      # Inherit attributes from definition
+      options[:extension] = extend_attributes
 
-        # Create node
-        current_node = [:node, node_name, options, [], indent]
+      # Get unwrapped node attributes
+      options[:attributes] = attributes_assignments atts, false
 
-        # Check if the node is explicitly self enclosing
-        if(close = accept_stripped :self_enclosing) || (!@definitions.keys.include?(node_name) && Settings::SelfEnclosing.include?(node_name))
-          current_node[@options][:self_enclosing] = true
+      # Create node
+      current_node = [:node, node_name, options, [], indent]
 
-          unless close.nil? || close.strip.empty?
-            undo close; error :self_enclosing
-          end
+      # Check for self enclosing tags and definitions
+      def_check = !@definitions.keys.include?(node_name) &&
+                  Settings::SELF_ENCLOSING.include?(node_name)
 
-          # For self enclosing tag error reporting purposes
-          line = @i
-        end
+      # Check if the node is explicitly self enclosing
+      if (close = accept_stripped :self_enclosing) || def_check
+        current_node[@options][:self_enclosing] = true
 
-        # Check whether we have explicit inline elements and add them
-        # with increased base indentation
-        if (accept :inline_child)
-          # Inline node element
-          unless (child_node = node current_node, indent)
-            error :inline_child
-          end
-        else
-          # Inline text element
-          text_node = text current_node, indent, false
+        unless close.nil? || close.strip.empty?
+          undo close
+          Logger.error :parse, @code, @i, @j, :self_enclosing
         end
+      end
 
-        # Add the current node to the root
-        root(current_node, indent)
+      # Check whether we have explicit inline elements and add them
+      # with increased base indentation
+      if accept :inline_child
+        # Inline node element
+        Logger.error :parse,
+                     @code,
+                     @i,
+                     @j,
+                     :inline_child unless node current_node, indent
+      elsif comment current_node, indent
+        # Accept same line comments
+      else
+        # Accept inline text element
+        text current_node, indent, false
+      end
 
-        # if current_node[@options][:self_enclosing] && current_node[@children].any?
-        #   error :self_enclosing_children, line
-        # end
+      # Add the current node to the root
+      root current_node, indent
 
-        # Create a clone of the definition model. Cloning the options is also
-        # necessary because it's a shallow copy
-        if @definitions.keys.include?(node_name)
-          @definition_stack << node_name
-          parent[@children] << process_definition(node_name, current_node)
-          @definition_stack.pop
-        else
-          parent[@children] << current_node
-        end
+      # Create a clone of the definition model. Cloning the options is also
+      # necessary because it's a shallow copy
+      if @definitions.keys.include?(node_name)
+        @definition_stack << node_name
+        parent[@children] << process_definition(node_name, current_node)
+        @definition_stack.pop
+      else
+        parent[@children] << current_node
       end
     end
 
@@ -107,13 +106,18 @@ module Opulent
       process_definition_child model[@options][:call]
       process_definition_child model
 
-      return model
+      model
     end
 
+    # Process definition children for the current node.
+    #
+    # @param node [Node] Callee node
+    #
     def process_definition_child(node)
       node[@children].map! do |child|
         if child[@type] == :node
-          if !@definition_stack.include?(child[@value]) && @definitions.keys.include?(child[@value])
+          if !@definition_stack.include?(child[@value]) &&
+             @definitions.keys.include?(child[@value])
             process_definition child[@value], child
           else
             process_definition_child child if child[@children]
@@ -154,20 +158,20 @@ module Opulent
     #
     def shorthand_attributes(atts = {})
       while (key = accept :shorthand)
-        key = Settings::Shorthand[key.to_sym]
+        key = Settings::SHORTHAND[key.to_sym]
 
         # Check whether the value is escaped or unescaped
         escaped = accept(:unescaped_value) ? false : true
 
         # Get the attribute value and process it
         if (value = accept(:node))
-          value = [:expression, value.inspect, {escaped: escaped}]
+          value = [:expression, value.inspect, { escaped: escaped }]
         elsif (value = accept(:exp_string))
-          value = [:expression, value, {escaped: escaped}]
+          value = [:expression, value, { escaped: escaped }]
         elsif (value = paranthesis)
-          value = [:expression, value, {escaped: escaped}]
+          value = [:expression, value, { escaped: escaped }]
         else
-          error :shorthand
+          Logger.error :parse, @code, @i, @j, :shorthand
         end
 
         # IDs are unique, the rest of the attributes turn into arrays in
@@ -175,17 +179,19 @@ module Opulent
         add_attribute(atts, key, value)
       end
 
-      return atts
+      atts
     end
 
+    # Get element attributes
+    #
+    # @atts [Hash] Accumulator for node attributes
+    #
     def attributes(atts = {})
       wrapped_attributes atts
       attributes_assignments atts, false
-
-      return atts
+      atts
     end
 
-
     # Check if we match node attributes
     #
     # [ assignments ]
@@ -194,11 +200,14 @@ module Opulent
     #
     def wrapped_attributes(list)
       if (bracket = accept :brackets)
-        attributes_assignments list
-        accept bracket.to_sym, :*
+        accept_newline
+        attributes_assignments list, true
+        accept_newline
+
+        accept_stripped bracket.to_sym, :*
       end
 
-      return list
+      list
     end
 
     # Check if we match an expression node or
@@ -206,53 +215,63 @@ module Opulent
     #
     # [ assignments ]
     #
-    # @param parent [Hash] Parent to which we append nodes
+    # @param list [Hash] Parent to which we append nodes
     # @param as_parameters [Boolean] Accept or reject identifier nodes
     #
-    def attributes_assignments(parent, wrapped = true)
-      unless wrapped
-        return parent if lookahead(:assignment_lookahead).nil?
+    def attributes_assignments(list, wrapped = true)
+      if wrapped && lookahead(:exp_identifier_stripped_lookahead).nil? ||
+         !wrapped && lookahead(:assignment_lookahead).nil?
+        return list
       end
 
-      if (argument = accept_stripped :node)
-        argument = argument.to_sym
+      return unless (argument = accept_stripped :node)
 
-        if accept :assignment
-          # Check if we have an attribute escape or not
-          escaped = if accept :assignment_unescaped
-            false
-          else
-            true
-          end
+      argument = argument.to_sym
 
-          # Get the argument value if we have an assignment
-          if (value = expression(false, wrapped))
-            value[@options][:escaped] = escaped
+      if accept_stripped :assignment
+        # Check if we have an attribute escape or not
+        escaped = if accept :assignment_unescaped
+                    false
+                  else
+                    true
+                  end
 
-            # IDs are unique, the rest of the attributes turn into arrays in
-            # order to allow multiple values or identifiers
-            add_attribute(parent, argument, value)
-          else
-            error :assignments_colon
-          end
+        # Get the argument value if we have an assignment
+        if (value = expression(false, wrapped))
+          value[@options][:escaped] = escaped
+
+          # IDs are unique, the rest of the attributes turn into arrays in
+          # order to allow multiple values or identifiers
+          add_attribute(list, argument, value)
         else
-          parent[argument] = [:expression, "nil", {escaped: false}] unless parent[argument]
+          Logger.error :parse, @code, @i, @j, :assignments_colon
         end
-
-        # If our attributes are wrapped, we allow method calls without
-        # paranthesis, ruby style, therefore we need a terminator to signify
-        # the expression end. If they are not wrapped (inline), we require
-        # paranthesis and allow inline calls
-        if wrapped && accept_stripped(:assignment_terminator)
-          attributes_assignments parent, wrapped
-        elsif !wrapped && lookahead(:assignment_lookahead)
-          attributes_assignments parent, wrapped
+      else
+        unless list[argument]
+          list[argument] = [:expression, 'true', { escaped: false }]
         end
+      end
 
-        return parent
-      elsif !parent.empty?
-        error :assignments_comma
+      # If our attributes are wrapped, we allow method calls without
+      # paranthesis, ruby style, therefore we need a terminator to signify
+      # the expression end. If they are not wrapped (inline), we require
+      # paranthesis and allow inline calls
+      if wrapped
+        # Accept optional comma between attributes
+        accept_stripped :assignment_terminator
+
+        # Lookahead for attributes on the current line and the next one
+        if lookahead(:exp_identifier_stripped_lookahead)
+          attributes_assignments list, wrapped
+        elsif lookahead_next_line(:exp_identifier_stripped_lookahead)
+          accept_newline
+          attributes_assignments list, wrapped
+        end
+      elsif !wrapped && lookahead(:assignment_lookahead)
+        attributes_assignments list, wrapped
       end
+
+      list
     end
 
     # Extend node attributes with hash from
@@ -262,14 +281,13 @@ module Opulent
     # +(paranthesis)
     #
     def extend_attributes
-      if (accept :extend_attributes)
-        unescaped = accept :unescaped_value
+      return unless accept :extend_attributes
+      unescaped = accept :unescaped_value
 
-        extension = expression(false, false, false)
-        extension[@options][:escaped] = false if unescaped
+      extension = expression(false, false, false)
+      extension[@options][:escaped] = !unescaped
 
-        return extension
-      end
+      extension
     end
   end
 end

data/lib/opulent/parser/root.rb

@@ -9,9 +9,12 @@ module Opulent
     # @param nodes [Array] Parent node to which we append to
     #
     def root(parent = @root, min_indent = -1)
-      while(@line = @code[(@i += 1)])
+      while (@line = @code[(@i += 1)])
+        # Reset character position cursor
+        @j = 0
+
         # Skip to next iteration if we have a blank line
-        if @line =~ /\A\s*\Z/ then next end
+        next if @line =~ /\A\s*\Z/
 
         # Reset the line offset
         @offset = 0
@@ -23,7 +26,8 @@ module Opulent
         # Stop using the current parent as root if it does not match the
         # minimum indentation includements
         unless min_indent < indent
-          @i -= 1; break
+          @i -= 1
+          break
         end
 
         # If last include path had a greater indentation, pop the last file path
@@ -31,23 +35,25 @@ module Opulent
 
         # Try the main Opulent node types and process each one of them using
         # their matching evaluation procedure
-        current_node =  node(parent, indent)        ||
-                        text(parent, indent)        ||
-                        comment(parent, indent)     ||
-                        define(parent, indent)      ||
-                        control(parent, indent)     ||
-                        evaluate(parent, indent)    ||
-                        filter(parent, indent)      ||
-                        block_yield(parent, indent) ||
-                        include_file(parent, indent)||
-                        html_text(parent, indent)   ||
-                        doctype(parent, indent)
-
-        # Throw an error if we couldn't find a valid node
-        error :unknown_node_type unless current_node
+        current_node = node(parent, indent) ||
+                       text(parent, indent) ||
+                       comment(parent, indent) ||
+                       define(parent, indent) ||
+                       control(parent, indent) ||
+                       evaluate(parent, indent) ||
+                       filter(parent, indent) ||
+                       block_yield(parent, indent) ||
+                       include_file(parent, indent) ||
+                       html_text(parent, indent) ||
+                       doctype(parent, indent)
+
+        # Throw an error if we couldn't find any valid node
+        unless current_node
+          Logger.error :parse, @code, @i, @j, :unknown_node_type
+        end
       end
 
-      return parent
+      parent
     end
   end
 end