opulent 1.4.0 → 1.4.1

data/lib/opulent/compiler/root.rb

@@ -11,7 +11,7 @@ module Opulent
     def root(current, indent, context)
       if Keywords.include? current[@type]
         send :"#{current[@type]}_node", current, indent, context
-      else
+      else 
         send current[@type], current, indent, context
       end
     end

data/lib/opulent/compiler/text.rb

@@ -9,52 +9,15 @@ module Opulent
     # @param context [Context] Processing environment data
     #
     def plain(node, indent, context)
-      indentation = " " * indent
-
-      inline = @inline_node.include? @node_stack.last
+      value = node[@options][:value]
 
       # Evaluate text node if it's marked as such and print nodes in the
       # current context
       if node[@value] == :text
-        if node[@options][:evaluate]
-          value = context.evaluate "\"#{node[@options][:value]}\""
-        else
-          value = node[@options][:value]
-        end
+        buffer_split_by_interpolation value, node[@options][:escaped]
       else
-        value = if node[@options][:value] == 'yield'
-          context.evaluate_yield
-        else
-          context.evaluate(node[@options][:value])
-        end
-      end
-
-      # Indent all the lines with the given indentation
-      value = indent_lines value, indentation
-
-      # If the last node was an inline node, we remove the trailing newline
-      # character and we left strip the value
-      #pp @node_stack
-      if @node_stack.last == :text
-        remove_trailing_newline
-        value = " " + value.lstrip
-      elsif inline
-        remove_trailing_newline
-        value.lstrip!
+        node[@options][:escaped] ? buffer_escape(value) : buffer(value)
       end
-      value.rstrip!
-
-      # Escape the value unless explicitly set to false
-      value = node[@options][:escaped] ? escape(value) : value
-
-      # Create the text tag to be added
-      text_tag = "#{value}"
-      text_tag += "\n"
-
-      # Set the current child node as last processed node
-      @node_stack << :text
-
-      @code += text_tag
     end
   end
 end

data/lib/opulent/compiler/yield.rb

@@ -0,0 +1,15 @@
+# @Opulent
+module Opulent
+  # @Compiler
+  class Compiler
+    # Generate the code for a while control structure
+    #
+    # @param node [Array] Node code generation data
+    # @param indent [Fixnum] Size of the indentation to be added
+    # @param context [Context] Processing environment data
+    #
+    def yield_node(node, indent, context)
+      buffer_eval "yield if block_given?"
+    end
+  end
+end

data/lib/opulent/context.rb

@@ -33,9 +33,9 @@ module Opulent
     #
     # @param code [String] Code to be evaluated
     #
-    def evaluate(code)
+    def evaluate(code, &block)
       begin
-        eval code, @binding
+        eval code, @binding, &block
       rescue NameError => variable
         Compiler.error :binding, variable, code
       end

data/lib/opulent/engine.rb

@@ -6,92 +6,91 @@ module Opulent
 
   # Module method wrapper for creating a new engine instance
   #
-  def Opulent.new(settings = {})
-    return Engine.new settings
+  def Opulent.new(input, settings = {})
+    return Engine.new input, settings
   end
 
   # @Engine
   class Engine
-    attr_reader :nodes, :definitions, :parser, :file, :preamble, :buffer
+    attr_reader :nodes, :parser, :def, :file, :template, :buffer
 
     # Update render settings
     #
     # @param settings [Hash] Opulent settings override
-    # @param definitions [Hash] Definitions from previously parsed files
+    # @param def [Hash] def from previously parsed files
     # @param overwrite [Boolean] Write changes directly to the parent binding
     #
-    def initialize(settings = {})
-      @definitions = {}
+    def initialize(input, settings = {})
+      # Set def from other Opulent instances
+      @def = settings.delete(:def) || {}
 
+      # Update default settings with user settings
       Settings.update_settings settings unless settings.empty?
-    end
-
-    # Avoid code duplication when layouting is set. When we have a layout, look
-    # in layouts/application by default.
-    #
-    # @param file [String] The file that needs to be analyzed
-    # @param locals [Hash] Render call local variables
-    # @param block [Proc] Processing environment data
-    #
-    def render(input, locals = {}, &block)
-      # If a layout is set, get the specific layout, otherwise, set the default
-      # one. If a layout is set to false, the page will be render as it is.
-      if Settings[:layouts]
-        layout = locals.has_key?(:layout) ? locals.delete(:layout) : Settings[:default_layout]
-
-        # Process with the built in layout system
-        process layout, locals, block do
-          process input, locals, block, &block
-        end
-      else
-        # We pass the same block as content block, in case we're using a
-        # different yielding system from within a web framework using Tilt
-        process input, locals, block, &block
-      end
-    end
 
