ramaze 0.1.4 → 0.2.0

data/lib/ramaze/controller/resolve.rb

@@ -3,16 +3,34 @@
 
 module Ramaze
   class Controller
+    FILTER = [ :cached, :default ] unless defined?(FILTER)
+
     class << self
-      # #ramaze - 9.5.2007
-      #
-      # manveru: if no possible controller is found, it's a NoController error
-      # manveru: that would be a 404 then
-      # Kashia: aye
-      # manveru: if some controller are found but no actions on them, it's NoAction Error for the first controller found, again, 404
-      # manveru: everything further down is considered 500
-
-      def resolve(path)
+
+      # Resolve an absolute path in the application by passing it to each
+      # element of Ramaze::Controller::FILTER.
+      # Elements in exclude_filter are excluded from handling.
+      # If an element does not respond to call it will be sent to self
+      # instead, in either case with path as argument.
+
+      def resolve(path, *exclude_filter)
+        (FILTER - exclude_filter.flatten).each do |filter|
+          answer =
+            if filter.respond_to?(:call)
+              filter.call(path)
+            else
+              send(filter.to_s, path)
+            end
+          return answer if answer
+        end
+
+        raise_no_filter(path)
+      end
+
+      # Default element of FILTER.
+      # Looks up the path in Cache.resolved and returns it if found.
+
+      def cached(path)
         if found = Cache.resolved[path]
           if found.respond_to?(:relaxed_hash)
             return found.dup
@@ -22,6 +40,15 @@ module Ramaze
           end
         end
 
+        nil
+      end
+
+      # Default element of FILTER.
+      # The default handler that tries to find the best match for the given
+      # path in terms of Controller/method/template and given arguments.
+      # If a match is found it will be cached for further use.
+
+      def default(path)
         mapping     = Global.mapping
         controllers = Global.controllers
 
@@ -52,6 +79,7 @@ module Ramaze
 
       # Try to produce an Action from the given path and paremters with the
       # appropiate template if one exists.
+
       def resolve_action(path, *parameter)
         path, parameter = path.to_s, parameter.map(&:to_s)
         if alternate_template = trait["#{path}_template"]
@@ -74,6 +102,7 @@ module Ramaze
 
       # Search the #template_paths for a fitting template for path.
       # Only the first found possibility for the generated glob is returned.
+
       def resolve_template(path)
         path = path.to_s
         path_converted = path.split('__').inject{|s,v| s/v}
@@ -118,7 +147,7 @@ module Ramaze
 
       # Generate all possible permutations for given path.
       def pattern_for(path)
-        atoms = path.split('/').grep(/\S/)
+        atoms = path.to_s.split('/').grep(/\S/)
         atoms.unshift('')
         patterns, joiner = [], '/'
 
@@ -149,10 +178,18 @@ module Ramaze
       # templating-engine to use ordered by priority and likelyhood.
       def extension_order
         t_extensions = Template::ENGINES
-        engine = trait[:engine]
-        c_extensions = t_extensions.select{|k,v| k == engine}.map{|k,v| v}.flatten
-        all_extensions = t_extensions.map{|k,v| v}.flatten
-        (c_extensions + all_extensions).uniq
+        all_extensions = t_extensions.values.flatten
+
+        if engine = trait[:engine]
+          c_extensions = t_extensions.select{|k,v| k == engine}.map{|k,v| v}.flatten
+          return (c_extensions + all_extensions).uniq
+        end
+
+        all_extensions
+      end
+
+      def raise_no_filter(path)
+        raise Ramaze::Error::NoFilter, "No Filter found for `#{path}'"
       end
 
       # Raises Ramaze::Error::NoController

data/lib/ramaze/dispatcher.rb

@@ -20,8 +20,7 @@ module Ramaze
   module Dispatcher
 
     # requests are passed to every
-    FILTER = [ Dispatcher::File, Dispatcher::Directory,
-               Dispatcher::Action ] unless defined?(FILTER)
+    FILTER = [ Dispatcher::File, Dispatcher::Action ] unless defined?(FILTER)
 
     # Response codes to cache the output of for repeated requests.
     trait :shielded => [ STATUS_CODE["Not Found"] ]
