nitro 0.31.0 → 0.40.0

data/lib/nitro/part.rb

@@ -1,3 +1,5 @@
+require 'facets/core/class/descendents'
+
 module Nitro
 
 # A part is a module of reusable functionality encapsulated as 
@@ -58,18 +60,61 @@ module Nitro
 # 'inherits' its templates. If you want to customize (override)
 # one template, just place a template with the same name in the
 # respective directory in the application template root.
- 
+#
+#--
+# TODO:
+#
+# * add support for autoload
+# * add support for install/uninstall
+#++
+
 class Part
 
-  # Require (include) a part in the current application.
+  # Perform part initialization, just before the server is 
+  # started. Override this in your parts.
+  
+  def initialize
+  end
+  
+  # Perform part finalization.
+  
+  def finalize
+  end
 
-  def self.require name
-    Logger.debug "Requiring part '#{name}'." if $DBG
-    Kernel.require 'part/' + name + '/run.rb'
+  # Perform part initialization when the part is installed,
+  # ie you add this in your application. Here comes one time
+  # initialization  code.
+  
+  def install
   end
+  
+  # Perform part cleanup when you want to remove the part
+  # from your application.
+  
+  def uninstall
+  end
+  alias cleanup uninstall
 
-end
+  class << self
+  
+    # Require (include) a part in the current application.
+
+    def require(name)
+      Logger.debug "Requiring part '#{name}'." if $DBG
+      Kernel.require 'part/' + name + '/run.rb'
+    end
 
+    # Call the initialization code of all parts. Typically
+    # called just before the server starts.
+    
+    def setup
+      for klass in self.descendents
+        p = klass.new
+      end
+    end
+
+  end
+  
 end
 
-# * George Moschovitis <gm@navel.gr>
+end

data/lib/nitro/publishable.rb

