nitro 0.28.0 → 0.29.0

data/lib/nitro/compiler/elements.rb

@@ -1,9 +1,11 @@
 require 'rexml/document'
 require 'rexml/streamlistener'
+require 'facet/class/by_name'
 
 require 'nitro/element'
 require "glue/html"
 
+
 module Nitro
 
 # A compiler that handles the processing of Elements
@@ -16,8 +18,9 @@ class Elements # :nodoc: all
     attr_accessor :buffer
     attr_accessor :stack
     
-    def initialize
-      super
+    def initialize(compiler)
+      super()
+      @compiler = compiler
       @buffer = ''
       @stack = []
     end
@@ -29,35 +32,20 @@ class Elements # :nodoc: all
       # check if the name starts with the element prefix, or
       # is capitalized.
       
-      if name =~ PREFIX_RE or name =~ CAPITALIZED_RE    
-        name = name.split(':')[1].camelize if name =~ PREFIX_RE
-
-        # First try to use Nitro::Element::xxx then ::xxx
-                
-        if klass = Nitro::Element.const_get(name) || Object.const_get(name)
-          unless klass.ancestors.include? Nitro::Element
-            if Element.auto_extend
-              klass.send(:include, Nitro::ElementMixin)
-            else
-              Logger.error "Invalid element class '#{name}', does not extend Nitro::Element"
-            end
-          end
-        else
-          Logger.error "The class of this element tag '#{name}' does not exist"
-        end
-                        
-        if klass and obj = klass.new        
-          attributes.each do | k, v | 
-            obj.instance_variable_set("@#{k}", v)
-          end        
+      if klass = is_element?(name)
+
+        obj = klass.new 
+        attributes.each do | k, v | 
+          obj.instance_variable_set("@#{k}", v)
+        end        
           
-          @stack.push [obj, @buffer, @parent]
+        @stack.push [obj, @buffer, @parent]
           
-          @buffer = obj._text
-          @parent.add_child(obj) if @parent
+        @buffer = obj._text
+        @parent.add_child(obj) if @parent
           
-          @parent = obj
-        end
+        @parent = obj
+
       else # This is a static element.
         attrs = []
         
@@ -74,14 +62,66 @@ class Elements # :nodoc: all
     def tag_end(name)    
       # check if the name starts with the element prefix, or
       # is capitalized.
-      if name =~ PREFIX_RE or name =~ CAPITALIZED_RE    
-         name = name.split(':')[1].camelize if name =~ PREFIX_RE
+      if is_element? name
         obj, @buffer, @parent = @stack.pop
         @buffer << obj.render
       else
         @buffer << "</#{name}>"
       end
     end
