nitro 0.28.0 → 0.29.0

data/lib/nitro/controller.rb

@@ -1,4 +1,5 @@
 require 'facet/annotation'
+require 'facet/inheritor'
 
 require 'glue/aspects'
 require 'glue/markup'
@@ -9,12 +10,31 @@ require 'nitro/scaffolding'
 require 'nitro/caching'
 require 'nitro/flash'
 require 'nitro/helper'
+require 'nitro/compiler'
 
 module Nitro
 
 # Include this Mixin to a class to make objects of this class
 # publishable, ie accessible through a standard web (REST) 
 # interface.
+#
+# === Instance variables
+#
+# ==== mount_path
+#
+# Where the publishable is mounted.
+#
+# ==== template_root
+#
+# Where to look for templates for this publishable
+# object / controller. The template root is actually a stack
+# to implement some form of template root inheritance, 
+# thus allowing for more reusable controllers. Ie you can
+# 'extend' a controller, and only override the templates
+# you want to change. The compiler will traverse the 
+# template root stack and use the templates from parent
+# controllers if they are not overriden.
+
 
 module Publishable
   def self.included(base)
@@ -25,22 +45,6 @@ module Publishable
       include Glue::Aspects
       include Flashing
       include Helpers
-    
-      # Override this method as needed. Unless overriden
-      # this method is initialized by the Dispatcher to 
-      # point to Template.root/path for each Controller.
-      
-      def self.template_root
-        nil
-      end
-      
-      private
-      
-      # Helper method.
-      
-      def template_root
-        self.class.template_root
-      end
     end
 
     # Aliases an action
@@ -118,25 +122,128 @@ module Publishable
         end
       end
     end
+        
+    base.module_eval do
+      class << self
+        # Override this method to customize the template_root.
+        # Typically used in controllers defined in reusable Parts.
+        # Call super to include the parent class's customizations.
+        #
+        # def setup_template_root(path)
+        #   super
+        #   @template_root << "custom/route/#{path}"
+        #   @template_root << "another/route/#{path}"
+        # end  
+        
+        def setup_template_root(path)
+        end
+        
+        def mount_at(path)
+          # Store the mount_path (where the controller is mounted).
+          
+          @mount_path = path
+          
+          # Update template_root. Unshift the PROTO_TEMPLATE_ROOT, 
+          # and unshift a template_root relative to the 
+          # application template root.
+        
+          @template_root = []
+          @template_root << File.join(Compiler::PROTO_TEMPLATE_ROOT, path).gsub(/\/$/, '')
+          setup_template_root(path)
+          @template_root << File.join(Glue::Template.root, path).gsub(/\/$/, '')
+          @template_root.reverse!
+        end
+        alias_method :mount, :mount_at
+      end
+    end
+    
+  end
 
-    # Cookie helpers.
-    #--
-    # TODO: move elsewhere.
-    #++
+private
+
+  # Cookie helpers.
+  #--
+  # TODO: move elsewhere.
+  #++
   
-    base.module_eval do
-      private
-      
-      def cookies
-        @context.cookies
-      end  
+  def cookies
+    @context.cookies
+  end  
+
+  def send_cookie(name, value = nil)
+    @context.add_cookie(name, value)
+  end
+
+  # Encode controller, action, params into a valid url.
+  # Automatically respects nice urls and routing.
+  #
+  # Handles parameters either as a hash or as an array.
+  # Use the array method to pass parameters to 'nice' actions.
+  #
+  # Pass Controller, action, and (param_name, param_value) 
+  # pairs.
+  #
+  # === Examples
+  #
+  # encode_url ForaController, :post, :title, 'Hello', :body, 'World'
+  # encode_url :post, :title, 'Hello', :body, 'World' # => implies controller == self
+  # encode_url :kick, :oid, 4
+  #--
+  # FIXME: better implementation? optimize this?
+  # TODO: move elsewhere.
+  #++
+  
+  def encode_url(*args)
+    if args.first.is_a?(Symbol) or args.first.is_a?(String)
+      # no controller passed, imply controller == self!
+      args.unshift(self.class)
+    end
+
+    # Try to encode using the router.
+    
+    if url = context.dispatcher.encode_route(*args)
+      return url
+    end
+    
+    # No routing rule, manual encoding.
+    
+    controller = args.shift
+    action = args.shift.to_sym
+    
+    url = "/#{controller.ann.self.mount_point}/#{action}"
+    
+    unless args.empty?
+      if controller.respond_to? action
+        param_count = controller.instance_method(action).arity
+        if param_count != 0
+          param_count.times do
+            args.shift # name 
+            url << "/#{CGI.escape(args.shift.to_s)}"
+          end        
+        end
+      end
       
