opulent 1.4.0 → 1.4.1

data/lib/opulent/compiler/comment.rb

@@ -9,15 +9,10 @@ module Opulent
     # @param context [Context] Processing environment data
     #
     def comment(node, indent, context)
-      indentation = " " * indent
-
-      # Escaping double quotes is required in order to avoid any conflicts with the eval quotes.
-      value = indent_lines context.evaluate('"' + node[@value].gsub('"', '\\"') + '"'), " " * indent
-
-      comment_tag = "#{"\n" if node[@options][:newline]}#{indentation}<!-- #{value.strip} -->\n"
-
-      @node_stack << :comment
-      @code += comment_tag
+      buffer_freeze "\n" if node[@options][:newline]
+      buffer_freeze "<!-- "
+      buffer_split_by_interpolation node[@value].strip, false
+      buffer_freeze " -->"
     end
   end
 end

data/lib/opulent/compiler/control.rb

@@ -10,17 +10,23 @@ module Opulent
     #
     def if_node(node, indent, context)
       # Check if we have any condition met, or an else branch
-      index = node[@value].index do |value|
-        value.empty? || context.evaluate(value)
-      end
+      node[@value].each_with_index do |value, index|
+        # If we have a branch that meets the condition, generate code for the
+        # children related to that specific branch
+        case value
+        when node[@value].first then buffer_eval "if #{value}"
+        when node[@value].last then buffer_eval "else"
+        else buffer_eval "elsif #{value}"
+        end
 
-      # If we have a branch that meets the condition, generate code for the
-      # children related to that specific branch
-      if index
+        # Evaluate child nodes
         node[@children][index].each do |child|
           root child, indent, context
         end
       end
+
+      # End
+      buffer_eval "end"
     end
 
     # Generate the code for a unless-else control structure
@@ -31,17 +37,22 @@ module Opulent
     #
     def unless_node(node, indent, context)
       # Check if we have any condition met, or an else branch
-      index = node[@value].index do |value|
-        value.empty? || !context.evaluate(value)
-      end
+      node[@value].each_with_index do |value, index|
+        # If we have a branch that meets the condition, generate code for the
+        # children related to that specific branch
+        case value
+        when node[@value].first then buffer_eval "unless #{value}"
+        else buffer_eval "else"
+        end
 
-      # If we have a branch that meets the condition, generate code for the
-      # children related to that specific branch
-      if index
+        # Evaluate child nodes
         node[@children][index].each do |child|
           root child, indent, context
         end
       end
+
+      # End
+      buffer_eval "end"
     end
 
     # Generate the code for a case-when-else control structure
@@ -52,20 +63,25 @@ module Opulent
     #
     def case_node(node, indent, context)
       # Evaluate the switching condition
-      switch_case = context.evaluate node[@options][:condition]
+      buffer_eval "case #{node[@options][:condition]}"
 
       # Check if we have any condition met, or an else branch
-      index = node[@value].index do |value|
-        value.empty? || switch_case == context.evaluate(value)
-      end
+      node[@value].each_with_index do |value, index|
+        # If we have a branch that meets the condition, generate code for the
+        # children related to that specific branch
+        case value
+        when node[@value].last then buffer_eval "else"
+        else buffer_eval "when #{value}"
+        end
 
-      # If we have a branch that meets the condition, generate code for the
-      # children related to that specific branch
-      if index
+        # Evaluate child nodes
         node[@children][index].each do |child|
           root child, indent, context
         end
       end
+
+      # End
+      buffer_eval "end"
     end
 
     # Generate the code for a while control structure
@@ -77,11 +93,15 @@ module Opulent
     def while_node(node, indent, context)
       # While we have a branch that meets the condition, generate code for the
       # children related to that specific branch
-      while context.evaluate node[@value]
-        node[@children].each do |child|
-          root child, indent, context
-        end
+      buffer_eval "while #{node[@value]}"
+
+      # Evaluate child nodes
+      node[@children].each do |child|
+        root child, indent, context
       end
+
+      #End
+      buffer_eval "end"
     end
 
     # Generate the code for a while control structure
@@ -93,11 +113,15 @@ module Opulent
     def until_node(node, indent, context)
       # Until we have a branch that doesn't meet the condition, generate code for the
       # children related to that specific branch
