kiss 1.1 → 1.7

data/lib/kiss/accessors/controller.rb

@@ -0,0 +1,47 @@
+class Kiss
+  module KissAccessors
+    # Escapes string for use in URLs.
+    def url_escape(string)
+      string.url_escape
+    end
+    alias_method :u, :url_escape
+    alias_method :escape, :url_escape
+    alias_method :url_encode, :url_escape
+    alias_method :escape_url, :url_escape
+    
+    # Encodes string for output to HTML.
+    def html_escape(string)
+      string.html_escape
+    end
+    alias_method :h, :html_escape
+    alias_method :escape_html, :html_escape
+  end
+  
+  module ControllerAccessors
+    def environment
+      controller.environment
+    end
+  
+    def public_dir
+      controller.public_dir
+    end
+  
+    def upload_dir
+      controller.upload_dir
+    end
+    
+    def database
+      controller.database
+    end
+    
+    def models
+      controller.models
+    end
+    alias_method :dbm, :models
+    
+    
+    # request data
+    
+    include KissAccessors
+  end
+end

data/lib/kiss/accessors/request.rb

@@ -0,0 +1,106 @@
+class Kiss
+  module RequestAccessors
+    def models
+      request.models
+    end
+    alias_method :dbm, :models
+    
+    def file_cache(*args, &block)
+      request.file_cache(*args, &block)
+    end
+    
+    def session
+      request.session
+    end
+  
+    def login
+      request.login
+    end
+    
+    def redirect_url(*args)
+      request.redirect_url(*args)
+    end
+    
+    def redirect_action(*args)
+      request.redirect_action(*args)
+    end
+    
+    def app(*args)
+      request.app_url(*args)
+    end
+    
+    def pub(*args)
+      request.pub_url(*args)
+    end
+    
+    def send_file(*args)
+      request.send_file(*args)
+    end
+    
+    def send_response(*args)
+      request.send_response(*args)
+    end
+    
+    def env
+      request.env
+    end
+    
+    def protocol
+      request.protocol
+    end
+    
+    def host
+      request.host
+    end
+    
+    def path_info
+      request.path_info
+    end
+  
+    def query_string_with_params
+      request.query_string_with_params
+    end
+  
+    def request_url_with_params
+      request.request_url_with_params
+    end
+    
+    def set_exception_cache(*args)
+      request.set_exception_cache(*args)
+    end
+    
+    def debug(object)
+      request.debug(object, Kernel.caller[0])
+    end
+    alias_method :trace, :debug
+    
+    def start_benchmark(label = nil)
+      request.start_benchmark(label, Kernel.caller[0])
+    end
+    alias_method :bench, :start_benchmark
+    
+    def stop_benchmark
+      request.stop_benchmark(Kernel.caller[0])
+    end
+    alias_method :bench_stop, :stop_benchmark
+    
+    def response
+      request.response
+    end
+    
+    def cookies
+      request.cookies
+    end
+    
+    def set_cookie(*args)
+      response.set_cookie(*args)
+    end
+  end
+  
+  module DatabaseAccessors
+    def database
+      request.database
+    end
+    alias_method :db, :database
+  end
+end

data/lib/kiss/accessors/template.rb

@@ -0,0 +1,23 @@
+class Kiss
+  module TemplateMethods
+    # Contains data set by action/mailer logic to be displayed in templates.
+    def data
+      @data
+    end
+    alias_method :vars, :data
+    
+    def data=(hash)
+      @data = hash
+    end
+    alias_method :'vars=', :'data='
+    
+    # Merges specified data (key-value pairs) into template data hash
+    # (provided for backward-compatibility with apps pre-1.2).
+    def set(vars)
+      vars.each_pair do |key, value|
+        @data[key] = value
+        self.instance_variable_set(:"@#{key}", value)
+      end
+    end
+  end
+end

data/lib/kiss/action.rb

@@ -1,78 +1,327 @@
 class Kiss
   class Action
+    @@template_class = nil
+    
+    cattr_reader :class_unique, :template_class
+    
     class << self
+      _attr_reader :subdir, :part, :name, :action_path, :parent_class, :object_options, :aliases
+      attr_reader :layout, :breadcrumbs, :authentication_required, :base_url
+      
+      dsl_accessor :breadcrumb, :object_breadcrumb
+      
       def inherited(subclass)
