nitro 0.29.0 → 0.30.0

data/lib/nitro/compiler/script.rb

@@ -8,7 +8,7 @@ module Nitro
 
 module ScriptCompiler
   extend JavascriptHelper
-  
+
   def self.transform(text, compiler)
     begin
       client = constant("#{compiler.controller}::Client")    
@@ -21,9 +21,11 @@ module ScriptCompiler
       client = client.new
       
       functions = {}
+      params = {}
           
-      text.scan(/__nc_(.*)\(\)/) do |match|
+      text.scan(/__nc_(.*)\((.*)\)/) do |match|
         functions[match.first] = true
+        params[match.last] = true
       end    
       
       script = ''
@@ -38,13 +40,13 @@ module ScriptCompiler
           
           function_code = client.buffer
           
-          # if the client action returs a String append it to
+          # if the client action returns a String append it to
           # the function code.
           
           function_code << ret if ret.is_a?(String)
           
           script << %{
-            function __nc_#{fun}() {
+            function __nc_#{fun}(params) {
               #{function_code}
             }
           }
@@ -53,51 +55,57 @@ module ScriptCompiler
         end
       end
 
-      # Inject css in the head tag.
-      
-      if css_buffer = compiler.shared[:css_buffer]
-        text.sub!(/<\/head>/) do |match|
-          %{
-            <style>
-              #{css_buffer}
-            </style>
-          </head>
-          }
-        end
+    end
+    
+    # Inject css in the head tag.
+    
+    if css_buffer = compiler.shared[:css_buffer]
+      text.sub!(/<\/head>/) do |match|
+        %{
+          <style>
+            #{css_buffer}
+          </style>
+        </head>
+        }
       end
+    end
 
-      # Inject required javascript files in the head tag.
-      
-      if required_files = compiler.shared[:js_required_files]
-        text.sub!(/<\/head>/) do |match|
-          %{
-            #{include_script *required_files.keys}
-          </head>
-          }
-        end
+    # Inject required javascript files in the head tag.
+
+    required_files = Javascript.required_files
+    if crf = compiler.shared[:js_required_files]
+      required_files.concat(crf.keys)
+    end
+    
+    unless required_files.empty?
+      text.sub!(/<\/head>/) do |match|
+        %{
+          #{include_script *required_files}
+        </head>
+        }
       end
-      
-      # Inject javascript just before the end of the
-      # template.
-      #--
-      # gmosx: injection happens at the end, so that the DOM
-      # tree is created. Dunno if this is valid xhtml though.
-      #++
+    end
+    
+    # Inject javascript just before the end of the
+    # template.
+    #--
+    # gmosx: injection happens at the end, so that the DOM
+    # tree is created. Dunno if this is valid xhtml though.
+    #++
 
-      js_buffer = compiler.shared[:js_buffer]
-      
-      if script or js_buffer
-        text.sub!(/<\/body>/) do |match|
-          %{
-            <script type="text/javascript">
-              #{script}
-              #{js_buffer}
-            </script>
-          </body>
-          }
-        end
+    js_buffer = compiler.shared[:js_buffer]
+    
+    if script or js_buffer
+      text.sub!(/<\/body>/) do |match|
+        %{
+          <script type="text/javascript">
+            #{script}
+            #{js_buffer}
+          </script>
+        </body>
+        }
       end
-    end  
+    end
     
     return text
   end

data/lib/nitro/compiler/squeeze.rb

@@ -1,12 +1,13 @@
 module Nitro
-  
-# Compress the inline xhtml. Does not touch the ruby code.
+
+# A compiler transformation pipeline stage that compresses
+# the generated xhtml code.   
  
 class Squeeze
   
   # Compresses the inline xhtml. Does not touch the ruby code.
    
-  def self.transform(text)
+  def self.transform(text, compiler = nil)
     return text.gsub(/\@out \<\< \%\^(.*?)\^/m) do |match|
       c = $1.gsub(/^(\s*)/m, '').squeeze(" \t").tr("\n", '').tr("\t", ' ')
       "@out << %{#{c}}"

data/lib/nitro/compiler/xslt.rb

@@ -4,10 +4,12 @@ require 'xml/xslt'
 
 module Nitro
 
-# Apply XSL transformation.
+# Pre-applies an XSL transformation to the template file to 
+# generate the final template file. Due to preproccessing, the
+# transformation comes for free.
 
 class XSLTransform