-      def send_cookie(name, value = nil)
-        @context.add_cookie(name, value)
+      unless args.empty?
+        url << '?'
+        params = []
+        (args.size / 2).times do
+          params << "#{args.shift}=#{args.shift}" 
+        end
+        url << params.join(';')
       end
     end
+    
+    return url  
   end
+  alias_method :R, :encode_url
+    
+  # Just like encode_url, but generates an absolute url instead.
   
+  def encode_absolute_url(*args)
+    return "#{request.host_url}#{encode_url(*args)}"
+  end
+  alias_method :RA, :encode_absolute_url
+    
 end
 
 # The Controller part in the MVC paradigm. The controller's 
@@ -148,17 +255,19 @@ class Controller
   include Scaffolding
   include Caching
   include Helpers
-  helper Markup
+  helper Glue::Markup
 
   # This callback is called after the Controller is mounted.
   
   def self.mounted(path)
     # Resolve aspects.
-    Aspects.include_advice_modules(self)
+    
+    Glue::Aspects.include_advice_modules(self)
       
     # The scaffolding code is compiled after the mount, so 
     # that template roots are finalized.
-    compile_scaffolding_code
+    
+    compile_scaffolding_code()
   end
   
 end

data/lib/nitro/dispatcher.rb

@@ -1,6 +1,6 @@
 require 'nitro/controller'
 require 'nitro/compiler'
-require 'nitro/routing'
+require 'nitro/router'
 require 'nitro/helper/default'
 
 module Nitro
@@ -63,28 +63,26 @@ class Dispatcher
   # disp.publish '/' => MainController
   
   def add_controller(controllers)
-    for path, c in controllers
-      unless (c.ancestors.include?(Controller) or c.ancestors.include?(Publishable))
-        c.send :include, Publishable
+    for path, klass in controllers
+      unless (klass.ancestors.include?(Controller) or klass.ancestors.include?(Publishable))
+        klass.send :include, Publishable
       end
 
-      auto_mixin(c)      
+      # Automatically mixin controller helpers.
       
-      # Try to setup a template_root if none is defined:
-      
-      unless c.template_root
-        c.module_eval %{
-          def self.template_root
-            "#{Template.root}#{path}".gsub(/\\/$/, '')
-          end
-        }
-      end
+      mixin_auto_helpers(klass)      
 
-      # Keep the mount point as an annotation.
+      # Customize the class for mounting at the given path.
+      #--
+      # gmosx, TODO: should actually create an instance, thus
+      # allowing mounting the same controller to multiple
+      # paths, plus simplifying the code. This instance will
+      # be dup-ed for each request.
+      #++
       
