nitro 0.25.0 → 0.26.0

data/lib/nitro/caching/stores.rb

@@ -2,6 +2,8 @@ require 'fileutils'
 
 require 'mega/synchash'
 
+require 'glue/attribute'
+
 module Nitro
 
 # Adds support for caching.
@@ -20,8 +22,10 @@ module Caching
       self[name] = content
     end
 
+    alias_method :old_delete, :delete
+    
     def delete(name, options = {}) 
-      self.delete(name)
+      old_delete(name)
     end
 
   end
@@ -69,8 +73,16 @@ module Caching
 
   end
 
+  #--
+  # TODO: implement me
+  #++
+  
   class DrbStrore
   end
+
+  #--
+  # TODO: implement me
+  #++
   
   class MemcacheStore
   end

data/lib/nitro/cgi.rb

@@ -1,3 +1,5 @@
+require 'cgi'
+
 require 'glue/configuration'
 require 'nitro/cgi/http'
 
@@ -23,6 +25,12 @@ class Cgi
     context.in = inp
     context.headers = cgi.env
 
+    # gmosx: QUERY_STRING is sometimes not populated.
+
+    if context.query_string.empty? and context.uri =~ /\?/
+      context.headers['QUERY_STRING'] = context.uri.split('?').last
+    end
+
     Cgi.parse_params(context)
     Cgi.parse_cookies(context)
     context.render(context.path)
@@ -293,4 +301,4 @@ end
 end
 
 # * George Moschovitis <gm@navel.gr>
-# * Guillaume Pierronnet <guillaume.pierronnet@gmail.com>
+# * Guillaume Pierronnet <guillaume.pierronnet@gmail.com>

data/lib/nitro/cgi/request.rb

@@ -39,7 +39,7 @@ module Request
 #   443 == port
     @headers['HTTPS'] == 'on'
   end
-    
+
   # The request uri.
 
   def uri
@@ -84,7 +84,14 @@ module Request
   #++
 
   def query_string 
-    @headers['QUERY_STRING']
+=begin
+    qs = headers['QUERY_STRING']
+    if qs.empty? and uri =~ /\?/
+      qs = headers['QUERY_STRING'] = uri.split('?').last
+    end
+    return qs
+=end
+    headers['QUERY_STRING']
   end
   
   # The request method. Alternatively you could use the 
@@ -160,6 +167,7 @@ module Request
     not /XMLHttpRequest/i.match(@headers['HTTP_X_REQUESTED_WITH']).nil?
   end
   alias xhr? :xml_http_request?
+  alias ajax? :xml_http_request?
     
   # Return the referer. For the initial page in the
   # clickstream there is no referer, set "/" by default.
@@ -187,7 +195,7 @@ module Request
 
     if @headers.include?('HTTP_X_FORWARDED_FOR') then
       remote_ips = @headers['HTTP_X_FORWARDED_FOR'].split(',').reject do |ip|
-        ip =~ /^unknown$|^(10|172\.16|192\.168)\./i
+        ip =~ /^unknown$|^(127|10|172\.16|192\.168)\./i
       end
 
       return remote_ips.first.strip unless remote_ips.empty?

data/lib/nitro/cgi/utils.rb

@@ -10,7 +10,9 @@ module Request
   # Different servers hold user agent in differnet 
   # strings (unify this).
   
-  def user_agent
    headers['HTTP_USER_AGENT'] || headers['USER-AGENT']
  end
+  def user_agent
+    headers['HTTP_USER_AGENT'] || headers['USER-AGENT']
+  end
 
   def from_gecko?
     user_agent =~ /Gecko/
@@ -34,9 +36,29 @@ module Request
   def from_w3c?
     from_gecko? or from_khtml? or from_opera?
   end
+  
+  def from_osx?
+    user_agent =~ /Mac OS X/ or user_agent =~ /Mac_PowerPC/
+  end
+
+  def from_os9?
+  end
+  
+  def from_mac?
+    from_osx? or from_os9?
+  end
+  
+  def from_unix?
+    user_agent =~ /linux/ or user_agent =~ /FreeBSD/
+  end
+  alias_method :from_linux?, :from_unix?
+  
+  def from_windows?
+    user_agent =~ /Windows/
+  end
 
 end
 
 end
 