@@ -0,0 +1,328 @@
+require 'facets/more/annotation'
+require 'facets/more/inheritor'
+require 'facets/more/aspects'
+
+require 'nitro/markup'
+
+require 'nitro'
+require 'nitro/render'
+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)
+    super
+
+    base.module_eval do
+      include Render
+      include Aspects
+      include Flashing
+      include Helpers
+
+      # The collection of 'models' ie classes that are linked
+      # to this Publishable/Controller.
+      
+      ann :self, :models => []
+
+      # This is a helper that 'links' one or more classes to this
+      # controller. In practice it annotates each class with the 
+      # controller and stores the controller's list of 'models'.
+      
+      def self.model *classes
+        for c in classes
+          c.ann :self, :controller => self
+          self.ann.self.models! << c
+        end
+      end
+    end
+
+    # Aliases an action
+    #--
+    # gmosx, FIXME: better implementation needed.
+    # gmosx, FIXME: copy all annotations.
+    #++
+
+    base.module_eval do
+      def self.alias_action(new, old)
+        alias_method new, old
+        ann new, :template => old        
+      end
+    end
+
+    # Return the 'action' methods for this Controller.
+    # Some dangerous methods from ancestors are removed.
+    # All private methods are ignored.
+
+    base.module_eval do
+      def self.action_methods
+        classes = self.ancestors - [Object, Kernel, Render, Controller, Caching]
+
+        classes.delete(PP::ObjectMixin) if defined?(PP::ObjectMixin)
+        
+        methods =  classes.inject([]) do |action_methods, klass| 
+          action_methods + klass.public_instance_methods(false) 
+        end
+        
+        return methods
+      end
+    end
+        
+    # Use the method_missing hook to compile the actions
+    # for this controller.
+  
+    base.module_eval do
+      def method_missing(action, *args)
+        if Compiler.new(self.class).compile(action)
+          send(action, *args)
+        else
+          super
+        end
+      end
+    end    
+
+    # Does this publishable respond to the given action?
+    
+    base.module_eval do
+      class << self
+        def respond_to_action?(action)
+          action_methods.include?(action.to_s)              
+        end
+        alias action? respond_to_action?
+      end
+    end
+
+    # Does this publishable respond to the given template?
+    
+    base.module_eval do
+      class << self
+        def respond_to_template?(action)
+          Compiler.new(self).template?(action.to_s)
+        end
+        alias template? respond_to_template?
+      end
+    end
+        
+    # Does this class respond to the given action? 
+    # Also looks for templates in the template root.
+    #
+    # Prefer to use the compiler for this.
+    #--
+    # THINK: maybe move template? here
+    #++
+  
+    base.module_eval do
+      class << self
+        def respond_to_action_or_template?(sym)
+          #--
+          # gmosx, FIXME: optimize this!
+          #++
+          return self.respond_to_action?(sym) || self.respond_to_template?(sym) 
+        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(Nitro::Template.root, path).gsub(/\/$/, '')
+          @template_root.reverse!
+        end
+        alias_method :mount, :mount_at
+
+        # Returns the path where this controller is mounted.
+        
+        def mount_path
+          @mount_path
+        end
+        alias mount_point mount_path
+      end
+    end
+    
+  end
+
+private
+
+  # Cookie helpers.
+  #--
+  # TODO: move elsewhere, probably to a default helper.
+  #++
+  
+  def cookies
+    @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.
+  #
+  # 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
+  # encode_url article # => article.to_href
+  # 
+  # Alternatively you can pass options with a hash:
+  #
+  # encode_url :controller => ForaController, :action => :delete, :params => { :title => 'Hello' }
+  # encode_url :action => :delete
+  #--
+  # FIXME: better implementation? optimize this?
+  # TODO: move elsewhere.
+  #++
+  
+  def encode_url(*args)
+    f = args.first
+    
+    # A standard url as string, return as is.
+    
+    if f.is_a? String
+      return f
+    end
+  
+    # If the passed param is an object that responds to :to_href
+    # returns the url to this object.
+    
+    if f.respond_to? :to_href
+      return args.first.to_href
+    end
+    
+    if f.is_a? Symbol
+      # 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
+    
+    if action == :index
+      url = "#{controller.mount_path}"
+    else
+      mount_path = controller.mount_path
+      mount_path = nil if mount_path == '/'    
+      url = "#{mount_path}/#{action}"
+    end
+      
+    unless args.empty?
+      if controller.respond_to_action_or_template? 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
+      
+      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 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 RA encode_absolute_url
+  
+  # Allows instances of Publishable classes to know where they 
+  # are mounted.
+  
+  def mount_path
+    self.class.mount_path
+  end
+  alias mount_point mount_path
+    
+end
+
+end

data/lib/nitro/render.rb

@@ -5,7 +5,7 @@ require 'stringio'
 require 'facet/string/blank'
 
 require 'glue/settings'
-require 'glue/template'
+require 'nitro/template'
 require 'glue/builder/xml'
 
 require 'nitro/helper/xhtml'
@@ -84,10 +84,6 @@ module Render
 
   attr_accessor :action_name
 
-  # The base url for this render.
-  
-  attr_accessor :base
-  
   # The current controller class.
   
   attr_accessor :controller
@@ -97,9 +93,8 @@ module Render
   # [+context+]
   #    A parent render/controller acts as the context.
 
-  def initialize(context, base = nil)
+  def initialize(context)
     @request = @response = @context = context
-    @base = base
     @out = context.out
   end
 
@@ -108,16 +103,16 @@ module Render
   # controller.
   #
   # Both relative and absolute paths are supported. Relative
-  # paths are converted to absolute by prepending the @base
-  # path of the controller.
+  # paths are converted to absolute by prepending the mount path
+  # of the controller.
   
   def render(path)
     # Convert relative paths to absolute paths.
-    path = "#@base/#{path}" unless path =~ /^\//
+    path = "#{self.class.mount_path}/#{path}".squeeze('/') unless path =~ /^\//
       
     Logger.debug "Rendering '#{path}'." if $DBG
   