-    @@sync = Sync.new
+  @@sync = Sync.new
 
   class << self
 
@@ -34,8 +36,7 @@ class XSLTransform
     
     # Transform the given xml.
     
-    def transform(text)
-      
+    def transform(text, compiler = nil)      
       parse_xsl()
       @xslt.xml = text
       hash += @name
@@ -43,8 +44,8 @@ class XSLTransform
       process_next(hash, xslt.serve)
     end
     
-    private 
-    
+  private 
+  
     # Parse the xsl.
     
     def parse_xsl

data/lib/nitro/context.rb

@@ -2,10 +2,13 @@ require 'forwardable'
 
 require 'facet/kernel/assign_with'
 
+require 'glue/cache/memory'
+
 require 'nitro/cgi'
 require 'nitro/cgi/request'
 require 'nitro/cgi/response'
 require 'nitro/render'
+require 'nitro/global'
 require 'nitro/session'
 
 module Nitro
@@ -16,17 +19,14 @@ module Nitro
 # 
 # The Context object can be accessed by the context, request or 
 # response aliases. You can use the alias that makes sense 
-# every time.
+# every time. This means inside an action request, response and
+# context all point to the same object.
 
 class Context
   include Request
   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
@@ -42,7 +42,15 @@ class Context
 
   attr_accessor :dispatcher
 
+  # The rendering level. An action may include sub-actions,
+  # each time the action is called, the level is increased,
+  # when the action returns the level decreases. The first
+  # action, called top level action has a level of 1.
+  
+  attr_accessor :level
+
   def initialize(conf)
+    @level = 0
     @conf = conf
     @dispatcher = @conf.dispatcher
     @context = self
@@ -57,6 +65,17 @@ class Context
     @out ||= OutputBuffer.new
   end
 
+
+  # Don't sync session. This method may be needed in low level 
+  # hacks with the session code. For example if you updade an
+  # entity (managed) object that is cached in the session, you
+  # may dissable the syncing to avoid resetting the old value
+  # after the sync.
+  
+  def no_sync!
+    @no_sync = true
+  end
+  
   # Close the context, should be called at the 
   # end of the HTTP request handling code.
 
@@ -67,12 +86,14 @@ class Context
         @session[:FLASH].clean
       end
       
-      # INVESTIGATE: is this needed?      
-      @session.sync 
+      # INVESTIGATE: is this needed?
+      @session.sync unless @no_sync
     end
   end
   alias_method :finish, :close
 
+  # The accomulated output for the current context (ie the 
+  # current request).
   #--
   # FIXME: still something more elegant/efficient.
   #++
@@ -97,7 +118,7 @@ class Context
   # these variables can reside outside of the process.
   
   def global
-    return $global
+    return Global
   end
   alias_method :application, :global
 
@@ -132,18 +153,16 @@ class Context
   alias_method :populate, :fill
   alias_method :assign, :fill  
   
-end
-
-# Forwards to the context
-# 
-# use in Nitro::Action
-
-module ContextHelper
-  extend Forwardable
-
-  attr_accessor :context
-
-  def_delegators :@context, :controller, :request, :response, :session, :out
+  # Is the current action the top level action? The level
+  # of the top action is 1.
+  
+  def is_top_level?
+    @level == 1
+  end
+  alias_method :is_top?, :is_top_level?
+  alias_method :in_top_level?, :is_top_level?
+  alias_method :top_level?, :is_top_level?
+  
 end
 
 end

data/lib/nitro/controller.rb

@@ -1,7 +1,7 @@
 require 'facet/annotation'
 require 'facet/inheritor'
+require 'facets/more/aspects'
 
-require 'glue/aspects'
 require 'glue/markup'
 
 require 'nitro'
@@ -37,12 +37,13 @@ module Nitro
 
 
 module Publishable
+
   def self.included(base)
     super
 
     base.module_eval do
       include Render
-      include Glue::Aspects
+      include ::Aspects
       include Flashing
       include Helpers
     end
@@ -154,6 +155,13 @@ module Publishable
           @template_root.reverse!
         end
         alias_method :mount, :mount_at
+
+        # Returns the path where this controller is mounted.
+        
+        def mount_path
+          @mount_path
+        end
+        alias_method :mount_point, :mount_path
       end
     end
     
@@ -170,10 +178,21 @@ private
     @context.cookies
   end  
 
+  # Send the cookie to the response stream.
+  
   def send_cookie(name, value = nil)
     @context.add_cookie(name, value)
   end
 
