opulent 1.5.5 → 1.6.0

data/lib/opulent/parser/define.rb

@@ -14,21 +14,24 @@ module Opulent
     # @param nodes [Array] Parent node to which we append to
     #
     def define(parent, indent)
-      if(match = accept :def)
-        # Process data
-        name = accept(:node, :*).to_sym
+      return unless accept(:def)
 
-        # Create node
-        definition = [:def, name, {parameters: attributes}, [], indent]
+      # Definition parent check
+      Logger.error :parse, @code, @i, @j, :definition if parent[@type] != :root
 
-        # Set definition as root node and let the parser know that we're inside
-        # a definition. This is used because inside definitions we do not process
-        # nodes (we do not check if they are have a definition or not).
-        root definition, indent
+      # Process data
+      name = accept(:node, :*).to_sym
 
-        # Add to parent
-        @definitions[name] = definition
-      end
+      # Create node
+      definition = [:def, name, { parameters: attributes }, [], indent]
+
+      # Set definition as root node and let the parser know that we're inside
+      # a definition. This is used because inside definitions we do not
+      # process nodes (we do not check if they are have a definition or not).
+      root definition, indent
+
+      # Add to parent
+      @definitions[name] = definition
     end
   end
 end

data/lib/opulent/parser/doctype.rb

@@ -1,15 +1,15 @@
-# @Opulent
-module Opulent
-  # @Parser
-  class Parser
-    # Match one line or multiline comments
-    #
-    def doctype(parent, indent)
-      if (accept :doctype)
-        buffer = accept(:line_feed)
-
-        parent[@children] << [:doctype, buffer.strip.to_sym, {}, nil, indent]
-      end
-    end
-  end
-end
+# @Opulent
+module Opulent
+  # @Parser
+  class Parser
+    # Match one line or multiline comments
+    #
+    def doctype(parent, indent)
+      return unless accept :doctype
+
+      buffer = accept(:line_feed)
+
+      parent[@children] << [:doctype, buffer.strip.to_sym, {}, nil, indent]
+    end
+  end
+end

data/lib/opulent/parser/eval.rb

@@ -6,16 +6,26 @@ module Opulent
     #
     def evaluate(parent, indent)
       # Accept eval or multiline eval syntax and return a new node,
-      if (evaluate = accept(:eval))
-        eval_node = [:evaluate, evaluate[1..-1].strip, {}, nil, indent]
-      elsif (evaluate = accept(:eval_multiline))
+      return unless accept :eval
+
+      multiline = accept(:text)
+
+      if multiline
+        # Get first evaluation line
+        evaluate_code = accept(:line_feed) || ''
+
         # Get all the lines which are more indented than the current one
-        eval_node = [:evaluate, evaluate[1..-1].strip, {}, nil, indent]
-        eval_node[@value] += accept(:newline) || ""
+        eval_node = [:evaluate, evaluate_code.strip, {}, nil, indent]
+        eval_node[@value] += accept(:newline) || ''
         eval_node[@value] += get_indented_lines(indent)
+      else
+        evaluate_code = accept(:line_feed) || ''
+        eval_node = [:evaluate, evaluate_code.strip, {}, [], indent]
+
+        root eval_node, indent
       end
 
-      parent[@children] << eval_node if eval_node
+      parent[@children] << eval_node
     end
   end
 end

data/lib/opulent/parser/expression.rb

@@ -5,46 +5,50 @@ module Opulent
     # Check if the parser matches an expression node
     #
     def expression(allow_assignments = true, wrapped = true, whitespace = true)
-      buffer = ""
+      buffer = ''
 
       # Build a ruby expression out of accepted literals
-      while (term = (whitespace ? accept(:whitespace) : nil)          ||
-                    modifier                                          ||
-                    identifier                                        ||
-                    method_call                                       ||
-                    paranthesis                                       ||
-                    array                                             ||
-                    hash                                              ||
-                    symbol                                            ||
-                    percent                                           ||
+      while (term = (whitespace ? accept(:whitespace) : nil) ||
+                    modifier ||
+                    identifier ||
+                    method_call ||
+                    paranthesis ||
+                    array ||
+                    hash ||
+                    symbol ||
+                    percent ||
                     primary_term)
         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 || (allow_assignments ? accept_stripped(:exp_assignment) : nil))
+        if wrapped && (op = operation ||
+          (allow_assignments ? accept_stripped(:exp_assignment) : nil))
+
           buffer += op
           if (right_term = expression(allow_assignments, wrapped)).nil?
-            error :expression
+            Logger.error :parse, @code, @i, @j, :expression
           else
             buffer += right_term[@value]
           end
-        elsif (conditional = ternary_operator allow_assignments, wrapped)
-          buffer += conditional
+        elsif (op = array || op = method_call || op = ternary_operator(allow_assignments, wrapped))
+          p buffer
+          p op
+          buffer += op
         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).nil?