-        subclass.clear_subclasses
+        subclass.init_child_classes
       end
-      def clear_subclasses
-        @subclasses = {}
+      def init_child_classes
+        @_child_classes = {}
+      end
+      
+      def get_subclass_from_path(path, request, params)
+        action_subdir = ''
+        action_path = '/'
+        action_found = false
+        args = []
+        objects = {}
+        breadcrumbs = []
+        object = nil
+        object_part = nil
+        collection = nil
+        
+        request.redirect_action('/') if path == ''
+        
+        action_class = self.get_child_class
+        
+        parts = path.sub(/\A\/*/, '').split(/\/+/)
+        parts.push('') if path[-1, 1] == '/'
+        
+        while part = parts.shift
+          action_path += part
+          part = (object_part ? 'view' : @@controller.default_action) if part.empty?
+          
+          # =column syntax not yet supported
+          # when adding this support, be sure to change Action#redirect_action also
+          
+          if part =~ /\A([\w\-\.\+\%]+)\=([\w\-\.\+\%]+)\Z/
+            params[$1.url_unescape] = $2.url_unescape
+            action_path += '/'
+            next
+          end
+          
+          if part !~ /\A[\w\-\.]*\Z/i
+            raise Kiss::FileNotFoundError::InvalidAction, 'invalid action path'
+          end
+                    
+          if redirect = action_class.aliases[part]
+            action, options = redirect
+            request.redirect_action(
+              absolute_uri( action + '/' + parts.join('/'), action_path ),
+              options
+            )
+          end
+          
+          test_path = @@controller.action_dir + action_subdir + '/' + part
+          if @@controller.directory_exists?(test_path)
+            action_subdir += '/' + part
+            action_class = action_class.get_child_class(part, true)
+            object = object_part = nil
+            
+            collection = action_class.breadcrumb
+            
+            action_path += '/'
+            if action_class.breadcrumbs.empty?
+              if File.file?("#{@@controller.action_dir}#{action_class.name}index.rb") ||
+                  File.file?("#{@@controller.action_dir}#{action_class.name}index.rhtml")
+                breadcrumbs << [action_class.breadcrumb, action_path]
+              end
+            else
+              breadcrumbs.push(*action_class.breadcrumbs)
+            end
+          else
+            # remove .rb extension, if any
+            part.sub!(/(\.rb)+\Z/, '')
+            
+            # does part have an extension?
+            if part =~ /\A(.+)\.(\w+)\Z/
+              extension = $2
+              part = $1
+            else
+              extension = 'rhtml'
+            end
+            
+            test_path = @@controller.action_dir + action_subdir + '/' + part
+            if File.file?("#{test_path}.rb") || File.file?("#{test_path}.#{(extension == 'xls') ? 'txt' : extension}")            
+              action_found = true
+              action_class = action_class.get_child_class(part)
+              break
+            else
+              unless part =~ /\A[\w\.\-]+\Z/
+                raise Kiss::FileNotFoundError, "invalid URI"
+              end
+              
+              object_options = action_class.object_options
+              if object_options && (object_options[:column] != :id || part =~ /\A\d+\Z/)
+                object_part = part
+                object = request.dbm[object_options[:class_name]].find(object_options[:column] => object_part)
+                objects[object_options[:variable_name]] = object
+                
+                action_path += '/'
+                
+                if !object
+                  raise Kiss::FileNotFoundError, "resource '#{test_path.html_escape}' not found"
+                end
+                
+                object_breadcrumb = action_class.object_breadcrumb
+                object_display_name = object[object.class.display_column] ||
+                  (object.send(object.class.display_column) rescue nil)
+                if (object_breadcrumb != false)
+                  breadcrumbs << [
+                    (object_breadcrumb.is_a?(Proc) ? object_breadcrumb.call(object) : object_breadcrumb) ||
+                      object_display_name,
+                    action_path
+                  ]
+                end
+              
+                next
+              else
+                if part == 'view'
+                  request.redirect_action(path + '..')
+                end
+                raise Kiss::FileNotFoundError, "resource '#{test_path.html_escape}' not found"
+              end
+            end
+          end
+        end
+        
+        # if no action found, add a trailing slash and try again
+        request.redirect_action(path + '/') unless action_found
+        
+        # keep rest of path_info in args
+        args.push(*parts)
+        
+        action = action_class.new(request, action_path, extension, collection, object, object_part, object_display_name, breadcrumbs, args, params)
+        objects.each_pair do |key, value|
+          action.instance_variable_set(key, value)
+        end
+        action
       end
       
-      def get_subclass(key, path, controller)
+      def get_root_class(controller, root_dir)
+        parent = self
+        klass = Class.new(self)
+        Kiss.register_class_path(klass, root_dir)
+        klass.class_eval do
+          @@action_dir = root_dir
+          @@controller = controller
+          @@root_class = klass
+          
+          @_parent_class = parent
+          @_subdir = ''
+          
+          @layout = nil
+          @breadcrumbs = []
+          @authentication_required = @@controller.authenticate_all ? true : false
+          
+          @_aliases = {}
+        end
+        klass
+      end
+      
+      def get_child_class(part = nil, is_directory = !part)
         # each subdir must get a subclass of the parent dir class;
-        # each subclass has its own @subclasses hash of its subdirs
+        # each subclass has its own @_child_classes hash of its subdirs
+        
+        subdir = self.name.to_s.sub(/\/\Z/, '')
+        name = self.name.to_s + part.to_s + (is_directory ? '/' : '')
+        path = name + (is_directory ? '_action' : '') + '.rb'
+        parent = self
+        
+        layout = @layout
         
-        src, updated = controller.file_cache(path, true)
+        auth_path = name
+        auth_req = @authentication_required && !@@controller.authenticate_exclude.include?(auth_path)
         
-        if updated
+        src, updated = @@controller.file_cache(@@action_dir + path, true)
+        
+        if updated || !@_child_classes.has_key?(part)
           klass = Class.new(self)
-          klass.class_eval(src,path) if src
-          @subclasses[key] = klass
+          Kiss.register_class_path(klass, @@action_dir + path)
+          klass.class_eval do
+            @_subdir = subdir
+            @_part = part
+            @_name = name
+            @_action_path = path
+            @_parent_class = parent
+            @_breadcrumb = part ? part.titleize : nil
+            
+            @layout = layout
+            @breadcrumbs = []
+            @authentication_required = auth_req
+            
+            @_aliases = {}
+            
+            selects_object if part && is_directory 
+          end
+          
+          if src
+            klass.class_eval(src, @@action_dir + path)
+          end
+          @_child_classes[part] = klass
         end
         
-        @subclasses[key]
+        @_child_classes[part]
+      end
+      
+      def selects_object(options = {})
+        if options.has_key?(:variable_name)
+          variable_name = options[:variable_name]
+          raise 'variable name must be a symbol' unless variable_name.is_a?(Symbol)
+          raise 'variable name must start with @' unless variable_name.to_s[0, 1] == '@'
+        end
+        
+        (@_object_options ||= {
+          :class_name => @_part.pluralize.to_sym,
+          :variable_name => ('@'+@_part.singularize).to_sym,
+          :column => :id
+        }).merge!(options)
+      end
+      alias_method :select_object, :selects_object
+      alias_method :accepts_object, :selects_object
+      alias_method :accept_object, :selects_object
+      
+      def alias_action(part, action, options = {})
+        @_aliases[part.to_s] = [action.to_s, options]
+      end
+      
+      def absolute_uri(path, action_path)
+        # need to add something to action_path before File.dirname, in case
+        # action_path ends in /
+        path =~ /\A\// ? path : action_path.gsub(/[^\/]*\Z/, '') + path
       end
     end
-    self.clear_subclasses
-    
+    self.init_child_classes
     
+    include Kiss::ControllerAccessors
+    include Kiss::RequestAccessors
+    include Kiss::DatabaseAccessors
     include Kiss::TemplateMethods
     
-    attr_reader :controller, :forms, :action, :action_uri, :action_subdir, :template, :extension,
-      :args, :params, :output, :output_options
+    attr_accessor :layout, :title
+    
+    _attr_reader :request, :controller, :forms, :action, :action_path, :template,
+      :extension, :args, :params, :output, :output_options
     
     def arg(index)
-      @args[index]
+      @_args[index]
     end
     
     def args
-      @args
+      @_args
     end
   
     # Raises custom error message for missing methods, specifying current action
     # more clearly than standard error message.
-    def method_missing(meth)
-      raise NoMethodError, "undefined method `#{meth}'"
+    def method_missing(method, *args, &block)
+      if method.to_s =~ /\A_class_(\d+)_(.*)/
+        __send__ $2.to_sym, $1.to_i, *args, &block
+      else
+        raise NoMethodError, "undefined method `#{method}'"
+      end
     end
     
     # Creates a new action instance from controller data.
-    def initialize(controller,action,action_uri,action_subdir,extension,args,params = nil)
-      @controller = controller
-      @action = @template = action
-      @action_uri = action_uri
-      @action_subdir = action_subdir
-      @extension = extension
-      @args = args
-      @params = params || {}
+    def initialize(request, action_path, extension, collection, object, object_part, object_display_name, breadcrumbs, args, params = {})
+      @_request = request
+      @_controller = request.controller
+      @_action_path = action_path
+      @_extension = extension
+      @_object = object
+      @_object_part = object_part
+      @_args = args
+      @_params = params
+      
+      @_template = self.class.name
+      
+      @_arg_index = -1
+      @_forms = {}
       
       @data = {}
-      @forms = {}
-      @template_dir = @controller.template_dir
+      
+      @breadcrumbs = breadcrumbs
+      @title =
+        is_index? ? (@breadcrumbs.pop.first unless @breadcrumbs.empty?) :
+        is_view? ? (@breadcrumbs.pop; object_display_name) :
+        is_edit? ? "#{@_object ? 'Edit' : 'Add'} #{collection.first.singularize}" : 
+        is_delete? ? "Delete #{collection.first.singularize}" : self.class.part.titlecase
+      
+      @base_url = app + action_path
+      
+      after_initialize
+    end
+    
+    def breadcrumbs_html
+      @breadcrumbs.map do |crumb|
+        %Q(<a href="#{app + crumb[1]}">#{crumb[0]}</a> &gt;)
+      end.join(' ')
+    end
+    
+    def context_class
+      Kiss.context_class
     end
   
     # Returns true is `form' param matches current action path.
     def form_action_match
-      form = params['form']
-      return false unless form =~ /^\/?\w+(\/\w+)*$/s
-      return form == @action || @action =~ /\/#{form}/
+      return params['form'] == action_path
     end
     
     # Raises error if database model object does not match the key=value data in
     # desired_values hash.
-    def check_desired_values(object,desired_values)
-      desired_values.each_pair do |key,value|
-        unless object[key] == value
-          raise "#{object.table.to_s.singularize} id=#{object.id} does not have #{key} == #{value.inspect}"
+    def check_desired_values(object, desired_values = nil)
+      if desired_values
+        desired_values.each_pair do |key, value|
+          unless object[key] == value
+            raise "#{object.class.table.to_s.singularize} id=#{object.id} does not have #{key} == #{value.inspect}"
+          end
         end
       end
       object
@@ -80,90 +329,160 @@ class Kiss
     
     # Verifies valid id value, selects database model object from specified table
     # with specified id, and checks result to match desired_values. 
-    def get_object_by_id(table, id, desired_values = {})
+    def get_object_by_id(table, id, desired_values = nil)
       id = id.to_i
-      raise 'bad object id' unless id > 0
-      result = dbm[table][id] || (raise "#{table.to_s.singularize} id=#{id} not found")
-      check_desired_values(result,desired_values)
+      result = (id > 0) ? dbm[table][id] : nil
+      raise "'#{table}' object not found" unless result
+      
+      check_desired_values(result, desired_values) 
     end
     
-    # Returns database model object from specified table, with id matching argument 
-    # of specified index (defaults to first argument).  Raises error if object not
-    # found in database or object data does not match desired_values.
-    def arg_object(table, index = 0, desired_values = {})
-      get_object_by_id(table, arg(index).to_i, desired_values)
+    def get_object_by_value(table, value, column, *args)
+      desired_values = args.first
+      if column
+        result = dbm[table].where(column => value).first
+        raise "'#{table}' object not found" unless result
+        
+        check_desired_values(result, desired_values) 
+      else
+        get_object_by_id(table, value, desired_values)
+      end
+    end
+    
+    # Returns database model object from specified table, with column matching 
+    # argument of specified index (defaults to first argument).  Raises error if 
+    # object not found in database or object data does not match desired_values.
+    def arg_object(table, *args)
+      index = args.first.is_a?(Numeric) ? args.shift : 0
+      value = arg(index)
+      
+      column = args.first.is_a?(Symbol) ? args.shift : nil
+      
+      get_object_by_value(table, value, column, *args) || begin
+        raise Kiss::FileNotFoundError::Object, "could not find #{table.to_s.singularize} with #{column || 'id'}=#{value} (arg #{index})"
+      end
     end
     
     # Returns arg_object, or new object of specified table if arg_object fails.
-    def arg_object_or_new(table,index = 0,desired_values = {})
-      arg_object(table,index,desired_values) rescue dbm[table].new(desired_values)
+    def arg_object_or_new(table, *args)
+      begin
+        arg_object(table, *args)
+      rescue
+        # remove non-hash arguments, looking for desired_values
+        desired_values = args.last.is_a?(Hash) ? args.last : {}
+        dbm[table].new(desired_values)
+      end
+    end
+    
+    def next_arg_index
+      @_arg_index += 1
+    end
+    
+    def next_arg_object(table, *args)
+      arg_object(table, next_arg_index, *args)
     end
     
-    # Returns database model object from specified table, with id matching param 
+    def next_arg_object_or_new(table, *args)
+      arg_object_or_new(table, next_arg_index, *args)
+    end
+    
+    # Returns database model object from specified table, with column matching param 
     # of specified key (defaults to singular form of table name).  Raises error if 
     # object not found in database or object data does not match desired_values.
-    def param_object(table, key = nil, desired_values = {})
+    def param_object(table, key = nil, column = nil, *args)
       key ||= table.to_s.singularize
-      get_object_by_id(table, params[key.to_s], desired_values)
+      get_object_by_value(table, params[key.to_s], column, *args)
     end
     
     # Returns param_object, or new object of specified table if param_object fails.
-    def param_object_or_new(table,key = nil,desired_values = {})
-      param_object(table,key,desired_values) rescue dbm[table].new(desired_values)
+    def param_object_or_new(table, *args)
+      param_object(table, *args) rescue begin
+        desired_values = args.last.is_a?(Hash) ? args.last : {}
+        dbm[table].new(desired_values)
+      end
     end
   
     # Validates param of specified key against specified format.
-    def validate_param(key, format, required = false)
-      Kiss.validate_value(@params[key], format, required, "param '#{key}'")
+    def validate_param(key, format, options = {})
+      @_params[key.to_s].validate(format, options.merge(:label => "param '#{key}'"))
     end
   
     # Validates argument of specified index against specified format.
-    def validate_arg(index, format, required = false)
-      Kiss.validate_value(@args[index], format, required, "arg #{index}")
+    def validate_arg(format, index = 0, options = {})
+      @_args[index].validate(format, options.merge(:label => "arg #{index}"))
     end
     
-    # Creates and invokes new Kiss::Mailer instance to send email message via sendmail.
-    def sendmail(options = {})
-      send_email({
-        :engine => :sendmail
+    # Creates and invokes new Kiss::Mailer instance to send email message via SMTP.
+    def new_email(options = {})
+      request.new_email({
+        :data => data
       }.merge(options))
     end
-  
-    # Creates and invokes new Kiss::Mailer instance to send email message via SMTP.
+    
     def send_email(options = {})
-      Kiss::Mailer.new({
-        :data => data,
-        :controller => controller
-      }.merge(options)).send
+      new_email(options).send
     end
-  
-    # Sends HTTP 302 response to redirect client agent to specified URL.
-    def redirect_url(*args)
-      controller.redirect_url(*args)
-    end
-  
+    
     # Redirects to specified action path, which may also include arguments.
     def redirect_action(action, options = {})
-      redirect_url( app(options) + app_absolute_path(action) + (options[:params] ?
-        '?' + options[:params].keys.map do |k|
-          "#{Kiss.url_escape k.to_s}=#{Kiss.url_escape options[:params][k].to_s}"
-        end.join('&') : '')
-      )
+      # need to rewrite this if current action class looks up objects
+      # by some other column than id
+      if options.has_key?(:object)
+        dest_object = options[:object]
+        column = self.class.parent_class.object_options[:column]
+        action = "#{@_object_part && '../'}#{"#{dest_object[column]}/" if dest_object}#{action}"
+      end
+      request.redirect_action( absolute_uri(action), options )
     end
     
-    def invoke(path,options = {})
-      action_handler = controller.invoke_action(path,options[:params] || {},{:layout => nil})
-      action_handler.output
+    # Redirects to index of the same action group.
+    def redirect_index(options = {})
+      redirect_action('', options.merge(:object => nil))
     end
-    alias_method :process_action, :invoke
-  
-    # Convert specified action path by prefixing current action_subdir,
+    
+    # Redirects to the view action on the object.
+    def redirect_object(object = nil, options = {})
+      if object.is_a?(Hash)
+        options = object
+        object = nil
+      end
+      object ||= options[:object] || @_object
+      if object && !object.new?
+        redirect_action('', {:object => object}.merge(options))
+      else
+        redirect_index(options)
+      end
+    end
+    alias_method :redirect_view, :redirect_object
+    
+    # Redirects to index of the same action group.
+    def redirect_pop(options = {})
+      if @breadcrumbs.empty?
+        redirect_index(options)
+      else
+        redirect_action(@breadcrumbs.last.last, options)
+      end
+    end
+    alias_method :redirect_breadcrumb, :redirect_pop
+    
+    def render_action(path, options = {})
+      action = request.render_action(
+        absolute_uri(path),
+        options[:params] || {}, {:layout => nil}
+      )
+      action.output
+    end
+    
+    # Convert specified action path by prefixing current action subdir,
     # unless specified path starts with slash (/).
     def app_absolute_path(path)
-      path = @action_subdir + path if path !~ /\A\//
-      path
+      path !~ /\A\// ? self.class.subdir + '/' + path : path
     end
-  
+    
+    def absolute_uri(relative_uri)
+      self.class.absolute_uri(relative_uri, action_path)
+    end
+    
     # Return string result from rendering specified string or template options.
     def render_to_string(options)
       if options.is_a?(String)
@@ -172,35 +491,57 @@ class Kiss
         return options[:text].to_s
       end
       
-      @base_url ||= app + action_uri
+      if options.is_a?(Hash)
+        @title = options[:title] if options.has_key?(:title)
+        @layout = options[:layout] if options.has_key?(:layout)
+        @breadcrumbs = options[:breadcrumbs] if options.has_key?(:breadcrumbs)
+      end
+      
+      @@template_class ||= Kiss::Template.get_root_class(controller, controller.template_dir)
+      
+      content = options[:content].is_a?(String) ? begin
+        template_class = @@template_class.get_subclass_from_path(self.class.subdir, 'rhtml')
+        options[:content]
+      end : begin
+        path = @@template_class.get_template_path(
+          {
+            :template => template,
+            :subdir => self.class.subdir,
+            :extension => (extension == 'xls') ? 'txt' : extension
+          }.merge(options)
+        )
+        template_class = @@template_class.get_subclass_from_path(path)
+        template_class.new(request, self).call
+      end
       
       unless defined?(@layout)
-        @layout = options.is_a?(Hash) && options.has_key?(:layout) ? options[:layout] : 
-          (extension == 'rhtml' ? Kiss.layout : nil)
+        @layout = extension == 'rhtml' ? self.class.layout || (template_class && template_class.layout) || '/_layout.rhtml' : nil
       end
-      content = options[:content].is_a?(String) ? options[:content] : process({
-        :template => template,
-        :extension => extension
-      }.merge(options))
       
+      i = 0
       while @layout
-        layout_path = get_template_path(
+        ext = options[:extension] || extension
+        layout_path = @@template_class.get_template_path(
           :template => @layout,
-          :extension => options[:extension] || extension
+          :subdir => self.class.subdir,
+          :extension => (ext == 'xls') ? 'txt' : ext
         ) rescue break
-      
-        # clear layout
-        # (however, layout template is allowed to set @layout to something else)
-        @layout = nil
+        
+        # cache layout for comparison after render
+        prev_layout = @layout
         
         # process layout file
-        content = erubis(layout_path,binding,content)
+        layout_class = @@template_class.get_subclass_from_path(layout_path)
+        content = layout_class.new(request, self).call(content)
+        
+        if @layout == prev_layout
+          @layout = layout_class.parent_class.parent_class.layout
+        end
       end
-      # add a base tag in case of arguments appended to request URI
       
-      base_url = options.has_key?(:base_url) ? options[:base_url] : @base_url
-      if (base_url)
-        content = Kiss.html_prepend(%Q(<base href="#{base_url}" />),content,'head')
+      # add a base tag in case of arguments appended to request URI
+      if extension == 'rhtml' && (base_url = options.has_key?(:base_url) ? options[:base_url] : @base_url)
+        content = content.prepend_html(%Q(<base href="#{base_url}" />), 'head')
       end
       
       content
@@ -208,60 +549,89 @@ class Kiss
   
     # Render and return response to Rack.
     def render(options = {})
-      @output = render_to_string(options)
-      @output_options = options
+      Dir.chdir(controller.project_dir)
+      
+      @_output = render_to_string(options)
+      @_output_options = options
       throw :kiss_action_done
     end
-  
-    # Placeholder for generic actions that do nothing but render template.
-    # render is called from Kiss#call after this method returns.
-    def call; end
     
     # Does nothing by default; override this method in your _action.rb or
     # other action files to specify authentication behavior.
     def authenticate; end
     
-    # Does nothing by default; override this method in your _action.rb or
-    # other action files to expand objects from persistent login data.
-    def expand_login; end
+    # Callback method: called after action handler initialized.  Does nothing 
+    # by default; override this method in your _action.rb or other action files.
+    def after_initialize; end
+    
+    # Callback method: called before action call.  Does nothing by default;
+    # override this method in your _action.rb or other action files.
+    def before_call; end
+  
+    # Placeholder for generic actions that do nothing but render template.
+    # render is called from Kiss#call after this method returns.
+    def call; end
+    
+    # Callback method: called after action call.  Does nothing by default;
+    # override this method in your _action.rb or other action files.
+    def after_call; end
     
     # Ensure that action requested via SSL; redirects to same action with
     # https protocol if protocol is not https.
     def force_ssl(options = {})
       unless protocol == 'https'
-        redirect_action(@action, options.merge( :protocol => 'https' ))
+        redirect_action(request.path_with_query_string, options.merge( :protocol => 'https' ))
       end
     end
     alias_method :force_https, :force_ssl
+    
+    def is_index?
+      self.class.name == self.class.subdir + '/index'
+    end
+    
+    def is_view?
+      self.class.name == self.class.subdir + '/view'
+    end
+    
+    def is_edit?
+      self.class.name == self.class.subdir + '/edit'
+    end
+    
+    def is_delete?
+      self.class.name == self.class.subdir + '/delete'
+    end
   
     # Creates and adds form to current action, using specified attributes.
-    def add_form(attrs = {})
-      # make sure form not already defined for this request
-      @forms ||= {}
-      attrs[:name] ||= @action
-      form_name = attrs[:name]
-      raise "page contains multiple forms named '#{form_name}'" if @forms.has_key?(form_name)
-      
+    def add_form(attrs = {}, &block)
       # create form
-      uri = app + request.path_info
-      @forms[form_name] = @form = Kiss::Form.new({
-        :action => uri,
-        :request => self
-      }.merge(attrs))
+      temp_form = Kiss::Form.new({
+        :name => attrs[:action] || action_path,
+        :action => app + request.path_with_query_string,
+        :delegate => self
+      }.merge(attrs), &block)
+      
+      # make sure form not already defined for this request
+      @_forms ||= {}
+      raise "page contains multiple forms named '#{temp_form.name}'" if @_forms.has_key?(temp_form.name)
+      @_forms[temp_form.name] = @_form = temp_form
       
-      # add data from controller to form
-      if params['form'] == @form.name
-        @form.submitted = true
-        @form.params = params
+      # add data from request to form
+      if params['form'] == @_form.name
+        @_form.submitted = true
+        @_form.params = params
       end
       
-      @form
+      @_form
     end
-  
+    
     # Returns most recently added form.
     # Shorthand for forms[0] when there is only one form.
     def form
-      @form
+      @_form
+    end
+    
+    def invoke_action(path, params = {})
+      request.invoke_action(path, params).output
     end
   end
 end