-    # Analyze the input code and check for matching tokens. In case no match was
-    # found, throw an exception. In special cases, modify the token hash.
-    #
-    # @param file [String] The file that needs to be analyzed
-    # @param locals [Hash] Render call local variables
-    # @param block [Proc] Processing environment data
-    #
-    def process(input, locals, block, &content)
       # Read input parameter based on opening mode. If we have a file mode, we
       # get its path and read the code. We need to reset the mode in case the next
       # render call is on code, not on a file.
       @code = case input
       when Symbol
-        @file = File.expand_path "#{input}.op"
-        File.read @file
+        @file = File.expand_path get_eval_file input; File.read @file
       else
-        @file = File.expand_path __FILE__
-        input
+        @file = File.expand_path __FILE__; input
       end
 
       # Get the nodes tree
-      @nodes, @definitions = Parser.new(@file, @definitions).parse @code
+      @nodes, @def = Parser.new(@file, @def).parse @code
 
-      # @TODO
-      # Implement precompiled template handling
-      @preamble = @nodes.inspect.inspect
+      # Compile our syntax tree using input context
+      @template = Compiler.new.compile @nodes
+    end
 
-      # Create a new context based on our rendering environment
-      @context = Context.new locals, block, &content
+    # Avoid code duplication when layouting is set. When we have a layout, look
+    # in layouts/application by default.
+    #
+    # @param scope [Object] Template evaluation context
+    # @param locals [Hash] Render call local variables
+    # @param block [Proc] Processing environment data
+    #
+    def render(scope = Object.new, locals = {}, &block)
+      # Get opulent buffer value
+      initial_buffer = scope.instance_variable_defined?(:@_opulent_buffer) ? scope.instance_variable_get(:@_opulent_buffer) : []
 
-      # Compile our syntax tree using input context
-      @output = Compiler.new.compile @nodes, @context
+      # If a layout is set, get the specific layout, otherwise, set the default
+      # one. If a layout is set to false, the page will be render as it is.
+      if scope.is_a? binding.class
+        scope_object = eval "self", scope
+        scope = scope_object.instance_eval{ binding } if block_given?
+      else
+        scope_object = scope
+        scope = scope_object.instance_eval{ binding }
+      end
 
-      if DEBUG
-        #puts "Nodes\n---\n"
-        #pp @nodes
+      # Set input local variables in current scope
+      locals.each do |key, value|
+        scope.local_variable_set key, value
+      end
 
-        # puts "\n\nCode\n---\n"
-        # pp @output
+      begin
+        # Evaluate the template in the given scope (context)
+        eval @template, scope
+      rescue ::SyntaxError => e
+        raise SyntaxError, e.message
+      ensure
+        # Get rid of the current buffer
+        scope_object.instance_variable_set :@_opulent_buffer, initial_buffer
       end
+    end
 
-      return @output
+    private
+    # Add .op extension to input file if it isn't already set.
+    #
+    # @param input [Symbol] Input file
+    #
+    def get_eval_file(input)
+      input = input.to_s
+      input += Settings::FileExtension unless File.extname(input) == Settings::FileExtension
+      return input
     end
+
   end
 end

data/lib/opulent/parser.rb

@@ -1,4 +1,3 @@
-require_relative 'parser/block.rb'
 require_relative 'parser/comment.rb'
 require_relative 'parser/control.rb'
 require_relative 'parser/define.rb'
@@ -7,9 +6,10 @@ require_relative 'parser/eval.rb'
 require_relative 'parser/expression.rb'
 require_relative 'parser/filter.rb'
 require_relative 'parser/node.rb'
-require_relative 'parser/require.rb'
+require_relative 'parser/include.rb'
 require_relative 'parser/root.rb'
 require_relative 'parser/text.rb'
+require_relative 'parser/yield.rb'
 
 # @Opulent
 module Opulent
@@ -31,8 +31,8 @@ module Opulent
       @indent = 4
 
       # Set current compiled file as the first in the file stack together with
-      # its base indentation. The stack is used to allow require directives to
-      # be used with the last parent path found 
+      # its base indentation. The stack is used to allow include directives to
+      # be used with the last parent path found
       @file = [[file, -1]]
 
       # Initialize definitions for the parser
@@ -206,12 +206,12 @@ module Opulent
       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 :require
-        "The required file #{data[0]} does not exist or an incorrect path has been specified."
-      when :require_dir
-        "The required file path #{data[0]} is a directory."
-      when :require_end
-        "Unexpected content found after require on line #{@i+1} of input at:\n\n" +
+      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}"

data/lib/opulent/parser/control.rb

