ramaze 0.0.7 → 0.0.8

data/lib/ramaze/dispatcher.rb

@@ -2,6 +2,7 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 require 'timeout'
+require 'ramaze/tool/mime'
 
 module Ramaze
 
@@ -15,21 +16,30 @@ module Ramaze
   # find any examples of how this is done exactly yet.
 
   module Dispatcher
+    trait :filters => [
+            lambda{|path| handle_file   path },
+            lambda{|path| handle_action path },
+          ]
+
+    trait :handle_error => {
+        Exception => '/error',
+        Ramaze::Error::NoAction => '/error',
+      }
+
     class << self
       include Trinity
 
       # handle a request/response pair as given by the adapter.
       # has to answer with a response.
       #
-      # It is built so it will catch _all_ errors and exceptions
+      # It is built so it will rescue _all_ errors and exceptions
       # thrown during processing of the request and #handle_error if
       # a problem occurs.
 
-      def handle orig_request, orig_response
-        @orig_request, @orig_response = orig_request, orig_response
-        respond(orig_response, orig_request)
+      def handle rack_request, rack_response
+        setup_environment rack_request, rack_response
+        respond
       rescue Object => exception
-        error(exception)
         handle_error(exception)
       end
 
@@ -53,249 +63,111 @@ module Ramaze
       # anyway, the solution might be simple?
 
       def handle_error exception
-        meth_debug :handle_error, exception
+        Informer.error exception
+        Informer.meth_debug :handle_error, exception
         Thread.current[:exception] = exception
 
+        handle_error = trait[:handle_error]
+
         case exception
-        when nil #Error::NoAction, Error::NoController
-          build_response(exception.message, STATUS_CODE[:not_found])
+        when *handle_error.keys
+          error_path = handle_error[exception.class]
+          error_path ||= handle_error.find{|k,v| k === exception}.last
+
+          request.path_info = error_path
+          respond
         else
           if Global.error_page
-            req = Thread.current[:request]
-
-            unless ((req.request_uri.path = '/error') rescue false)
-              req.request.params['REQUEST_PATH'] = '/error'
-            end
-
-            fill_out
+            request.path_info = '/error'
+            respond
           else
             build_response(exception.message, STATUS_CODE[:internal_server_error])
           end
         end
-      end
-
-      # setup the #setup_environment (Trinity) and start #fill_out
-
-      def respond orig_response, orig_request
-        setup_environment orig_response, orig_request
-        fill_out
-      end
-
-      #
-
-      def build_response out = '', code = STATUS_CODE[:internal_server_error], head = {}
-        default_head = {
-          'Content-Type' => 'text/plain',
-        }
-
-        if Global.cookies
-          default_head['Set-Cookie'] = session.export
-        else
-          head.delete('Set-Cookie')
-        end
-
-        head = default_head.merge(head)
 
-        Response.new(out, code, head)
+        respond
+      rescue Object => ex
+        Informer.error ex
+        build_response(ex.message, STATUS_CODE[:internal_server_error])
       end
 
-
       # Obtain the path requested from the request and search for a static
       # file matching the request, #respond_file is called if it finds one,
       # otherwise the path is given on to #respond_action.
       # Answers with a response
 
-      def fill_out
-        path = request.request_path.squeeze('/')
-        info "Request from #{request.remote_addr}: #{path}"
-
-        the_paths = $:.map{|way| (way/'public'/path) }
-        if file = the_paths.find{|way| File.exist?(way) and File.file?(way)}
-          respond_file file
-        else
-          respond_action path
-        end
-        response
-      end
-
-      # takes a file and sets the response.out to the contents of the file
-      # If you are running mongrel as your adapter it will take advantage of
-      # mongrels #send_file
-
-      def respond_file file
-        debug "Responding with static file: #{file}"
+      def respond
+        path = request.path_info.squeeze('/')
+        Informer.info "Request from #{request.remote_addr}: #{path}"
 
-        response.head['Content-Type'] = ''
-        if @orig_response.respond_to?(:send_file)
-          @orig_response.send_file(file)
-        else
-          response.out = File.read(file)
-        end
-      end
-
-      # Takes the path, figures out the controller by asking #resolve_controller
-      # for the controller, action and params for the path.
-      #
-      # Sets the cookies in the response.head if Global.cookies is set
-      #
-      # finally it runs #handle_controller
-
-      def respond_action path
-        debug "Responding with action: #{path}"
+        catch(:respond) do
+          redirection = catch(:redirect) do
+            filtered = [filter(path)].flatten.first
+            throw(:respond, build_response(filtered, response.status))
+          end
 
-        controller, action, params = resolve_controller(path)
-        catch :respond do
-          response.out = handle_controller(controller, action, params)
+          body, status, head = redirection.values_at(:body, :status, :head)
+          Informer.info("Redirect to `#{head['Location']}'")
+          throw(:respond, build_response(body, status, head))
         end
       end
 