-# * Chris Farmiloe <chris.farmiloe@farmiloe.com>
+# * Chris Farmiloe <chris.farmiloe@farmiloe.com>

data/lib/nitro/compiler.rb

@@ -1,7 +1,13 @@
 require 'nano/kernel/singleton'
 
 require 'glue/template'
+
+require 'nitro/compiler/elements'
 require 'nitro/compiler/errors'
+require 'nitro/compiler/markup'
+require 'nitro/compiler/morphing'
+require 'nitro/compiler/include'
+require 'nitro/compiler/cleanup'
 
 module Nitro
 
@@ -13,6 +19,10 @@ class Compiler
   unless const_defined? :PROTO_TEMPLATE_ROOT
     PROTO_TEMPLATE_ROOT = "#{Nitro.proto_path}/public"
   end
+
+  # The controller for this compiler.
+  
+  attr_accessor :controller
   
   # Set to true to force reloading of code and templates for
   # each request. Extremely useful during development. Must be
@@ -20,50 +30,81 @@ class Compiler
   # performance penalty.
   
   setting :reload, :default => true, :doc => 'If true all code and templates are reloaded in each request'
-  
+
+  def initialize(controller = nil)
+    @controller = controller
+  end
+
   # Action names with double underscores (__) are converted
   # to subdirectories. Here are some example mappings:
   #
   # hello_world -> template_root/hello_world.xhtml
   # this__is__my__hello_world -> template_root/this/is/my/hello_world
   
-  def template_for_action(action, template_root = Template.root, ext = Template.extension)
-    # attempt to find a template of the form
-    # template_root/action.xhtml
+  def template_for_action(action, ext = Template.extension)
+    cklass = @controller
+    template_root = nil
+    checked_proto = nil
+    
+    # search for template in controller and its ancestors's template_root
+    # if there is not an action defined in controller then also check in
+    # PROTO_TEMPLATE_ROOT
 
-    path = "#{template_root}/#{action.gsub(/__/, '/')}.#{ext}".squeeze('/')
+    loop do
+      if cklass.respond_to?(:template_root) && template_root = cklass.template_root
+        cklass = cklass.superclass
+      elsif !@controller.respond_to?(:action) && !checked_proto
+        template_root = PROTO_TEMPLATE_ROOT
+        checked_proto = true
+      else
+        return nil # no template found
+      end
+      
+      # attempt to find a template of the form
+      # template_root/action.xhtml
 
-    unless File.exist?(path)
+      path = "#{template_root}/#{action.gsub(/__/, '/')}.#{ext}".squeeze('/')
+      return path if File.exist?(path)
+    
       # attempt to find a template of the form
       # template_root/action/index.xhtml
 
       path = "#{template_root}/#{action.gsub(/__/, '/')}/#{Template.default}.#{ext}".squeeze('/')
-      
-      unless File.exist?(path)  
-        # No template found!
-        return nil
-      end
+      return path if File.exist?(path) 
     end
+  end
+  alias_method :template?, :template_for_action
+
+  # Helper.
 
-    return path
+  def action?(sym)
+    return @controller.action_methods.include?(sym.to_s)
   end
 
-  # This is methods transforms the template. Typically 
+  # This method transforms the template. Typically 
   # template processors are added as aspects to this method 
   # to allow for customized template transformation prior 
   # to compilation.
   # 
   # The default transformation extracts the Ruby code from
-  # processing instructions.
+  # processing instructions, and uses the StaticInclude,
+  # Morphing, Elements and Markup compiler modules.
   
   def transform_template(template)
-    Template.transform(template)
+    template = StaticInclude.transform(template)
+    template = Morphing.transform(template)
+    template = Elements.transform(template)
+    template = Markup.transform(template)
+    template = Cleanup.transform(template)
+    template = Template.transform(template)
   end
 
   # Compile the template into a render method.