-      until context.evaluate node[@value]
-        node[@children].each do |child|
-          root child, indent, context
-        end
+      buffer_eval "until #{node[@value]}"
+
+      # Evaluate child nodes
+      node[@children].each do |child|
+        root child, indent, context
       end
+
+      # End
+      buffer_eval "end"
     end
 
     # Generate the code for a while control structure
@@ -107,10 +131,8 @@ module Opulent
     # @param context [Context] Processing environment data
     #
     def each_node(node, indent, context)
-      result = []
-
       # Process named variables for each structure
-      variables = node[@value][0].clone
+      variables = node[@value][1].clone
 
       # The each structure accept missing arguments as well, therefore we need to
       # substitute them with our defaults
@@ -129,46 +151,22 @@ module Opulent
         variables[1] = Settings::DefaultEachValue
       end
 
-      # Evaluate in current context and add to results
-      evaluate_children = Proc.new do |key, value, context|
-        # Update the local variables in the each context with the values from the
-        # current loop iteration
-        locals = {
-          variables[0] => key,
-          variables[1] => value
-        }
-        context.extend_locals locals
-
-        # Add the mapped child elements
-        node[@children].each do |child|
-          root child, indent, context
-        end
+      # Choose whether to apply each with index (Arrays) or each (Hashes) methods
+      #buffer_eval "_opulent_send_method = (#{node[@value][1]}.is_a?(Array) ? :each_with_index : :each)"
+      case node[@value][0][0]
+      when '[]'
+        buffer_eval "#{node[@value][0][1]}.each_with_index do |#{variables.reverse.join ', '}|"
+      else
+        buffer_eval "#{node[@value][0][1]}.each do |#{variables.join ', '}|"
       end
 
-      # Create a new context based on the parent context and progressively update
-      # variables in the new context
-      block = context.block.clone if context.block
-      each_context = Context.new Hash.new, &block
-      each_context.parent = context
-
-      # Evaluate the iterable object
-      enumerable = context.evaluate(node[@value][1])
-
-      # Check if input can be iterated
-      self.error :enumerable, node[@value][1] unless enumerable.respond_to? :each
-
-      # Selectively iterate through the input and add the result using the previously
-      # defined proc object
-      case enumerable
-      when Hash
-        enumerable.each do |key, value|
-          evaluate_children[key, value, context]
-        end
-      else
-        enumerable.each_with_index do |value, key|
-          evaluate_children[key, value, context]
-        end
+      # Evaluate child nodes
+      node[@children].each do |child|
+        root child, indent, context
       end
+
+      # End
+      buffer_eval "end"
     end
   end
 end

data/lib/opulent/compiler/define.rb

@@ -9,87 +9,115 @@ module Opulent
     # @param context [Context] Context holding environment variables
     #
     def def_node(node, indent, context)
-      # Create a new definition context
-      #
-      # @update: Added &context.block to make sure yield can be called from
-      # within a definition (it might be a nice feature)
-      #
-      definition_context = Context.new &context.block
-      definition_context.extend_nonlocals context.binding
-      definition_context.name = node[@value]
-      definition_context.parent = context
+      # Set a namespace for the current node definition and make it a valid ruby
+      # method name
+      key = "_opulent_definition_#{node[@value]}_#{@current_definition += 1}".gsub '-', '_'
 
-      # Set call node
+      # Set call variable
       call_node = node[@options][:call]
 
-      # Get call node attributes
-      attributes = call_node[@options][:attributes]
+      # Create the definition
+      buffer_eval "instance_eval do"
+      buffer_eval "def #{key}(attributes = {}, &block)" 
 
-      # Evaluate node extension in the current context
-      if call_node[@options][:extension]
-        extension = context.evaluate call_node[@options][:extension][@value]
-      else
-        extension = {}
+      # Set each parameter as a local variable
+      node[@options][:parameters].each do |parameter, value|
+        set_argument_code = "#{parameter} = attributes.delete(:#{parameter})"
+        set_argument_code += " || #{value[@value]}" if value[@value]
+        buffer_eval set_argument_code
       end
 
-      # Evaluate and generate node attributes, then process each one to
-      # by generating the required attribute code
-      attributes = {}
-      call_node[@options][:attributes].each do |key, attribute|
-        unless node[@options][:parameters].has_key? key
-          attributes[key] = map_attribute key, attribute, context
-        end
+      # Evaluate definition child elements
+      node[@children].each do |child|
+        root child, indent + Settings[:indent], context
       end
 