@@ -36,7 +35,13 @@ module Ramaze
         setup_environment(rack_request, rack_response)
 
         path = request.path_info.squeeze('/')
-        Inform.info("Request from #{request.remote_addr}: #{path}")
+
+        case path
+        when *Global.ignore
+          unless ::File.exist?(Dispatcher::File.resolve_path(path))
+            return response.build(Global.ignore_body, Global.ignore_status)
+          end
+        end
 
         general_dispatch path
       rescue Object => error
@@ -94,16 +99,13 @@ module Ramaze
       # filters the path until a response or redirect is thrown or a filter is
       # successful, builds a response from the returned hash in case of throws.
       def dispatch(path)
-        catch(:respond) do
-          redirection = catch(:redirect) do
-            found = filter(path)
-            throw(:respond, found)
-          end
-
-          body, status, head = redirection.values_at(:body, :status, :head)
-          Inform.info("Redirect to `#{head['Location']}'")
-          throw(:respond, response.build(body, status, head))
-        end
+        catch(:respond){
+          redirected = catch(:redirect){
+            filter(path)
+            throw(:respond)
+          }
+          response.build(*redirected)
+        }
       end
 
       # Calls .process(path) on every class in Dispatcher::FILTER until one

data/lib/ramaze/dispatcher/action.rb

@@ -11,18 +11,19 @@ module Ramaze
 
       # The response is passed to each filter by sending .call(response) to it.
 
-      FILTER = [
+      FILTER = OrderedSet.new(
         # Ramaze::Tool::Localize,
-        # Ramaze::Tool::Tidy
-      ]
+      ) unless defined?(FILTER)
 
       class << self
+        include Trinity
 
         # Takes path, asks Controller to handle it and builds a response on
         # success. The response is then passed to each member of FILTER for
         # post-processing.
 
         def process(path)
+          Inform.info("Dynamic request from #{request.remote_addr}: #{path}")
           body = Controller.handle(path)
           response = Response.current.build(body)
           FILTER.inject(response){|r,f| f.call(r) }

data/lib/ramaze/dispatcher/directory.rb

@@ -78,7 +78,7 @@ module Ramaze
           dirs, files = Dir[path/'*'].partition{|file| ::File.directory?(file) }
           dir_body, file_body = [], []
 