+  # Don't compile the template if the controller
+  # responds_to? #{action}_template.
   
-  def compile_template(klass, action, path)
-    Logger.debug "Compiling template '#{klass}: #{path}'" if $DBG
+  def compile_template(action, path)
+    Logger.debug "Compiling template '#{@controller}: #{path}'" if $DBG
 
     template = File.read(path)
   
@@ -74,7 +115,7 @@ class Compiler
     }
 
     begin
-      klass.class_eval(code, path)
+      @controller.class_eval(code, path)
     rescue SyntaxError => e
       raise TemplateCompileError.new(code, template, e)
     end        
@@ -88,18 +129,12 @@ class Compiler
   # TODO: cleanup this method.
   #++
   
-  def compile_action(klass, action)    
-    #--
-    # gmosx: Move elsewhere.
-    #++
-    
-    Aspects.include_advice_modules(klass)
-    
+  def compile_action(action)    
     action = action.to_s.gsub(/_action$/, '')
-    
+
     return false unless action
 
-    Logger.debug "Compiling action '#{klass}##{action}'" if $DBG
+    Logger.debug "Compiling action '#@controller##{action}'" if $DBG
 
     valid = false
     
@@ -111,16 +146,16 @@ class Compiler
   
     # Inject the pre advices.
 
-    code << Aspects.gen_advice_code(action, klass.advices, :pre) 
+    code << Aspects.gen_advice_code(action, @controller.advices, :pre) 
 
     # Call the action
     
-    if klass.action_methods.include?(action)
+    if @controller.action_methods.include?(action)
       valid = true
 
       # Annotated parameters.
 
-      if params = klass.ann(action.to_sym).params and (!params.nil?)
+      if params = @controller.ann(action.to_sym).params and (!params.nil?)
         params = params.collect { |p| "@#{p} = @context['#{p}']" }
         code << "#{params.join(';')}"
       end
@@ -128,7 +163,7 @@ class Compiler
       # Try to resolve action parameters. Returns negative
       # numbers for arbitrary parameters.
 
-      param_count = klass.instance_method(action.intern).arity 
+      param_count = @controller.instance_method(action.intern).arity 
       
       if param_count != 0
         if param_count > 0 
@@ -172,38 +207,22 @@ class Compiler
 
     # Take :view annotation into account.
     
-    view = klass.ann(action.to_sym).view # FIXME
+    view = @controller.ann(action.to_sym).view # FIXME
     view = action if view.nil?
 
-    cklass = klass    
-    template_path = nil
-
-    loop do
-      template_root = nil
-
-      if cklass.respond_to?(:template_root)
-        template_root = cklass.template_root
-      end
-
-      # Don't use a proto template if there is an action 
-      # defined.      
-      
-      template_root ||= PROTO_TEMPLATE_ROOT unless valid
-
-      if template_root and template_path = template_for_action(view.to_s, template_root)
-        valid = true
-        code << %{
-          #{action}_template;
-        }
-        break
-      end 
-      
-      break unless cklass = cklass.superclass
+    # Search the [controller] class and it's ancestors for the template
+    
+    template_path = template_for_action(view.to_s) 
+    if template_path or @controller.instance_methods.include?("#{action}_template")
+      valid = true
+      code << %{
+        #{action}_template
+      }
     end
 
     return false unless valid
 