-      # Go through each extension attribute and use the value where applicable
-      extend_attributes attributes, extension
+      # End
+      buffer_eval "end"
+      buffer_eval "end"
 
-      # Definition call arguments
-      arguments = {}
+      # If we have attributes set for our defined node, we will need to create
+      # an extension parameter which will be o
+      if call_node[@options][:attributes].empty?
+        # Call method without any extension
+        buffer_eval "#{key}() do"
+      else
+        call_attributes_code = buffer_attributes_to_hash call_node[@options][:attributes]
 
-      # Extract values which appear as definition parameters. If we have the
-      # key passed as argument, get its value. Otherwise, set the default
-      # parameter value.
-      #
-      # Definition arguments (parameters which are set in definition header)
-      # will be passed unescaped, to allow node definition to handle escaping
-      # properly
-      node[@options][:parameters].each do |key, value|
-        if call_node[@options][:attributes].has_key? key
-          arguments[key] = context.evaluate call_node[@options][:attributes][key][@value]
-        else
-          arguments[key] = definition_context.evaluate value[@value]
-        end
-      end
+        # Set call node parameters
+        call_attributes = buffer_set_variable :call_attributes, call_attributes_code
 
-      # Set the remaining attributes as a value in the arguments
-      arguments[:attributes] = attributes
+        # If the call node is extended as well, merge the call attributes hash with
+        # the extension hash
+        if call_node[@options][:extension]
+          extension_attributes = buffer_set_variable :extension, call_node[@options][:extension][@value]
+          buffer_eval "#{call_attributes}.merge!(#{extension_attributes}) do |#{OpulentKey}, #{OpulentValue}1, #{OpulentValue}2|"
+          buffer_eval "#{OpulentKey} == :class ? (#{OpulentValue}1 += #{OpulentValue}2) : (#{OpulentValue}2)"
+          buffer_eval "end"
+        end
 
-      # Add call children to the block stack, depending on whether they're
-      # block elements or child elements
-      @block_stack << { @default_yield => [] }
+        buffer_eval "#{key}(#{call_attributes}) do"
+      end
 
-      # If we have a direct child, add it to the default yield (children)
-      # block and allow same block multiple times by appending nodes
+      # Set call node children as block evaluation. Very useful for
+      # performance and evaluating them in the parent context
       call_node[@children].each do |child|
-        if child[@type] == :block
-          @block_stack[-1][child[@value]] ||= []
-          @block_stack[-1][child[@value]] += child[@children]
-        else
-          @block_stack[-1][@default_yield] << child
-        end
+        root child, indent + Settings[:indent], context
       end
 
-      # Set variable to determine available blocks
-      arguments[:blocks] = Hash[@block_stack[-1].keys.map{|key| [key, true]}]
+      # End block
+      buffer_eval "end"
 
-      # Create local variables from argument variables
-      definition_context.extend_locals arguments
 
-      # Evaluate the model using the new context
-      node[@children].each do |child|
-        root child, indent, definition_context
-      end
+
+      # definition_context.parent = context
+      #
+      # # # Set call node
+      # # call_node = node[@options][:call]
+      # #
+      # # # Get call node attributes
+      # # attributes = call_node[@options][:attributes]
+      # #
+      # # Evaluate node extension in the current context
+      # if call_node[@options][:extension]
+      #   extension = context.evaluate call_node[@options][:extension][@value]
+      # else
+      #   extension = {}
+      # end
+      #
+      # # Evaluate and generate node attributes, then process each one to
+      # # by generating the required attribute code
+      # attributes = {}
+      # call_node[@options][:attributes].each do |key, attribute|
+      #   unless node[@options][:parameters].has_key? key
+      #     attributes[key] = map_attribute key, attribute, context
+      #   end
+      # end
+      #
+      # # Go through each extension attribute and use the value where applicable
+      # extend_attributes attributes, extension
+      #
+      # # Definition call arguments
+      # arguments = {}
+      #
+      # # Extract values which appear as definition parameters. If we have the
+      # # key passed as argument, get its value. Otherwise, set the default
+      # # parameter value.
+      # #
+      # # Definition arguments (parameters which are set in definition header)
+      # # will be passed unescaped, to allow node definition to handle escaping
+      # # properly
+      # node[@options][:parameters].each do |key, value|
+      #   if call_node[@options][:attributes].has_key? key
+      #     arguments[key] = context.evaluate call_node[@options][:attributes][key][@value]
+      #   else
+      #     arguments[key] = definition_context.evaluate value[@value]
+      #   end
+      # end
+      #
+      # # Set the remaining attributes as a value in the arguments
+      # arguments[:attributes] = attributes
+
 
       # Remove last set of blocks from the block stack
       @block_stack.pop