-      # find out which controller should be used based on the path.
-      # it will answer [controller, action, params] or raise an
-      #
-      #   Ramaze::Error::NoController # if no controller is found
-      #   Ramaze::Error::NoAction     # if no action but a controller is found
-      #
-      # It actually uses #resolve_action on almost every combination of
-      # so-called paractions (yet unsplit but possible combination of action
-      # and parameters for the action)
-      #
-      # If your templating is action-less, which means it does not depend on
-      # methods on the controller, but rather on templates or just dynamically
-      # calculated stuff you can set trait[:actionless] for your templating.
-      #
-      # Please see the documentation for Ramaze::Template::Amrita2 for an more
-      # specific example of how it is used in practice.
-      #
-      # Further it uses the Global.mapping to look up the controller to be used.
-      #
-      # Also, the action '/' will be expanded to 'index'
-      #
-      # Parameters are CGI.unescaped
-
-      def resolve_controller path
-        meth_debug :resolve_controller, path
-        track = path.split('/')
-        controller = false
-        action = false
-        tracks = []
-
-        track.unshift '/'
+      def filter path
+        last_error = $!
+        ancestral_trait[:filters].each do |filter|
+          filtered = run_filter(filter, path)
 
-        track.each do |atom|
-          tracks << (tracks.last.to_s / atom)
+          next unless filtered
+          return filtered unless filtered.is_a?(Exception)
+          last_error = filtered
         end
 