@@ -17,9 +17,8 @@ module Opulent
           # Check if arguments provided correctly
           error :each_arguments unless condition.match Tokens[:each_pattern]
 
-          # Split provided arguments for the each structure
-          condition = condition.split(' in ').map(&:strip)
-          condition[0] = condition[0].split(',').map(&:strip).map(&:to_sym)
+          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

data/lib/opulent/parser/expression.rb

@@ -44,7 +44,7 @@ module Opulent
       if buffer.strip.empty?
         return undo buffer
       else
-        return [:expression, buffer.strip, {evaluate: true}]
+        return [:expression, buffer.strip, {}]
       end
     end
 

data/lib/opulent/parser/{require.rb → include.rb}

@@ -13,42 +13,44 @@ module Opulent
     #
     # @param nodes [Array] Parent node to which we append to
     #
-    def require_file(parent, indent)
-      if(match = accept :require)
+    def include_file(parent, indent)
+      if(match = accept :include)
 
         # Process data
-        name = accept :exp_string, :*
+        name = accept :line_feed || ""
+        name.strip!
 
-        # Check if there is any string after the require input
-        unless (feed = accept(:line_feed) || "").strip.empty?
-          undo feed; error :require_end
+
+        # 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
-        require_path = File.expand_path name[1..-2], File.dirname(@file[-1][0])
+        include_path = File.expand_path name, File.dirname(@file[-1][0])
 
         # Try to see if it has any existing extension, otherwise add .op
-        require_path += '.op' unless Settings::Extensions.include? File.extname require_path
+        include_path += Settings::FileExtension if File.extname(name).empty?
 
         # Throw an error if the file doesn't exist
-        error :require, name unless Dir[require_path].any?
+        error :include, name unless Dir[include_path].any?
 
-        # Require entire directory tree
-        Dir[require_path].each do |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]
 
-          @file << [require_path, indent]
+          @file << [include_path, indent]
 
           # Throw an error if the file doesn't exist
-          error :require_dir, file if File.directory? file
+          error :include_dir, file if File.directory? file
 
           # Throw an error if the file doesn't exist
-          error :require, file unless File.file? file
+          error :include, file unless File.file? file
 
           # 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

data/lib/opulent/parser/node.rb

@@ -74,9 +74,9 @@ module Opulent
         # 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 current_node[@options][:self_enclosing] && current_node[@children].any?
+        #   error :self_enclosing_children, line
+        # end
 
         # Create a clone of the definition model. Cloning the options is also
         # necessary because it's a shallow copy
@@ -99,16 +99,28 @@ module Opulent
       model[@options] = {}.merge model[@options]
       model[@options][:call] = call_context
 
-      # Recursively map each child node with its definition 
-      model[@children].map! do |child|
-        if @definitions.keys.include? child[@value]
-          process_definition child[@value], child
+      # Recursively map each child nodes to their definitions
+      # for the initial call node children and for the model
+      # children
+      process_definition_child model[@options][:call]
+      process_definition_child model
+
+      return model
+    end
+
+    def process_definition_child(node)
+      node[@children].map! do |child|
+        if child[@type] == :node
+          if @definitions.keys.include? child[@value]
+            process_definition child[@value], child
+          else
+            process_definition_child child if child[@children]
+            child
+          end
         else
           child
         end
       end
-
-      return model
     end
 
     # Helper method to create an array of values when an attribute is set
@@ -119,13 +131,6 @@ module Opulent
     # @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
@@ -229,7 +234,7 @@ module Opulent
             error :assignments_colon
           end
         else
-          parent[argument] = [:expression, "nil", {evaluate: true, escaped: false}] unless parent[argument]
+          parent[argument] = [:expression, "nil", {escaped: false}] unless parent[argument]
         end
 
         # If our attributes are wrapped, we allow method calls without

data/lib/opulent/parser/root.rb

@@ -21,12 +21,12 @@ module Opulent
         indent = accept(:indent).size
 
         # Stop using the current parent as root if it does not match the
-        # minimum indentation requirements
+        # minimum indentation includements
         unless min_indent < indent
           @i -= 1; break
         end
 
-        # If last require path had a greater indentation, pop the last file path
+        # If last include path had a greater indentation, pop the last file path
         @file.pop if @file[-1][1] > indent
 
         # Try the main Opulent node types and process each one of them using
@@ -39,8 +39,7 @@ module Opulent
                         evaluate(parent, indent)    ||
                         filter(parent, indent)      ||
                         block_yield(parent, indent) ||
-                        block(parent, indent)       ||
-                        require_file(parent, indent)||
+                        include_file(parent, indent)||
                         html_text(parent, indent)   ||
                         doctype(parent, indent)