data/lib/opulent/compiler/doctype.rb

@@ -10,8 +10,6 @@ module Opulent
     # @param context [Context] Processing environment data
     #
     def doctype_node(node, indent, context)
-      indentation = " " * indent
-
       value = case node[@value]
       when :"", :"html", :"5"
         "!DOCTYPE html"
@@ -33,10 +31,8 @@ module Opulent
         '?xml version="1.0" encoding="iso-8859-1" ?'
       end
 
-      doctype_tag = "#{indentation}<#{value}>\n"
-
       @node_stack << :doctype
-      @code += doctype_tag
+      buffer_freeze "<#{value}>"
     end
   end
 end

data/lib/opulent/compiler/eval.rb

@@ -9,7 +9,7 @@ module Opulent
     # @param context [Context] Processing environment data
     #
     def evaluate(node, indent, context)
-      context.evaluate node[@value]
+      buffer_eval node[@value]
     end
   end
 end

data/lib/opulent/compiler/node.rb

@@ -12,223 +12,39 @@ module Opulent
     def node(node, indent, context)
       indentation = " " * indent
 
-      # Check if the current node and last node should be displayed inline
-      inline_current = @inline_node.include? node[@value]
-      inline_last = @inline_node.include? @node_stack.last
-
-      # Check if the node is a special node which can be either inline or
-      # block structure. Write the special node as inline if its children
-      # are all inline nodes
-      if @multi_node.include?(node[@value])
-        # First condition should be removed to ignore preceding node and make
-        # it be inline no matter what. Using the first check, we write it
-        # inline only if the element before it was inline
-        unless @sibling_stack.last > 1 && node[@children].all? do |child|
-          @inline_node.include?(child[@value])
-        end
-          inline_current = false
-          multi = true
-        end
-      end
-
-      # If we have an inline node, we remove the trailing newline character
-      # and write the tag code directly. Otherwise we add the tag code with
-      # normal indentation
-      if inline_last && inline_current
-        remove_trailing_newline
-      else
-        @code += indentation
-      end
-
       # Add the tag opening, with leading whitespace to the code buffer
-      tag_open = "<#{node[@value]}"
-      @code += " " if node[@options][:leading_whitespace]
-      @code += tag_open
+      buffer_freeze " " if node[@options][:leading_whitespace]
+      buffer_freeze "<#{node[@value]}"
 
       # Evaluate node extension in the current context
-      if node[@options][:extension]
-        extension = context.evaluate node[@options][:extension][@value]
-      else
-        extension = {}
+      extension = if node[@options][:extension]
+        buffer_set_variable :extension, node[@options][:extension][@value]
       end
 
       # Evaluate and generate node attributes, then process each one to
       # by generating the required attribute code
       attributes = {}
-      node[@options][:attributes].each do |key, attribute|
-        attributes[key] = map_attribute key, attribute, context
-      end
+      buffer_attributes node[@options][:attributes], extension
 
-      # Go through each extension attribute and use the value where applicable
-      extend_attributes attributes, extension
-
-      # Join arrays, create new attributes by hash and set the
-      # value otherwise
-      attributes.each do |key, value|
-        @code += attribute_code key, value
-      end
-
-      # Set the current node as a parent for the node elements to follow
-      @node_stack << (multi ? :multi : node[@value])
 
       # Check if the current node is self enclosing. Self enclosing nodes
       # do not have any child elements
       if node[@options][:self_enclosing]
         # If the tag is self enclosing, it cannot have any child elements.
-        tag_close = ">"
-        tag_close += "\n"
-
-        @code += tag_close
+        buffer_freeze ">"
       else
         # Set tag ending code