-        until controller and action or tracks.empty?
-          current = Regexp.escape(tracks.pop.to_s)
-          paraction = path.gsub(/^#{current}/, '').split('/').map{|e| CGI.unescape(e)}
-          paraction.delete('')
-          if controller = Ramaze::Global.mapping[current]
-            if controller.ancestral_trait[:actionless] or paraction == ['error']
-
-              action = paraction.shift
-              params = paraction
-              action = 'index' if action == nil
-            else
-              action, params = resolve_action controller, paraction
-            end
-          end
-        end
-
-        raise Ramaze::Error::NoController, "No Controller found for #{path}" unless controller
-        raise Ramaze::Error::NoAction, "No Action found for #{path}" unless action
-
-        return controller, action, params
+        throw(:respond, handle_error(last_error))
       end
 
-      # Resolve the method to be called and the number of parameters
-      # it will receive for a specific class (the controller) given the
-      # paraction (like 'foo/bar' => controller.call('foo', 'bar'))
-      # in case arity is 1 and a public instance-method named foo is defined.
-      #
-      # TODO:
-      # - find a solution for def x(a = :a) which has arity -1
-      #   identical to def x(*a) for some odd reason
-
-      def resolve_action controller, paraction
-        meth_debug :resolve_action, controller, paraction
-
-        meths =
-          (controller.ancestors - [Kernel, Object]).inject([]) do |sum, klass|
-            sum | (klass.is_a?(Module) ? klass.instance_methods(false) : sum)
-          end
-
-        track = paraction.dup
-        tracks = []
-        action = false
+      def run_filter filter, path
+        filter[path]
+      rescue Object => ex
+        ex
+      end
 
-        track.each do |atom|
-          atom = [tracks.last.to_s, atom]
-          atom.delete('')
-          tracks << atom.join('__')
-        end
+      def handle_action path
+        handler = Controller.handle(path)
+      end
 
-        tracks.unshift 'index'
-
-        until action or tracks.empty?
-          current = tracks.pop
-          if meths.include?(current)
-            arity = controller.instance_method(current).arity
-            params = (paraction - current.split('__'))
-
-            if params.size == arity
-              return current, params
-            elsif arity < 0 and arity + params.size >= 0
-              return current, params
-            elsif arity == -1
-              return current, params
-            end
-          end
+      def handle_file path
+        custom_publics = Global.controllers.map{|c| c.trait[:public]}.compact
+        the_paths = $:.map{|way| (way/'public'/path) }
+        the_paths << (BASEDIR/'proto'/'public'/path)
+        the_paths += custom_publics.map{|c| c/path   }
+        file = the_paths.find{|way| File.file?(way)}
+
+        if file
+          response['Content-Type'] = Tool::MIME.type_for(file)
+          Informer.debug("Serving static: #{file}")
+          File.open(file)
         end
       end
 
-      # Depending on Global.cache_all and Global.cache_actions it will
-      # call either #handle_uncached_controller or #handle_cached_controller
-      # takes the controller, action and params and just passes them on.
+      # takes the content, code and head for a new response, will set the cookies
+      # if Global.cookies is true (which it is by default) and set the default
+      # Content-Type to 'text/plain'
 
-      def handle_controller controller, action, params
-        if Global.cache_all or Global.cache_actions[controller].include?(action.to_s)
-          handle_cached_controller(controller, action, *params)
-        else
-          handle_uncached_controller(controller, action, *params)
+      def build_response body = '', status = STATUS_CODE[:internal_server_error], head = {}
+        set_cookie if Global.cookies
+        head.each do |key, value|
+          response[key] = value
         end
-      end
 
-      # Call the class-method handle_request with action and *params, all
-      # the controller has to do is to respond with a string.
+        response.body, response.status = body, status
 
-      def handle_uncached_controller controller, action, *params
-        controller.handle_request(action, *params)
+        return response
       end
 
-      # Call the class-method handle_request with action and *params, all
-      # the controller has to do is to respond with a string.
-      #
-      # To add a method for caching you can either use the CacheHelper
-      # or directly
-      #   Global.cache_actions[self] << 'index'
-      #
-      # Caching is done for [action, params] pairs per controller.
-
-      def handle_cached_controller controller, action, *params
-        Global.cached_actions ||= Global.cache.new
-
-        key = [action, params].inspect
-
-        Global.cached_actions[controller] ||= {key => nil}
-
-        if out = Global.cached_actions[controller][key]
-          debug "Using Cached version for #{key.inspect}"
-          return out
-        end
-
-        debug "Compiling Action: #{action} #{params.join(', ')}"
-        Global.cached_actions[controller][key] =
-          handle_uncached_controller(controller, action, *params)
+      def set_cookie
+        session.finalize
+        hash = {:value => session.session_id, :path => '/'}
+        response.set_cookie(Session::SESSION_KEY, hash)
       end
 
       # Setup the Trinity (Request, Response, Session) and store them as
@@ -304,11 +176,11 @@ module Ramaze
       #   Thread.current[:response] == Response.current
       #   Thread.current[:session]  == Session.current
 
-      def setup_environment orig_response, orig_request
+      def setup_environment rack_request, rack_response
         this = Thread.current
-        this[:request]  = Request.new(orig_request)
+        this[:request]  = Request.new(rack_request)
         this[:session]  = Session.new(request)
-        this[:response] = build_response('', STATUS_CODE[:ok], 'Content-Type' => 'text/html')
+        this[:response] = rack_response
       end
     end
   end

data/lib/ramaze/error.rb

@@ -2,10 +2,20 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
+
+  # The general Namespace for Ramazes Errorclasses
+
   module Error
+    # No action found on Controller
     class NoAction < StandardError; end
+
+    # No Controller found for request
     class NoController < StandardError; end
+
+    # Wrong parameter count for action
     class WrongParameterCount < StandardError; end
+
+    # Error while transformation in template
     class Template < StandardError; end
   end
 end

data/lib/ramaze/global.rb

@@ -113,6 +113,14 @@ module Ramaze
         yield(e)
       end
     end
+
+    def inspect
+      table.inspect
+    end
+
+    def pretty_inspect
+      table.pretty_inspect
+    end
   end
 
   Thread.current[:global] = GlobalStruct.new(GlobalStruct::DEFAULT)

data/lib/ramaze/helper/aspect.rb

@@ -2,10 +2,13 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
+
   # A helper that provides the means to wrap actions of the controller with
   # other methods.
+  #
   # For examples please look at the test/tc_aspect.rb
-  # this is not a default helper due to the possible performance-issues.
+  #
+  # This is not a default helper due to the possible performance-issues.
   # However, it should be only an overhead of about 6-8 calls, so if you
   # want this feature it shouldn't have too large impact ;)
 
@@ -19,12 +22,28 @@ module Ramaze
       unless defined?(Traits[klass][:aspects]) and Traits[klass][:aspects]
         Traits[klass] = {:aspects => {:pre => {}, :post => {}, :wrap => {}}}
         unless defined?(klass.old_render)
-          klass.send(:alias_method, :old_render, :render)
-          klass.send(:alias_method, :render, :new_render)
+          klass.class_eval do
+            class << self
+              include AspectHelperMixin
+              alias_method :old_render, :render
+              alias_method :render, :new_render
+
+              public :render
+            end
+          end
         end
       end
     end
+  end
+
+  # This is the actual Module to be included into the Controller you call
+  #   helper :aspect
+  # from.
+  #
+  # The reason for that is to avoid recursion of inclusion in AspectHelper
+  # which does the aliasing and predefinition of the traits for the aspects.
 
+  module AspectHelperMixin
     private
 
     # define pre-aspect which calls render(:your_pre_aspect)
@@ -47,7 +66,7 @@ module Ramaze
     #   With great power comes great responsibility
     #
     # Example:
-    #   class FooController < Template::Ramaze
+    #   class FooController < Controller
     #
     #     def index
     #       'foo'
@@ -93,7 +112,7 @@ module Ramaze
     #   With great power comes great responsibility
     #
     # Example:
-    #   class FooController < Template::Ramaze
+    #   class FooController < Controller
     #
     #     def index
     #       'foo'
@@ -175,12 +194,16 @@ module Ramaze
 
       if pre
         arity = arity_for[pre].abs
-        pre_content = old_render(pre, *params[0,arity]) if pre
+        pre_content = old_render(pre, *params[0,arity])
       end
 
       unless (pre_content.delete(:skip_next_aspects) rescue false)
         content = old_render(action, *params)
-        post_content = old_render(post, *params) if post
+
+        if post
+          arity = arity_for[post].abs
+          post_content = old_render(post, *params[0,arity])
+        end
       end
 
       [pre_content, content, post_content].join