+          break if lookahead(:exp_identifier_lookahead).nil?
         end
       end
 
       if buffer.strip.empty?
-        return undo buffer
+        undo buffer
       else
-        return [:expression, buffer.strip, {}]
+        [:expression, buffer.strip, {}]
       end
     end
 
@@ -55,12 +59,12 @@ module Opulent
     # [array_elements]
     #
     def array
-      if (buffer = accept :square_bracket)
-        accept_newline
-        buffer += array_elements
-        accept_newline
-        buffer += accept :'[', :*
-      end
+      return unless (buffer = accept :square_bracket)
+      accept_newline
+      buffer += array_elements
+      accept_newline
+      buffer += accept :'[', :*
+      buffer
     end
 
     # Recursively gather expressions separated by a comma and add them to the
@@ -75,7 +79,7 @@ module Opulent
         buffer += term[@value]
         # If there is an array_terminator ",", recursively gather the next
         # array element into the buffer
-        if (terminator = accept_stripped :comma) then
+        if (terminator = accept_stripped :comma)
           accept_newline
           buffer += array_elements terminator
         end
@@ -83,11 +87,9 @@ module Opulent
 
       # Array ended prematurely with a trailing comma, therefore the current
       # parsing process will stop
-      if buffer.strip[-1] == ','
-        error :array_elements_terminator
-      end
+      error :array_elements_terminator if buffer.strip[-1] == ','
 
-      return buffer
+      buffer
     end
 
     # Check if it's possible to parse a ruby hash literal. First, try to see
@@ -97,12 +99,12 @@ module Opulent
     # { hash_elements }
     #
     def hash
-      if (buffer = accept :curly_bracket)
-        accept_newline
-        buffer += hash_elements
-        accept_newline
-        buffer += accept :'{', :*
-      end
+      return unless (buffer = accept :curly_bracket)
+      accept_newline
+      buffer += hash_elements
+      accept_newline
+      buffer += accept :'{', :*
+      buffer
     end
 
     # Recursively gather expression attributions separated by a comma and add
@@ -113,7 +115,7 @@ module Opulent
     # @param buffer [String] Accumulator for the hash elements
     #
     def hash_elements(buffer = '')
-      value = Proc.new do
+      value = proc do
         # Get the value associated to the current hash key
         if (exp = expression)
           buffer += exp[@value]
@@ -123,7 +125,7 @@ module Opulent
 
         # If there is an hash_terminator ",", recursively gather the next
         # array element into the buffer
-        if (terminator = accept_stripped :comma) then
+        if (terminator = accept_stripped :comma)
           accept_newline
           buffer += hash_elements terminator
         end
@@ -139,7 +141,7 @@ module Opulent
         value[]
       elsif (exp = expression false)
         buffer += exp[@value]
-        if(assign = accept_stripped :hash_assignment)
+        if (assign = accept_stripped :hash_assignment)
           buffer += assign
           value[]
         else
@@ -149,31 +151,28 @@ module Opulent
 
       # Array ended prematurely with a trailing comma, therefore the current
       # parsing process will stop
-      if buffer.strip[-1] == ','
-        error :hash_elements_terminator
-      end
+      error :hash_elements_terminator if buffer.strip[-1] == ','
 
-      return buffer
+      buffer
     end
 
     # Accept a ruby identifier such as a class, module, method or variable
     #
     def identifier
-      if (buffer = accept :exp_identifier)
-        if (args = call)
-          buffer += args
-        end
-        return buffer
+      return unless (buffer = accept :exp_identifier)
+      if (args = call)
+        buffer += args
       end
+      buffer
     end
 
     # Check if it's possible to parse a ruby paranthesis expression wrapper.
     #
     def paranthesis
-      if (buffer = accept :round_bracket)
-        buffer += expression[@value]
-        buffer += accept_stripped :'(', :*
-      end
+      return unless (buffer = accept :round_bracket)
+      buffer += expression[@value]
+      buffer += accept_stripped :'(', :*
+      buffer
     end
 
     # Check if it's possible to parse a ruby call literal. First, try to see
@@ -183,10 +182,11 @@ module Opulent
     # ( call_elements )
     #
     def call
-      if (buffer = accept :round_bracket)
-        buffer += call_elements
-        buffer += accept_stripped :'(', :*
-      end
+      return unless (buffer = accept :round_bracket)
+
+      buffer += call_elements
+      buffer += accept_stripped :'(', :*
+      buffer
     end
 
     # Recursively gather expression attributes separated by a comma and add
@@ -215,13 +215,13 @@ module Opulent
 
         # If there is an comma ",", recursively gather the next
         # array element into the buffer
-        if (terminator = accept_stripped :comma) then
+        if (terminator = accept_stripped :comma)
           buffer += call_elements terminator
         end
       elsif (exp = expression(true))
         buffer += exp[@value]
 