+
+
+    # Check if a tag is a Nitro::Element. If found, it also tries to
+    # auto-extend the klass.
+    #
+    # returns the Element class if found
+    def is_element?(name)
+      # Doesn't support modulized classes
+#      name = name.demodulize
+      return false unless name =~ PREFIX_RE or name =~ CAPITALIZED_RE
+
+      name = name.gsub(/#{PREFIX_RE}:/,'').camelize if name =~ PREFIX_RE
+
+      # First try to use Nitro::Element::xxx then ::xxx
+      
+      begin
+        klass = Class.by_name("Nitro::Element::#{name}")
+      rescue
+      end
+
+      # Look into the module the controller's module if any
+
+      begin
+        namespace = @compiler.controller.name
+        if /::/ =~ namespace
+          namespace = namespace.gsub( /::[a-zA-Z]+$/, "::#{name}" )
+          pp namespace
+          klass = Class.by_name(namespace)
+        end
+      rescue
+      end unless klass
+
+      # Look in the root module
+
+      begin
+        klass = Class.by_name(name)
+      rescue
+      end unless klass
+
+      return false unless klass.kind_of?( Class )
+
+      # Try to auto-extend
+
+      unless klass.ancestors.include? Nitro::Element
+        if Element.auto_extend
+          klass.send(:include, Nitro::ElementMixin)
+        else
+          return false
+        end
+      end
+
+      return klass
+    end
     
     def text(str)
       @buffer << str
@@ -92,7 +132,7 @@ class Elements # :nodoc: all
     end
 
     def comment(c)
-      unless Template.strip_xml_comments
+      unless Glue::Template.strip_xml_comments
         @buffer << "<!--#{c}-->"
       end
     end
@@ -116,7 +156,7 @@ class Elements # :nodoc: all
   #++
     
   def transform(source, compiler)
-    listener = Listener.new
+    listener = Listener.new(compiler)
 
     REXML::Document.parse_stream(source, listener)
     

data/lib/nitro/compiler/errors.rb

@@ -1,65 +1,115 @@
 require 'facet/ormsupport'
 
-module Nitro
+# This supports source code extraction from a full
+# backtrace from any exception and also exposes class
+# methods incase you wish to harness them from elsewhere.
+#--
+# TODO: Cache source code? Memory vs Speed - Is it worth
+# it?
+# FIXME: Don't change the Exception class, use NitroException
+# or something.
+#++
 
-class ActionCompileError < SyntaxError
-  SOURCE_CODE_RADIUS = 5
+class Exception
 
-  attr_accessor :original_excpetion
-    
-  def initialize(source_code, filename, original_exception)
-    @source_code = source_code.split("\n")
-    @filename = filename
-    @original_exception = original_exception
-  end
+  # Radius of the source code to display arround the error line.
   
-  def line_number
-    trace = @original_exception.backtrace.join
+  SOURCE_RADIUS = 5
+  
+  class << self
 
-    if trace.include?(":in `class_eval'")
-      trace.scan(/:([0-9]*):in `class_eval'/).first.first.to_i
-    else
-      1
+    # Extracts the filename and line from the given line (step)
+    # of the backtrace.
+      
+    def file_and_line_no(step)
+      file = no = nil
+      if res = step.match(/^(.+):(\d+)$/)
+        file = res[1]
+        no = res[2]
+      elsif res = step.match(/^(.+):(\d+):in `.+'$/)
+        file = res[1]
+        no = res[2]
+      end
+      if file and no
+        [file,no.to_i]
+      else
+        nil
+      end
     end
-  end
+
+    # Extract the source arround the error line.
+        
+    def source_extract(step, indent = 0)
+      begin
+        file, no = file_and_line_no(step)        
+        source = File.read(file)
+
+        if file =~ /\.xhtml$/
+          source = Compiler.new.transform_template(source)
+          no -= 2
+        end
+
+        source = source.split("\n")
+        start = (no-1) - SOURCE_RADIUS
+        finish = (no-1) + SOURCE_RADIUS
+        start = 0 if start < 0
+        finish = source.size if finish > source.size
   
-  def source_extract(indent = 0)
-    ln = line_number
-    start_line = [ln - SOURCE_CODE_RADIUS, 0].max
-    end_line = [ln + SOURCE_CODE_RADIUS - 1, @source_code.length].min
+        number = start
+        extract = source[start..finish].collect do |line| 
+          number += 1
+          line = line.gsub(/; @out << %\^/, ' ?>').gsub(/\^;/, '<?r ')
+          "#{' ' * indent}#{number}: #{line}"
+        end  
 
-    number = start_line
-    extract = @source_code[start_line..end_line].collect do |line| 
-      number += 1
-      line = line.gsub(/; @out << %\^/, ' ?>').gsub(/\^;/, '<?r ')
-      if number == line_number
-        "#{' ' * indent}#{number}: #{line}"
-      else
-        "#{' ' * indent}#{number}: #{line}"
+        return extract.join("\n")
+      rescue => ex
+        ''
       end
     end
+    
+  end
 
-    return extract.join("\n")
+  # Identifies the 'hot' index in the backtrace, where the error
+  # actually happened.
+  
+  def hot_trace_index
+    index = 0
+    while backtrace[index] =~ /controller\.rb(.*)method_missing/ 
+      index += 1
+    end
+    return index
   end
 
-  def backtrace  
-    @original_exception.backtrace.collect do |line|
-      line.gsub("#{Nitro::LibPath}/", '')
-    end.compact
+  # Returns the 'hot' backtrace line.
+    
+  def hot_trace_step
+    backtrace[hot_trace_index]
   end
 
-  def to_s
-    "#{self.class.to_s.demodulize} (#{@original_exception.class}): '#@filename' at line ##{line_number}"
+  # Returns the 'hot' backtrace file.
+    
+  def hot_file
+    file_and_line_no(hot_trace_step).first
   end
   
-  def message
-    "#{to_s}\n#{source_extract}"
+  def file_and_line_no(step)
+    self.class.file_and_line_no(step)
+  end
+  
+  def source_extract(step = hot_trace_step, indent = 0)
+    self.class.source_extract(step,indent)
+  end
+  
+  # Extract source for backtrace.
+  
+  def source_for_backtrace(indent = 0)
+    backtrace.inject([]) do |sources, step| 
+      sources << source_extract(indent,step)
+    end
   end
-end
   
-class TemplateCompileError < ActionCompileError
-end
-
 end
 
 # * George Moschovitis <gm@navel.gr>
+# * Rob Pitt <rob@motionpath.co.uk>

data/lib/nitro/compiler/include.rb

@@ -7,27 +7,57 @@ module Nitro
 # to use static includes in many many cases.
  
 class StaticInclude
-  #--
-  # FIXME: use template root of the controller.
-  #++
+  # Statically include sub-template files.
+  # The target file is included at compile time.
+  # If the given path is relative, the template_root stack of
+  # the controller is traversed. If an absolute path is provided,
+  # templates are searched only in Template.root
+  #
+  # gmosx: must be xformed before the <?r pi.
+  #
+  # === Example    
+  # <?include href="root/myfile.sx" ?>
   
-  def self.transform(text)
-    # Statically include sub-template files.
-    # The target file is included at compile time.
-    #
-    # gmosx: must be xformed before the <?r pi.
-    #
-    # Example:    
-    # <?include href="root/myfile.sx" ?>
-
+  def self.transform(text, compiler)
+    controller = compiler.controller
+    
     return text.gsub(/<\?include href=["|'](.*?)["|'](.*)\?>/) do |match|
-      unless File.exist?(filename = "#{Template.root}/#$1")
-       unless File.exist?(filename = "#{Template.root}/#$1.xinc")
-          unless File.exist?(filename = "#{Template.root}/#$1.xhtml")
-            raise "Cannot include '#{Template.root}/#$1'"
-          end
+      found = false
+
+      if $1[0] == ?/
+        # Absolute path, search only in the application template
+        # root.
+
+        href = $1[1, 999999] # hack!!
+        template_stack = [ Glue::Template.root ]
+      else
+        # Relative path, traverse the template_root stack.
+        
+        href = $1
+        template_stack = controller.instance_variable_get(:@template_root)
+      end
+        
+      for template_root in template_stack
+        if File.exist?(filename = "#{template_root}/#{href}")
+          found = true
+          break
+        end
+
+        if File.exist?(filename = "#{template_root}/#{href}.xinc")
+          found = true
+          break
+        end
+
+        if File.exist?(filename = "#{template_root}/#{href}.xhtml")
+          found = true
+          break
         end
       end
+      
+      unless found
+        raise "Cannot statically include '#{href}'"
+      end      
+
       itext = File.read(filename)
       itext.gsub!(/<\?xml.*\?>/, '')
       itext.gsub!(/<\/?root(.*?)>/m, ' ');

data/lib/nitro/compiler/morphing.rb

@@ -4,8 +4,6 @@ require 'rexml/streamlistener'
 require 'facet/dictionary'
 require 'facet/string/blank'
 
-require 'glue/html'
-
 module Nitro
 
 # :section: A collection of standard morphers.
@@ -205,7 +203,7 @@ class Morphing
     end
 
     def comment(c)
-      unless Template.strip_xml_comments
+      unless Glue::Template.strip_xml_comments
         @buffer << "<!--#{c}-->"
       end
     end    

data/lib/nitro/compiler/script.rb

@@ -87,13 +87,13 @@ module ScriptCompiler
       js_buffer = compiler.shared[:js_buffer]
       
       if script or js_buffer
-        text.sub!(/<\/html>/) do |match|
+        text.sub!(/<\/body>/) do |match|
           %{
             <script type="text/javascript">
               #{script}
               #{js_buffer}
             </script>
-          </html>
+          </body>
           }
         end
       end

data/lib/nitro/context.rb

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 require 'facet/kernel/assign_with'
 
 require 'nitro/cgi'
@@ -21,6 +23,10 @@ class Context
   include Response
   include Render
 
+  # The cache/store used to back global variables.
+  
+  setting :global_cache_class, :default => ($NITRO_GLOBAL_CACHE_CLASS || MemoryCache), :doc => 'The store used to back global variables'
+
   # The configuration parameters.
 
   attr_accessor :conf
@@ -60,6 +66,8 @@ class Context
       if @session.has_key?(:FLASH)
         @session[:FLASH].clean
       end
+      
+      # INVESTIGATE: is this needed?      
       @session.sync 
     end
   end
@@ -85,6 +93,14 @@ class Context
     @session || @session = Session.lookup(self)
   end
 
+  # Access global variables. In a distributed server scenario,
+  # these variables can reside outside of the process.
+  
+  def global
+    return $global
+  end
+  alias_method :application, :global
+
   # Lookup the controller for this request.
   #--
   # FIXME: improve this! BUGGY
@@ -101,6 +117,14 @@ class Context
   #
   # * name
   # * force_boolean
+  #
+  # === Example
+  #
+  # request.fill(User.new)
+  #
+  # Prefer to use the following form:
+  #
+  # User.new.assign_with(request)
   
   def fill(obj, options = {})
     Property.populate_object(obj, @params, options)
@@ -110,6 +134,18 @@ class Context
   
 end
 
+# Forwards to the context
+# 
+# use in Nitro::Action
+
+module ContextHelper
+  extend Forwardable
+
+  attr_accessor :context
+
+  def_delegators :@context, :controller, :request, :response, :session, :out
+end
+
 end
 
 # * George Moschovitis <gm@navel.gr>