-    @controller, action, base = @context.dispatcher.dispatch(path, @context)
+    @controller, action = @context.dispatcher.dispatch(path.to_s, @context)
 
     raise 'No controller for action' unless @controller
 
@@ -130,13 +125,13 @@ module Render
     if self.class == @controller 
       self.send(action)
     else
-      @controller.new(@context, base).send(action)
+      @controller.new(@context).send(action)
     end
 
     Controller.replace_current(old_controller)
     @context.level -= 1
     
-  rescue NoActionError => e1
+  rescue ActionError => e1
     log_error(e1, path, false)
     print '(error)'
 
@@ -200,6 +195,11 @@ private
   # The default redirect status is 303.
   
   def redirect(*args)
+    # If this is an ajax  and/or rpc request skip the redirect.
+    # Allows to write more reusable  code.
+
+    return if  request.script?
+  
     if args.last.is_a? Hash
       status = args.last.fetch(:status, 303)
     else
@@ -209,9 +209,8 @@ private
     url = encode_url(*args)
 
     # gmosx, THINK: this may be unnecessary!
-        
+
     unless url =~ /^http/
-      url = "#@base/#{url}" unless url =~ /^\//
       url = "#{@context.host_url}/#{url.gsub(/^\//, '')}"
     end
 
@@ -239,42 +238,6 @@ private
   end
   alias_method :redirect_to_home, :redirect_home
 
-  # :section: Seaside style call/answer methods.
-  
-  # Call redirects to the given url but push the original
-  # url in a callstack, so that the target can return by 
-  # executing answer.
-  #
-  # === Example
-  #
-  # caller:
-  # color, type = call 'utils/select_color'
-  #
-  # target:
-  # answer color, type
-  #--
-  # FIXME: dont use yet, you have to encode the branch to 
-  # make this safe for use.
-  #++
-  
-  def call(url, status = 303)
-    (session[:CALL_STACK] ||= {}) << request.uri
-    redirect(url, status)
-  end
-  
-  # Returns from a call by poping the callstack.
-  #--
-  # FIXME: don't use yet.
-  #++
-    
-  def answer(index = 0, status = 303)
-    if stack = session[:CALL_STACK] and not stack.empty?
-      redirect(stack.pop, status)
-    else
-      raise 'Cannot answer, call stack is empty'
-    end
-  end
-
   # Log a rendering error.
 
   def log_error(error, path, full = true)
@@ -305,20 +268,28 @@ private
   alias_method :print, :render_text
 
   # Render a template into the output buffer.
-  
-  def render_template(filename)
-    filename = "#{filename}.xhtml" unless filename =~ /\.xhtml$/
-    template = File.read("#{template_root}/#{filename}")
-    Glue::Template.process_template(template, '@out', binding)
+=begin  
+  def render_template(*args)
+    url = encode_url(*args)
+    filename = "#{url}.xhtml" unless url =~ /\.xhtml$/
+    template = File.read(File.join(Template.root, filename))
+    Template.process_template(template, '@out', binding)
   end
+=end
 
+  def render_template(path)
+    render(path)
+    exit
+  end
+  alias_method :template, :render_template
+  
   # Access the programmatic renderer (builder).
   
   def build(&block)
     if block.arity == 1
-      yield Glue::XmlBuilder.new(@out)
+      yield XmlBuilder.new(@out)
     else
-      Glue::XmlBuilder.new(@out).instance_eval(&block)
+      XmlBuilder.new(@out).instance_eval(&block)
     end
   end
 
@@ -326,7 +297,7 @@ private
   # output buffer.
   
   def builder
-    Glue::XmlBuilder.new(@out)
+    XmlBuilder.new(@out)
   end
   
   # A Helper class to access rendering mixins. Useful to avoid 
@@ -356,5 +327,3 @@ private
 end
 
 end
-
-# * George Moschovitis <gm@navel.gr>