-        if(assign = accept_stripped :hash_assignment)
+        if (assign = accept_stripped :hash_assignment)
           buffer += assign
 
           # Get the value associated to the current hash key
@@ -234,7 +234,7 @@ module Opulent
 
         # If there is an comma ",", recursively gather the next
         # array element into the buffer
-        if (terminator = accept_stripped :comma) then
+        if (terminator = accept_stripped :comma)
           buffer += call_elements terminator
         end
       end
@@ -248,14 +248,13 @@ module Opulent
     # :symbol
     #
     def symbol
-      if (colon = accept :colon)
-        return undo colon if lookahead(:whitespace)
+      return unless (colon = accept :colon)
+      return undo colon if lookahead(:whitespace)
 
-        if (exp = expression).nil?
-          error :symbol
-        else
-          colon + exp[@value]
-        end
+      if (exp = expression).nil?
+        error :symbol
+      else
+        colon + exp[@value]
       end
     end
 
@@ -268,30 +267,29 @@ module Opulent
       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_stripped :exp_percent)
-        match_start = buffer[-1]
-        match_name = :"percent#{match_start}"
-
-        unless Tokens[match_name]
-          match_end = Tokens.bracket(match_start) || match_start
+      return unless (buffer = accept_stripped :exp_percent)
+      match_start = buffer[-1]
+      match_name = :"percent#{match_start}"
 
-          match_inner = "\\#{match_start}"
-          match_inner += "\\#{match_end}" unless match_end == match_start
+      unless Tokens[match_name]
+        match_end = Tokens.bracket(match_start) || match_start
 
-          pattern = /(((?:[^#{match_inner}\\]|\\.)*?)#{'\\' + match_end})/
+        match_inner = "\\#{match_start}"
+        match_inner += "\\#{match_end}" unless match_end == match_start
 
-          Tokens[match_name] = pattern
-        end
+        pattern = /(((?:[^#{match_inner}\\]|\\.)*?)#{'\\' + match_end})/
 
-        buffer += accept match_name
+        Tokens[match_name] = pattern
       end
+
+      buffer += accept match_name
+      buffer
     end
 
     # Accept any primary term and return it without the leading whitespace to
@@ -306,12 +304,12 @@ module Opulent
     # /.*/
     #
     def primary_term
-      accept_stripped(:exp_string)     ||
-      accept_stripped(:exp_fixnum)     ||
-      accept_stripped(:exp_double)     ||
-      accept_stripped(:exp_nil)        ||
-      accept_stripped(:exp_regex)      ||
-      accept_stripped(:exp_boolean)
+      accept_stripped(:exp_string) ||
+        accept_stripped(:exp_fixnum) ||
+        accept_stripped(:exp_double) ||
+        accept_stripped(:exp_nil) ||
+        accept_stripped(:exp_regex) ||
+        accept_stripped(:exp_boolean)
     end
 
     # Accept an operation between two or more expressions
@@ -323,7 +321,12 @@ module Opulent
     # Accept a ruby method call modifier
     #
     def method_call
-      accept(:exp_method_call)
+      return unless (method_code = accept(:exp_method_call))
+
+      argument = call
+      method_code += argument if argument
+
+      method_code
     end
 
     # Accept ternary operator syntax

data/lib/opulent/parser/filter.rb

@@ -1,25 +1,31 @@
-# @Opulent
-module Opulent
-  # @Parser
-  class Parser
-    # Check if we match an compile time filter
-    #
-    # :filter
-    #
-    # @param parent [Node] Parent node to which we append the element
-    #
-    def filter(parent, indent)
-      if (filter_name = accept :filter)
-        # Get element attributes
-        atts = attributes(shorthand_attributes) || {}
-
-        # Accept inline text or multiline text feed as first child
-        error :fiter unless accept(:line_feed).strip.empty?
-
-        # Get everything under the filter and set it as the node value
-        # and create a new node and set its extension
-        parent[@children] << [:filter, filter_name[1..-1].to_sym, atts, get_indented_lines(indent), indent]
-      end
-    end
-  end
-end
+# @Opulent
+module Opulent
+  # @Parser
+  class Parser
+    # Check if we match an compile time filter
+    #
+    # :filter
+    #
+    # @param parent [Node] Parent node to which we append the element
+    #
+    def filter(parent, indent)
+      return unless (filter_name = accept :filter)
+
+      # Get element attributes
+      atts = attributes(shorthand_attributes) || {}
+
+      # Accept inline text or multiline text feed as first child
+      error :fiter unless accept(:line_feed).strip.empty?
+
+      # Get everything under the filter and set it as the node value
+      # and create a new node and set its extension
+      parent[@children] << [
+        :filter,
+        filter_name[1..-1].to_sym,
+        atts,
+        get_indented_lines(indent),
+        indent
+      ]
+    end
+  end
+end