+  # Delete the cookie by setting the expire time to now and 
+  # clearing the value.
+  
+  def delete_cookie(name)
+    cookie = Cookie.new(name, '')
+    cookie.expires = Time.now  
+    @context.add_cookie(cookie)    
+  end
+  
   # Encode controller, action, params into a valid url.
   # Automatically respects nice urls and routing.
   #
@@ -210,10 +229,10 @@ private
     controller = args.shift
     action = args.shift.to_sym
     
-    url = "/#{controller.ann.self.mount_point}/#{action}"
+    url = "#{controller.mount_path}/#{action}"
     
     unless args.empty?
-      if controller.respond_to? action
+      if controller.respond_to_action_or_template? action
         param_count = controller.instance_method(action).arity
         if param_count != 0
           param_count.times do
@@ -262,7 +281,7 @@ class Controller
   def self.mounted(path)
     # Resolve aspects.
     
-    Glue::Aspects.include_advice_modules(self)
+    ::Aspects.include_advice_modules(self)
       
     # The scaffolding code is compiled after the mount, so 
     # that template roots are finalized.

data/lib/nitro/dispatcher.rb

@@ -74,6 +74,7 @@ class Dispatcher
 
       # Customize the class for mounting at the given path.
       #--
+      # gmosx, TODO: path should include trailing '/'
       # gmosx, TODO: should actually create an instance, thus
       # allowing mounting the same controller to multiple
       # paths, plus simplifying the code. This instance will
@@ -81,7 +82,6 @@ class Dispatcher
       #++
       
       klass.mount_at(path)
-      
       klass.mounted(path) if klass.respond_to?(:mounted)
     end
 
@@ -112,16 +112,23 @@ class Dispatcher
 
   # Update the routes. Typically called after a new
   # Controller is mounted.
+  #
+  # === Example of routing through annotations
+  #
+  # def view_user
+  #   "params:  #{request[:id]} and #{request[:mode]}"
+  # end
+  # ann :view_user, :route => [ /user_(\d*)_(*?)\.html/, :id, :mode ] 
 
   def update_routes
-    @routes = []
+    init_routes()
     
     @controllers.each do |base, c|
       base = '' if base == '/'
       for m in c.action_methods
         m = m.to_sym
         if route = c.ann(m).route and (!route.nil?)
-          add_route(route.first, c, m, route.last)
+          add_route(route.first, :controller => c, :action => m, :params => route.last)
         end
       end
     end
@@ -156,8 +163,9 @@ class Dispatcher
     
     klass, action, params = decode_route(path)
     if klass
-      context.params.update(params)
-      return klass, "#{action}_action", controller.ann.self.mount_point
+      context.params.update(params) if params
+      # gmosx, FIXME/OPTIMIZE: no annotation for mount point!! 
+      return klass, "#{action}_action", klass.mount_path
     end
     
     parts = path.split('/')

data/lib/nitro/global.rb

@@ -0,0 +1,63 @@
+require 'glue/cache/memory'
+
+# Global scoped variables. This is backed by a Cache store.
+
+class Global
+
+  # The address of the store.
+  
+  setting :cache_address, :default => '127.0.0.1', :doc => 'The address of the store'
+
+  # The port of the store.
+  
+  setting :cache_port, :default => 9079, :doc => 'The port of the store'
+
+  # The cache store that backs global variables.
+  
+  setting :cache, :default => ::Glue::MemoryCache.new, :doc => 'The cache store that backs global variables'
+  
+  class << self
+  
+    # Initialize a global value once.
+    
+    def init(key, value)
+      unless Global[key]
+        Global[key] = value
+      end
+    end
+    
+    def set(key, value)
+      Global.cache[key] = value
+    end
+    alias_method :[]=, :set
+    
+    def get(key)
+      return Global.cache[key]
+    end
+    alias_method :[], :get
+
+    # If block is given it acts as an update methods,
+    # that transparently handles distributed stores.
+    #
+    # Global.update(:USERS) do |users|
+    #   users << 'gmosx'
+    # end
+         
+    def update(key)
+      if block_given?
+        # update, also handles distributed stores.
+        val = Global.cache[key]
+        yield val
+        Global.cache[key] = val
+      end    
+    end
+    
+    def delete(key)
+      Global.cache.delete(key)
+    end
+
+  end
+  
+end
+
+# * George Moschovitis <gm@navel.gr>