-        tag_end = ">"
-
-        # If the node is an inline node and doesn't have any child elements,
-        # we close it on the same line, without adding indentation
-        tag_end += "\n" unless inline_current || node[@children].empty?
-
-        # Set tag closing code
-        tag_close = "</#{node[@value]}>"
-        tag_close += " " if node[@options][:trailing_whitespace]
-        tag_close += "\n"
-
-        # Add tag ending to the buffer
-        @code += tag_end
-
-        # Get number of siblings
-        @sibling_stack << node[@children].size
+        buffer_freeze ">"
 
         # Process each child element recursively, increasing indentation
         node[@children].each do |child|
           root child, indent + Settings[:indent], context
         end
 
-        # Remove the current node children count from the sibling stack
-        @sibling_stack.pop
-
-        # Remove all child nodes of the current node from the node stack
-        @node_stack.pop(node[@children].size)
-
-        # If we have an inline node, we remove the trailing newline from
-        # our buffer, otherwise add indentation
-        if inline_current
-          remove_trailing_newline
-
-        # If the node doesn't have any child elements, we close it on the same
-        # line, without adding indentation
-        elsif node[@children].any?
-          @code += indentation
-        end
-
-        # Close the current tag
-        @code += tag_close
-      end
-    end
-
-    # Map attributes by evaluating them in the current working context
-    #
-    # @param key [Symbol] Name of the attribute being processed
-    # @param attribute [Array] Attribute instance data
-    # @param context [Context] Processing environment data
-    #
-    def map_attribute(key, attribute, context)
-      # Process input value depending on its type. When array or hash, iterate
-      # and escape each string value.
-      process = Proc.new do |value|
-        case value
-        when Array
-          value.map do |v|
-            v.is_a?(String) ? escape(v) : v
-          end
-        when Hash
-          value.each do |k,v|
-            value[k] = value[k].is_a?(String) ? escape(v) : v
-          end
-        when String
-          escape value
-        else
-          value
-        end
-      end
-
-      # Process each attribute depending on whether it's an array of values,
-      # exclusive to the class attribute, or an individual attribute value
-      if key == :class
-        attribute.map do |attrib|
-          value = context.evaluate attrib[@value]
-          attrib[@options][:escaped] ? process[value] : value
-        end
-      else
-        value = context.evaluate attribute[@value]
-        attribute[@options][:escaped] ? process[value] : value
-      end
-    end
-
-    # Extend attributes using the extension directive where applicable.
-    # Concatenate arrays, merge hashes and replace otherwise
-    #
-    # @param attributes [Hash] Evaluated node attributes
-    # @param extension [Hash] Node extension input
-    #
-    def extend_attributes(attributes, extension)
-      extension.each do |key, value|
-        case attributes[key]
-        when Array
-          if key == :class
-            attributes[key] << value
-            attributes[key].flatten!
-          else
-            attributes[key] = value
-          end
-        when Hash
-          if value.is_a? Hash
-            attributes[key].merge! value
-          else
-            attributes[key] = value
-          end
-        else
-          attributes[key] = value
-        end
-      end
-    end
-
-    # Generate attribute code for the current key value pair. For string
-    # values, generate a key value pair. For false values, remove the
-    # attribute. For true values, generate a standalone attribute key
-    #
-    # @param key [Symbol] Name of the attribute being generated
-    # @param value [Object] Value of the attribute
-    #
-    def attribute_code(key, value)
-      attribute_code = ""
-
-      case value
-      when Array
-        if key == :class
-          attribute_value = value.join ' '
-        else
-          attribute_value = value.join '_'
-        end
-
-        unless attribute_value.empty?
-          attribute_code += " #{key}"
-          attribute_code += "=\"#{attribute_value.strip}\""
-        end
-      when Hash
-        value.each do |k,v|
-          if v
-            attribute_code += " #{key}-#{k}"
-            attribute_code += "=\"#{v.to_s.strip}\"" unless v == true
-          end
-        end
-      else
-        if value
-          attribute_code += " #{key}"
-          attribute_code += "=\"#{value.to_s.strip}\"" unless value == true
-        end
+        # Set tag closing code
+        buffer_freeze "</#{node[@value]}>"
+        buffer_freeze " " if node[@options][:trailing_whitespace]
       end
-
-      return attribute_code
     end
   end
 end