-    if klass.action_methods.include?(action)
+    if @controller.action_methods.include?(action)
       code << %{
         if @out.empty? and action_return_value.is_a?(String)
           print(action_return_value)
@@ -220,7 +239,7 @@ class Compiler
 
     # Inject the post advices.
 
-    code << Aspects.gen_advice_code(action, klass.advices, :post) 
+    code << Aspects.gen_advice_code(action, @controller.advices, :post) 
 
     code << %{
         @action_name = @parent_action_name
@@ -230,12 +249,16 @@ class Compiler
     # First compile the action method. 
     
 #    begin
-      klass.class_eval(code)
+      @controller.class_eval(code)
 #    rescue SyntaxError => e
 #      raise ActionCompileError.new(code, action, e)
 #    end
-    
-    compile_template(klass, action, template_path) if template_path
+
+    unless @controller.respond_to?("#{action}_template")
+      if template_path 
+        compile_template(action, template_path)
+      end
+    end
 
     return true
   end
@@ -243,8 +266,8 @@ class Compiler
   # Compiles an action method in the given (controller) class.
   # A sync is used to make compilation thread safe.
   
-  def compile(klass, action)
-    compile_action(klass, action)
+  def compile(action)
+    compile_action(action)
   end
 
   # :section: Helper methods.
@@ -279,3 +302,6 @@ class Compiler
 end
 
 end
+
+# * George Moschovitis <gm@navel.gr>
+# * Chris Farmiloe <chris.farmiloe@farmiloe.com>

data/lib/nitro/compiler/cleanup.rb

@@ -0,0 +1,16 @@
+module Nitro
+
+# Tidy up the html
+
+module Cleanup
+  
+  def self.transform(text)
+    Glue::Html.cleanup(text)
+  end
+  
+end
+
+end
+
+# * George Moschovitis <gm@navel.gr>
+# * Chris Farmiloe <chris.farmiloe@farmiloe.com>

data/lib/nitro/compiler/elements.rb

@@ -0,0 +1,117 @@
+require 'rexml/document'
+require 'rexml/streamlistener'
+
+require 'nitro/element'
+require "glue/html"
+
+module Nitro
+
+# A compiler that handles the processing of Elements
+
+class Elements # :nodoc: all
+
+  class Listener # :nodoc: all
+    include REXML::StreamListener
+    
+    attr_accessor :buffer
+    attr_accessor :stack
+    
+    def initialize
+      super
+      @buffer = ''
+      @stack = []
+    end
+    
+    PREFIX_RE = /^#{Element.prefix}:/
+    CAPITALIZED_RE = /^[A-Z]/
+    
+    def tag_start(name, attributes)    
+      # 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
+        
+        obj = Object.const_get(name).new
+        
+        attributes.each do | k, v | 
+          obj.instance_variable_set("@#{k}", v)
+        end        
+        
+        @stack.push [obj, @buffer, @parent]
+        
+        @buffer = obj._text
+        @parent.add_child(obj) if @parent
+        
+        @parent = obj
+      else # This is a static element.
+        attrs = []
+        
+        attributes.each do | k, v | 
+          attrs << %|#{k}="#{v}"|
+        end
+        
+        attrs = attrs.empty? ? nil : " #{attrs.join(' ')}"
+        
+        @buffer << "<#{name}#{attrs}>"
+      end
+    end
+
+    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
+        obj, @buffer, @parent = @stack.pop
+        @buffer << obj.render
+      else
+        @buffer << "</#{name}>"
+      end
+    end
+    
+    def text(str)
+      @buffer << str
+    end
+    
+    def instruction(name, attributes)
+      @buffer << "<?#{name}#{attributes}?>"
+    end
+
+    def comment(c)
+      unless Template.strip_xml_comments
+        @buffer << "<!--#{c}-->"
+      end
+    end
+  end
+  
+  class << self
+    def parse(source)
+      self.new.parse(source)
+    end
+    
+    def transform(source)
+      self.new.transform(source)
+    end
+  end
+
+  # Expand the elemens found in source.
+    
+  def transform(source)
+    listener = Listener.new
+    REXML::Document.parse_stream(source, listener)
+    # gmosx, FIXME: optimize this, how?
+    # gmosx, FIXME: this is a hack fix, improve.
+    # TODO:farms why is cleanup called this many times?!?!? ... waste of gsubs
+    return listener.buffer
+  end
+end
+
+# An (old) alias.
+
+unless const_defined? :ElementProcessor
+   ElementProcessor = Elements
+end
+
+end
+
+# * George Moschovitis <gm@navel.gr>
+# * Chris Farmiloe <chris.farmiloe@farmiloe.com>