opulent 0.0.9 → 1.0.2

data/lib/opulent/parser/eval.rb

@@ -0,0 +1,21 @@
+# @Opulent
+module Opulent
+  # @Parser
+  class Parser
+    # Match one line or multiline, escaped or unescaped text
+    #
+    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))
+        # 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[@value] += get_indented_lines(indent)
+      end
+
+      parent[@children] << eval_node if eval_node
+    end
+  end
+end

data/lib/opulent/parser/expression.rb

@@ -0,0 +1,344 @@
+# @Opulent
+module Opulent
+  # @Parser
+  class Parser
+    # Check if the parser matches an expression node
+    #
+    def expression(allow_assignments = true, wrapped = true, whitespace = true)
+      buffer = ""
+
+      # Build a ruby expression out of accepted literals
+      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))
+          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).nil?
+        end
+      end
+
+      if buffer.strip.empty?
+        return undo buffer
+      else
+        return [:expression, buffer.strip, {evaluate: true}]
+      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 :square_bracket)
+        accept_newline
+        buffer += array_elements
+        accept_newline
+        buffer += accept :'[', :*
+      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_stripped :comma) then
+          accept_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
+
+      return 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 :curly_bracket)
+        accept_newline
+        buffer += hash_elements
+        accept_newline
+        buffer += accept :'{', :*
+      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_stripped :comma) then
+          accept_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_stripped :hash_symbol)
+        buffer += symbol
+        value[]
+      elsif (exp = expression false)
+        buffer += exp[@value]
+        if(assign = accept_stripped :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
+
+      return 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
+      end
+    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
+    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 :round_bracket)
+        buffer += call_elements
+        buffer += accept_stripped :'(', :*
+      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_stripped :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_stripped :comma) then
+          buffer += call_elements terminator
+        end
+      elsif (exp = expression(true))
+        buffer += exp[@value]
+
+        if(assign = accept_stripped :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_stripped :comma) then
+          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)
+
+        if (exp = expression).nil?
+          error :symbol
+        else
+          colon + exp[@value]
+        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_stripped :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] = 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_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
+    #
+    def operation
+      accept(:exp_operation)
+    end
+
+    # Accept a ruby method call modifier
+    #
+    def method_call
+      accept(:exp_method_call)
+    end
+
+    # Accept ternary operator syntax
+    #
+    # condition ? expression1 : expression2
+    #
+    def ternary_operator(allow_assignments, wrapped)
+      if (buffer = accept :exp_ternary)
+        buffer += expression(allow_assignments, wrapped)[@value]
+        if (else_branch = accept :exp_ternary_else)
+          buffer += else_branch
+          buffer += expression(allow_assignments, wrapped)[@value]
+        end
+        return buffer
+      end
+    end
+  end
+end

data/lib/opulent/parser/filter.rb

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

data/lib/opulent/parser/node.rb

@@ -0,0 +1,246 @@
+# @Opulent
+module Opulent
+  # @Parser
+  class Parser
+    # Check if we match an node node with its attributes and possibly
+    # inline text
+    #
+    # node [ attributes ] Inline text
+    #
+    # @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
+
+        # 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 wrapped node attributes
+        atts = attributes(shorthand) || {}
+
+        # Inherit attributes from definition
+        options[:extension] = extension = extend_attributes
+
+        # Get unwrapped node attributes
+        options[:attributes] = attributes_assignments atts, false
+
+        # Create node
+        current_node = [:node, node_name, options, [], indent]
+
+        # Check if the node is explicitly self enclosing
+        if(close = accept_stripped :self_enclosing) || Settings::SelfEnclosing.include?(node_name)
+          current_node[@options][:self_enclosing] = true
+
+          unless close.nil? || close.strip.empty?
+            undo close; error :self_enclosing
+          end
+
+          # For self enclosing tag error reporting purposes
+          line = @i
+        end
+
+        # 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
+        end
+
+        # Add the current node to the root
+        root(current_node, indent)
+
+        if current_node[@options][:self_enclosing] && current_node[@children].any?
+          error :self_enclosing_children, line
+        end
+
+        if @definitions.keys.include? node_name
+          model = @definitions[node_name].clone
+          model[@options][:call] = current_node
+
+          parent[@children] << model
+        else
+          parent[@children] << current_node
+        end
+      end
+    end
+
+    # Helper method to create an array of values when an attribute is set
+    # multiple times. This happens unless the key is id, which is unique
+    #
+    # @param atts [Hash] Current node attributes hash
+    # @param key [Symbol] Attribute name
+    # @param value [String] Attribute value
+    #
+    def add_attribute(atts, key, value)
+      # Check whether the attribute value needs to be evaluated or not
+      value[@options][:evaluate] = if value[@value] =~ Settings::EvaluationCheck
+        value[@value] =~ Settings::InterpolationCheck ? true : false
+      else
+        true
+      end
+
+      # Check for unique key and arrays of attributes
+      if key == :class
+        # If the key is already associated to an array, add the value to the
+        # array, otherwise, create a new array or set it
+        if atts[key]
+          atts[key] << value
+        else
+          atts[key] = [value]
+        end
+      else
+        atts[key] = value
+      end
+    end
+
+    # Accept node shorthand attributes. Each shorthand attribute is directly
+    # mapped to an attribute key
+    #
+    # @param atts [Hash] Node attributes
+    #
+    def shorthand_attributes(atts = {})
+      while (key = accept :shorthand)
+        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}]
+        elsif (value = accept(:exp_string))
+          value = [:expression, value, {escaped: escaped}]
+        elsif (value = paranthesis)
+          value = [:expression, value, {escaped: escaped}]
+        else
+          error :shorthand
+        end
+
+        # IDs are unique, the rest of the attributes turn into arrays in
+        # order to allow multiple values or identifiers
+        add_attribute(atts, key, value)
+      end
+
+      return atts
+    end
+
+    def attributes(atts = {})
+      wrapped_attributes atts
+      attributes_assignments atts, false
+
+      return atts
+    end
+
+
+    # Check if we match node attributes
+    #
+    # [ assignments ]
+    #
+    # @param as_parameters [Boolean] Accept or reject identifier nodes
+    #
+    def wrapped_attributes(list)
+      if (bracket = accept :brackets)
+        attributes_assignments list
+        accept bracket.to_sym, :*
+      end
+
+      return list
+    end
+
+    # Check if we match an expression node or
+    # a node node
+    #
+    # [ assignments ]
+    #
+    # @param parent [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?
+      end
+
+      if (argument = accept_stripped :node)
+        argument = argument.to_sym
+
+        if accept :assignment
+          # Check if we have an attribute escape or not
+          escaped = if accept :assignment_unescaped
+            false
+          else
+            true
+          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(parent, argument, value)
+          else
+            error :assignments_colon
+          end
+        else
+          parent[argument] = [:expression, "nil", {evaluate: true, escaped: false}] unless parent[argument]
+        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
+        end
+
+        return parent
+      elsif !parent.empty?
+        error :assignments_comma
+      end
+    end
+
+    # Extend node attributes with hash from
+    #
+    # +value
+    # +{hash: "value"}
+    # +(paranthesis)
+    #
+    def extend_attributes
+      if (accept :extend_attributes)
+        unescaped = accept :unescaped_value
+
+        extension = expression(false, false, false)
+        extension[@options][:escaped] = false if unescaped
+
+        return extension
+      end
+    end
+  end
+end