-      c.ann.self.mount_point = path.gsub(/^\//, '')
+      klass.mount_at(path)
       
-      c.mounted(path) if c.respond_to?(:mounted)
+      klass.mounted(path) if klass.respond_to?(:mounted)
     end
 
     (@controllers ||= {}).update(controllers)
@@ -100,12 +98,12 @@ class Dispatcher
   # default helper 'Helper' and the auto helper
   # 'XxxControllerHelper' (if it exists) are included.
   
-  def auto_mixin(c)
-      c.helper(Nitro::DefaultHelper)      
+  def mixin_auto_helpers(klass)
+      klass.helper(Nitro::DefaultHelper)      
       
       begin
-        if helper = Module.by_name("#{c}Helper")
-          c.helper(helper)
+        if helper = Module.by_name("#{klass}Helper")
+          klass.helper(helper)
         end
       rescue NameError
         # The auto helper is not defined.
@@ -123,12 +121,7 @@ class Dispatcher
       for m in c.action_methods
         m = m.to_sym
         if route = c.ann(m).route and (!route.nil?)
-          unless c.ann(m).params.nil?
-            keys = c.ann(m).params.keys
-          else
-            keys = []
-          end
-          @routes << [route, "#{base}/#{m}", *keys]
+          add_route(route.first, c, m, route.last)
         end
       end
     end
@@ -159,7 +152,13 @@ class Dispatcher
   #++
   
   def dispatch(path, context = nil)
-    path = route(path, context)
+    # Try if the router can directly decode the path.
+    
+    klass, action, params = decode_route(path)
+    if klass
+      context.params.update(params)
+      return klass, "#{action}_action", controller.ann.self.mount_point
+    end
     
     parts = path.split('/')
     parts.shift # get rid of the leading '/'.

data/lib/nitro/element.rb

@@ -1,10 +1,9 @@
 require 'facet/string/capitalized'
 require 'facet/string/camelize'
-require 'facet/string/underscore'
+require 'facet/class/method_name'
 require 'facet/dir/self/recurse'
 require 'facet/annotation'
 
-require 'glue/flexob'
 require 'glue/configuration'
 require 'glue/template'
 
@@ -57,29 +56,44 @@ module ElementMixin
   
   attr_accessor :_view
 
+  # The id of this element.
+  
+  attr_accessor :id
+
   def initialize(*args)
     @_children = {}
     @_text = ''
+    @id = self.class.demodulize.underscore
   end
     
+  # Prepend this code to the element content.
+  
   def open
   end
   
   # If an optional name parameter is passed renders
   # the content of the named child element.
+  #
+  # eg. #{content :child_element_id}
   
   def content(cname = nil)
     if cname
-      @_children[cname].content
+      if c = @_children[cname.to_s]
+        c.content
+      else
+        Logger.error "Undefined sub-element '#{cname}' for element '#{self.class}'"
+      end
     else
       @_text
     end
   end
   
+  # Append this code to the element content.
+  
   def close
   end  
 
-  # Renders the actual content of this Element.
+  # Override this.
   
   def render
     "#{open}#{content}#{close}"
@@ -95,14 +109,42 @@ module ElementMixin
   end  
 
   def add_child(child)
-    child._parent = self  
-    @_children[Element.class_to_name(child.class)] = child
+    child._parent = self
+    @_children[child.id] = child
   end
   
   alias_method :children, :_children  
 end
 
 # A programmatically generated element.
+#
+# === Usage
+#
+# = in the code
+# 
+# class Page < Nitro::Element
+#   def render
+#     %{
+#     <div id="@id">#{content}</div>
+#     }
+#   end
+# end
+# 
+# = in your template
+#
+# <Page>hello</Page>
+# 
+# => <div id="page">hello</div>
+#
+# the id is automatically fille with the class name using class.method_name
+# eg. MyModule::MyPage => my_module__my_page
+#
+# you can override the id to use the element multiple times on the page
+#
+# == Sub Elements
+#
+# Elements can be imbricated. To render the the child element in the parent's template,
+# use #{content :element_id}
 # 
 # === Design
 #
@@ -125,10 +167,10 @@ class Element
   setting :auto_extend, :default => true, :doc => 'Allow auto extension of element classes?'
 
   # The directory where element templates reside. The default
-  # dir is #{Template.root}/element
+  # dir is #{Glue::Template.root}/element
 
-  if File.exist?(File.join(Template.root, 'element'))
-    default_root = File.join(Template.root, 'element')
+  if File.exist?(File.join(Glue::Template.root, 'element'))
+    default_root = File.join(Glue::Template.root, 'element')
   else
     default_root = 'element'
   end
@@ -144,11 +186,6 @@ class Element
   setting :template_root, :default => default_root, :doc => 'The directory where element templates reside'
 
   class << self
-    #  Return the name for an Element class.
-  
-    def class_to_name(klass)
-      klass.to_s.underscore.to_sym
-    end
 
     # Compile the element templates into element classes. 
     # Typically called at startup.
@@ -156,7 +193,7 @@ class Element
     def compile_template_elements
       if File.exist? Element.template_root
         Dir.recurse(Element.template_root) do |filename| 
-          if filename =~ /\.#{Template.extension}$/
+          if filename =~ /\.#{Glue::Template.extension}$/
             name = File.basename(filename).split('.').first.camelize
             Nitro::Element.module_eval %{
               class #{name} < Nitro::Element