-          dirs.each do |dir|
+          dirs.sort.each do |dir|
             basename = ::File.basename(dir)
             dir_body << %[<tr>
             <td class="n"><a href="#{display/basename}">#{basename}/</a></td>
@@ -89,10 +89,10 @@ module Ramaze
           end
 
           time_format = "%Y-%b-%d %H:%M:%S"
-          files.each do |file|
+          files.sort.each do |file|
             basename = ::File.basename(file)
             time = ::File.mtime(file).strftime(time_format)
-            size = ::File.size(file).human_readable_filesize_format
+            size = ::File.size(file).filesize_format
             mime = Tool::MIME.type_for(file)
             file_body << %[<tr>
             <td class="n"><a href="#{display/basename}">#{basename}</a></td>

data/lib/ramaze/dispatcher/error.rb

@@ -64,7 +64,7 @@ module Ramaze
         def log_error error
           error_message = error.message
 
-          if trait[:last_error] == error_message
+          if trait[:last_error] == error_message or error.is_a? Ramaze::Error::NoAction
             Inform.error(error_message)
           else
             trait[:last_error] = error_message

data/lib/ramaze/dispatcher/file.rb

@@ -9,26 +9,37 @@ module Ramaze
 
     class File
       class << self
+        include Trinity
 
         # Entry point from Dispatcher::filter.
         # searches for the file and builds a response with status 200 if found.
 
         def process(path)
           return unless file = open_file(path)
-          Response.current.build(file, Ramaze::STATUS_CODE['OK'])
+          response.build(file, STATUS_CODE['OK'])
         end
 
         # returns file-handle with the open file on success, setting the
         # Content-Type as found in Tool::MIME
 
         def open_file(path)
-          file = ::File.join(Global.public_root, path =~ /\/$/ ? path + 'index' : path)
+          file = resolve_path(path)
+          if ::File.file?(file) or ::File.file?(file=file/'index')
+            response['Content-Type'] = Tool::MIME.type_for(file) unless ::File.extname(file).empty?
+            log(file)
+            ::File.open(file, 'rb')
+          end
+        end
 
-          if ::File.file?(file)
-            response = Response.current
-            response['Content-Type'] = Tool::MIME.type_for(file)
+        def resolve_path(path)
+          ::File.join(Global.public_root, path)
+        end
+
+        def log(file)
+          case file
+          when *Global.boring
+          else
             Inform.debug("Serving static: #{file}")
-            ::File.open(file, 'rb')
           end
         end
       end

data/lib/ramaze/error.rb

@@ -9,6 +9,9 @@ module Ramaze
     # No action found on Controller
     class NoAction < Error; end
 
+    # No Controller found for request
+    class NoFilter < Error; end
+
     # No Controller found for request
     class NoController < Error; end
 

data/lib/ramaze/gestalt.rb

@@ -72,32 +72,52 @@ module Ramaze
     # catching all the tags. passing it to _gestalt_build_tag
 
     def method_missing meth, *args, &block
-      _gestalt_build_tag meth, *args, &block
+      _gestalt_call_tag meth, args, &block
     end
 
     # workaround for Kernel#p to make <p /> tags possible.
 
     def p *args, &block
-      _gestalt_build_tag :p, *args, &block
+      _gestalt_call_tag :p, args, &block
+    end
+
+    def _gestalt_call_tag name, args, &block
+      if args.size == 1 and args[0].kind_of? Hash
+        # args are just attributes, children in block...
+        _gestalt_build_tag name, args[0], &block
+      else
+        # no attributes, but text
+        _gestalt_build_tag name, {}, args, &block
+      end
     end
 
     # build a tag for `name`, using `args` and an optional block that
     # will be yielded
 
-    def _gestalt_build_tag name, args = []
+    def _gestalt_build_tag name, attr={}, text=[]
       @out << "<#{name}"
-      if block_given?
-        @out << args.inject(''){ |s,v| s << %{ #{v[0]}="#{v[1]}"} }
+      @out << attr.inject(''){ |s,v| s << %{ #{v[0]}="#{_gestalt_escape_entities(v[1])}"} }
+      if text != [] or block_given?
         @out << ">"
-        text = yield
-        @out << text if text != @out and text.respond_to?(:to_str)
+        @out << _gestalt_escape_entities(text.to_s)
+        if block_given?
+          text = yield
+          @out << text.to_str if text != @out and text.respond_to?(:to_str)
+        end
         @out << "</#{name}>"
       else
-        @out << args.inject(''){ |s,v| s << %{ #{v[0]}="#{v[1]}"} }
         @out << ' />'
       end
     end
 
+    def _gestalt_escape_entities(s)
+      s.to_s.gsub(/&/, '&amp;').
+        gsub(/"/, '&quot;').
+        gsub(/'/, '&apos;').
+        gsub(/</, '&lt;').
+        gsub(/>/, '&gt;')
+    end
+
     # @out.to_s
 
     def to_s

data/lib/ramaze/global.rb

@@ -20,15 +20,25 @@ module Ramaze
     o "Turn benchmarking every request on.",
       :benchmarking => false, :cli => false, :short => :b
 
+    o "Do not log about these requests to static files, values as in Global.ignore",
+      # Example: [/\.(ico|gif|jpg|png)$/, '/robots.txt']
+      :boring => [ '/favicon.ico' ]
+
     o "Use this for general caching and as base for Cache.new.",
       :cache => :memory, :cli => [:memory, :memcached, :yaml]
 
+    o "Alternative caches",
+      :cache_alternative => {}
+
     o "Turn on naive caching of all requests.",
       :cache_all => false, :cli => false
 
     o "Compile Templates",
       :compile => false, :cli => false
 
+    o "Active contribs ",
+      :contribs => Set.new
+
     o "All subclasses of Controller are collected here.",
       :controllers => Set.new
 
@@ -41,12 +51,22 @@ module Ramaze
     o "Caching actions to the filesystem in Global.public_root",
       :file_cache => false, :cli => false
 
-    o "Base directory for meta information of file-caching",
-      :file_cache_meta_dir => "cache_meta", :cli => "cache_meta"
-
     o "Specify what IP Ramaze will respond to - 0.0.0.0 for all",
       :host => "0.0.0.0", :cli => '0.0.0.0'
 
+    o "Ignore requests to these paths if no file in public_root exists, absolute path or regex",
+      # Example: [/\.(ico|gif|jpg|png)$/, '/robots.txt']
+      :ignore => [ '/favicon.ico' ]
+
+    o "Body set on ignored paths",
+      :ignore_body => "File not found"
+
+    o "Status set on ignored paths",
+      :ignore_status => 404
+
+    o "Templating engines to load on startup",
+      :load_engines => []
+
     o "All paths to controllers are mapped here.",
       :mapping => {}
 
@@ -57,7 +77,7 @@ module Ramaze
       :port => 7000, :cli => 7000, :short => :p
 
     o "Specify directory to serve static files",
-      :public_root => './public', :cli => './public'
+      :public_root => APPDIR/'./public', :cli => './template'
 
     o "Record all Request objects by assigning a filtering Proc to me.",
       :record => false
@@ -84,7 +104,7 @@ module Ramaze
       :test_connections => true, :cli => true
 
     o "Specify directory to serve dynamic files",
-      :template_root => './template', :cli => './template'
+      :template_root => APPDIR/'./template', :cli => './template'
 
     o "Enable directory listing",
       :list_directories => false, :cli => false
@@ -92,5 +112,5 @@ module Ramaze
 
   require 'ramaze/global/globalstruct'
 
-  Global = GlobalStruct.setup(OPTIONS)
+  Global = GlobalStruct.setup(OPTIONS) unless defined?(Global)
 end

data/lib/ramaze/global/globalstruct.rb

@@ -10,12 +10,19 @@ module Ramaze
   # Class for Ramaze::Global instance.
   class GlobalStruct
 
+    ENV_TRIGGER = {
+      'EVENT' => lambda{ require 'ramaze/adapter/evented_mongrel' },
+      'SWIFT' => lambda{ require 'ramaze/adapter/swiftiplied_mongrel' }
+    }
+
     # mapping of :adapter => to the right class-name.
     ADAPTER_ALIAS = {
-      :webrick => :WEBrick,
-      :mongrel => :Mongrel,
-      :cgi     => :CGI,
-      :fcgi    => :Fcgi,
+      :webrick             => :WEBrick,
+      :cgi                 => :Cgi,
+      :fcgi                => :Fcgi,
+      :mongrel             => :Mongrel,
+      :evented_mongrel     => :Mongrel,
+      :swiftiplied_mongrel => :Mongrel,
     }
 
     # mapping of :cache => to the right class-name.
@@ -38,6 +45,13 @@ module Ramaze
           create_member(key, value)
         end
       end
+
+      ENV_TRIGGER.values_at(*ENV.keys).compact.each{|l| l.call}
+
+      engines = self[:load_engines]
+      (Symbol === engines ? [engines] : engines).each do |engine|
+        Ramaze::Template.const_get(engine)
+      end
     end
 
     # batch-assignment of key/value from hash, yields self if a block is given.
@@ -55,8 +69,8 @@ module Ramaze
     # the actual class.
     def adapter
       if internal = self[:adapter]
-        class_name = ADAPTER_ALIAS[internal.to_sym]
-        require("ramaze/adapter/"/class_name.to_s.downcase)
+        class_name = ADAPTER_ALIAS.fetch(internal.to_sym, internal)
+        require("ramaze/adapter"/internal.to_s.downcase)
         adapter = Ramaze::Adapter.const_get(class_name)
       end
     end
@@ -90,6 +104,17 @@ module Ramaze
       self[:public_root] = File.expand_path(pr)
     end
 
+    def list_directories=(active)
+      require 'ramaze/dispatcher'
+      d = Ramaze::Dispatcher
+      self[:list_directories] = active
+      if active
+        d::FILTER.put_within(d::Directory, :after => d::File, :before => d::Action)
+      else
+        d::FILTER.delete(d::Directory)
+      end
+    end
+
 
     # External helpers