ramaze 0.0.9 → 0.1.0

data/lib/ramaze/dispatcher.rb

@@ -2,164 +2,69 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 require 'timeout'
-require 'ramaze/tool/mime'
 
-module Ramaze
+require 'ramaze/adapter'
+require 'ramaze/tool/mime'
 
-  # The Dispatcher is the very heart of Ramaze itself.
-  #
-  # It will take requests and guide the request through all parts of the
-  # framework and your application.
-  #
-  # It is built in a way that lets you easily replace it with something you
-  # like better, since i'm very fond of the current implementation you can't
-  # find any examples of how this is done exactly yet.
+require 'ramaze/dispatcher/action'
+require 'ramaze/dispatcher/error'
+require 'ramaze/dispatcher/file'
 
+module Ramaze
   module Dispatcher
-    trait :filters => [
-            lambda{|path| handle_file   path },
-            lambda{|path| handle_action path },
-          ]
+
+    trait :dispatch => [
+      Dispatcher::File,
+      Dispatcher::Action,
+    ]
 
     trait :handle_error => {
-        Exception => '/error',
-        Ramaze::Error::NoAction => '/error',
+        Exception                   => [500, '/error'],
+        Ramaze::Error::NoAction     => [404, '/error'],
+        Ramaze::Error::NoController => [404, '/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 rescue _all_ errors and exceptions
-      # thrown during processing of the request and #handle_error if
-      # a problem occurs.
-
       def handle rack_request, rack_response
-        setup_environment rack_request, rack_response
-        respond
-      rescue Object => exception
-        handle_error(exception)
-      end
-
-      # The handle_error method takes an exception and decides based on that
-      # how it is going to respond in case of an error.
-      #
-      # In future this will become more and more configurable, right now
-      # you can provide your own error-method and error.xhtml inside either
-      # your trait[:template_root] or trait[:public].
-      #
-      # As more and more error-classes are being added to Ramaze you will get
-      # the ability to define your own response-pages and/or behaviour like
-      # automatic redirects.
-      #
-      # This feature is only available if your Global.error is true, which is
-      # the default.
-      #
-      #--
-      #
-      # Yes, again, webrick _has_ to be really obscure, I searched for half an hour
-      # and still have not the faintest idea how request_path is related to
-      # request_uri...
-      # anyway, the solution might be simple?
-
-      def handle_error exception
-        Informer.error exception
-        Informer.meth_debug :handle_error, exception
-        Thread.current[:exception] = exception
-
-        handle_error = trait[:handle_error]
-
-        case exception
-        when *handle_error.keys
-          error_path = handle_error[exception.class]
-          error_path ||= handle_error.find{|k,v| k === exception}.last
-
-          if exception.message =~ /`#{error_path.split('/').last}'/
-            build_response(exception.message, STATUS_CODE[:internal_server_error])
-          else
-            request.path_info = error_path
-            respond
-          end
-        else
-          if Global.error_page
-            request.path_info = '/error'
-            respond
-          else
-            build_response(exception.message, STATUS_CODE[:internal_server_error])
-          end
-        end
-
-        response
-      rescue Object => ex
-        Informer.error ex
-        build_response(ex.message, STATUS_CODE[:internal_server_error])
+        setup_environment(rack_request, rack_response)
+        dispatch
+      rescue Object => error
+        Dispatcher::Error.process(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 respond
+      def dispatch
         path = request.path_info.squeeze('/')
-        Informer.info "Request from #{request.remote_addr}: #{path}"
+        Inform.info("Request from #{request.remote_addr}: #{path}")
 
         catch(:respond) do
           redirection = catch(:redirect) do
-            filtered = [filter(path)].flatten.first
-            throw(:respond, build_response(filtered, response.status))
+            found = filter(path)
+            throw(:respond, found)
           end
 
           body, status, head = redirection.values_at(:body, :status, :head)
-          Informer.info("Redirect to `#{head['Location']}'")
+          Inform.info("Redirect to `#{head['Location']}'")
           throw(:respond, build_response(body, status, head))
         end
       end
 
-      def filter path
-        last_error = $!
-        ancestral_trait[:filters].each do |filter|
-          filtered = run_filter(filter, path)
-
-          next unless filtered
-          return filtered unless filtered.is_a?(Exception)
-          last_error = filtered
-        end
-
-        throw(:respond, handle_error(last_error))
+      def dispatch_to path
+        raise "Redirect to #{path} from #{path}" if request.path_info == path
+        request.path_info = path
+        dispatch
       end
 
-      def run_filter filter, path
-        filter[path]
-      rescue Object => ex
-        ex
-      end
-
-      def handle_action path
-        handler = Controller.handle(path)
-      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, 'rb')
+      def filter path
+        trait[:dispatch].each do |dispatcher|
+          result = dispatcher.process(path)
+          return result if result
         end
+        raise Ramaze::Error::NoAction, "No Dispatcher found for `#{path}'"
       end
 
-      # 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 build_response body = '', status = STATUS_CODE[:internal_server_error], head = {}
+      def build_response body = response.body, status = response.status, head = response.header
         set_cookie if Global.cookies
         head.each do |key, value|
           response[key] = value
@@ -184,7 +89,7 @@ module Ramaze
 
       def setup_environment rack_request, rack_response
         this = Thread.current
-        this[:request]  = Request.new(rack_request)
+        this[:request]  = rack_request
         this[:session]  = Session.new(request)
         this[:response] = rack_response
       end

data/lib/ramaze/dispatcher/action.rb

@@ -0,0 +1,28 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+# require 'ramaze/tool/tidy'
+# require 'ramaze/tool/localize'
+
+module Ramaze
+  module Dispatcher
+    class Action
+
+      # The response is passed to each filter by sending .call(response) to it.
+
+      trait :filter => [
+        # Ramaze::Tool::Localize,
+        # Ramaze::Tool::Tidy
+      ]
+
+      class << self
+        def process(path)
+          body = Controller.handle(path)
+          response = Dispatcher.build_response(body)
+          filter = ancestral_trait[:filter]
+          filter.inject(response){|r,f| f.call(r) }
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/dispatcher/error.rb

@@ -0,0 +1,43 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module Dispatcher
+    class Error
+      class << self
+        trait :last_error => nil
+
+        def process error
+          log_error(error)
+
+          Thread.current[:exception] = error
+          handle_error = Dispatcher.trait[:handle_error]
+
+          key = error.class.ancestors.find{|a| handle_error[a]}
+          status, path = *handle_error[key || Exception]
+
+          unless error.message =~ %r(`#{path.split('/').last}')
+            Response.current.status = status
+            return Dispatcher.dispatch_to(path) if path and Global.error_page
+          end
+
+          Dispatcher.build_response(error.message, status)
+        rescue Object => ex
+          Inform.error(ex)
+          Dispatcher.build_response(ex.message, status || 500)
+        end
+
+        def log_error error
+          error_message = error.message
+
+          if trait[:last_error] == error_message
+            Inform.error(error_message)
+          else
+            trait[:last_error] = error_message
+            Inform.error(error)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/dispatcher/file.rb

@@ -0,0 +1,34 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module Dispatcher
+    class File
+      class << self
+        def process(path)
+          return unless file = open_file(path)
+          Dispatcher.build_response(file, Ramaze::STATUS_CODE[:ok])
+        end
+
+        def lookup_paths
+          [ (BASEDIR/'proto'/'public'),
+            Global.controllers.map{|c| c.trait[:public]},
+            './public'
+          ].flatten.select{|f| ::File.directory?(f.to_s)}.map{|f| ::File.expand_path(f)}
+        end
+
+        def open_file(path)
+          paths = lookup_paths.map{|pa| pa/path}
+          file = paths.find{|way| ::File.file?(way)}
+
+          if file
+            response = Response.current
+            response['Content-Type'] = Tool::MIME.type_for(file)
+            Inform.debug("Serving static: #{file}")
+            ::File.open(file, 'rb')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/global.rb

@@ -6,26 +6,19 @@ require 'set'
 
 module Ramaze
   class GlobalStruct < OpenStruct
-    # autoreload    - Interval for autoreloading changed source in seconds
-    # adapter       - Webserver-adapter ( :mongrel | :webrick )
-    # cache         - Cache to use   ( MemcachedCache | MemoryCache | YamlStoreCache )
-    # cache_actions - Finegrained caching based on actions (see CacheHelper)
-    # cache_all     - Naive caching for all responses ( true | false )
-    # error_page    - Show default errorpage with inspection and backtrace ( true | false )
-    # host          - Host to respond to ( '0.0.0.0' )
-    # mapping       - Route to controller map ( {} )
-    # port          - First port of the port-range the adapters run on. ( 7000 )
-    # run_loose     - Don't wait for the servers to finish, useful for testing ( true | false )
-    # tidy          - Run all text/html responses through Tidy ( true | false )
-    # template_root - Default directory for your templates.
-    #
-    # inform_to             - :stdout/'stdout'/$stderr (similar for stdout) or some path to a file
-    # inform_tags           - a Set with any of [ :debug, :info, :error ]
-    # inform_backtrace_size - size of backtrace to be logged (and show on error-page).
-    # inform_timestamp      - parameter for Time.strftime
-    # inform_prefix_info    - prefix for all the Inform#info messages
-    # inform_prefix_debug   - prefix for all the Inform#debug messages
-    # inform_prefix_error   - prefix for all the Inform#error messages
+    # autoreload     - Interval for autoreloading changed source in seconds
+    # adapter        - Webserver-adapter ( :mongrel | :webrick )
+    # backtrace_size - size of backtrace to be logged (and shown on error-page).
+    # benchmarking   - enable timing of each request
+    # cache          - Cache to use   ( MemcachedCache | MemoryCache | YamlStoreCache )
+    # cache_all      - Naive caching for all responses ( true | false )
+    # cookies        -
+    # error_page     - Show default errorpage with inspection and backtrace ( true | false )
+    # host           - Host to respond to ( '0.0.0.0' )
+    # mapping        - Route to controller map ( {} )
+    # port           - First port of the port-range the adapters run on. ( 7000 )
+    # run_loose      - Don't wait for the servers to finish, useful for testing ( true | false )
+    # template_root  - Default directory for your templates.
     #
     # startup         - List of methods and lambdas that are executed on startup
     # ramaze_startup  - Internal list of methods and lambdas that are executed on startup
@@ -34,40 +27,45 @@ module Ramaze
     # ramaze_shutdown - Internal list of methods and lambdas that are executed on shutdown
 
     DEFAULT = {
-      :autoreload     => 5,
-      :adapter        => :webrick,
-      :cache          => MemoryCache,
-      :cache_actions  => Hash.new{|h,k| h[k] = Set.new},
-      :cache_all      => false,
-      :cookies        => true,
-      :error_page     => true,
-      :host           => '0.0.0.0',
-      :mapping        => {},
-      :port           => 7000,
-      :run_loose      => false,
-      :tidy           => false,
-      :template_root  => 'template',
-
-      :inform_to             => $stdout,
-      :inform_tags           => Set.new([:debug, :info, :error]),
-      :inform_backtrace_size => 10,
-      :inform_timestamp      => "%Y-%m-%d %H:%M:%S",
-      :inform_prefix_info    => 'INFO ',
-      :inform_prefix_debug   => 'DEBUG',
-      :inform_prefix_error   => 'ERROR',
-
-      :startup => [],
+      :autoreload       => 5,
+      :adapter          => :webrick,
+      :backtrace_size   => 10,
+      :benchmarking     => false,
+      :cache            => MemoryCache,
+      :cache_all        => false,
+      :controllers      => Set.new,
+      :cookies          => true,
+      :error_page       => true,
+      :host             => '0.0.0.0',
+      :localize         => lambda{ Ramaze::Tool::Localize.trait },
+      :logger           => Ramaze::Informer.new($stdout),
+      :mapping          => {},
+      :port             => 7000,
+      :run_loose        => false,
+      :template_root    => 'template',
+      :tidy             => lambda{ Ramaze::Tool::Tidy.trait },
+      :test_connections => true,
+      :shutdown_trap    => 'SIGINT',
+
+      :startup => [
+        lambda{
+          Ramaze::Inform = Global.logger unless defined?(Inform)
+          Inform.info("Starting up Ramaze (Version #{VERSION})")
+        }
+      ],
       :ramaze_startup => [
-          :find_controllers, :setup_controllers, :init_autoreload, :init_adapter
-        ],
+        :setup_controllers, :init_autoreload, :init_adapter
+      ],
 
       :shutdown => [],
       :ramaze_shutdown => [
         :kill_threads,
-        :close_inform,
-        lambda{ puts "Shutdown Ramaze (it's save to kill me now if i hang)" },
+        lambda{
+          Inform.shutdown
+          puts("Shutdown Ramaze (it's save to kill me now if i hang)")
+        },
         :exit
-        ],
+      ],
     }
 
     # takes an hash of options and optionally an block that is evaled in this
@@ -106,6 +104,12 @@ module Ramaze
       table.values_at(*keys.map(&:to_sym))
     end
 
+    # all keys already set
+
+    def keys
+      table.keys
+    end
+
     # iterate over the GlobalStruct, no guarantee on the order.
 
     def each
@@ -121,6 +125,43 @@ module Ramaze
     def pretty_inspect
       table.pretty_inspect
     end
+
+
+  def new_ostruct_member(name)
+    name = name.to_sym
+    unless self.respond_to?(name)
+      class << self; self; end.class_eval do
+        define_method(name) { @table[name] }
+        define_method(:"#{name}=") { |x| @table[name] = x }
+      end
+    end
+  end
+
+    def new_ostruct_member(name)
+      name = name.to_sym
+      unless self.respond_to?(name)
+        meta = (class << self; self; end)
+        meta.class_eval do
+          define_method(name) do
+            sel = @table[name]
+            if sel.respond_to?(:call)
+              sel.call
+            else
+              sel
+            end
+          end
+
+          define_method(:"#{name}=") do |x|
+            sel = @table[name]
+            if sel.respond_to?(:call)
+              sel.call("#{name}=", x)
+            else
+              @table[name] = x
+            end
+          end
+        end
+      end
+    end
   end
 
   Thread.current[:global] = GlobalStruct.new(GlobalStruct::DEFAULT)