ramaze 0.1.3 → 0.1.4

data/lib/ramaze/action.rb

@@ -101,6 +101,26 @@ module Ramaze
       self[:binding] ||= instance.instance_eval{ binding }
     end
 
+    def name
+      File.basename((self[:method] || self[:template]).to_s).split('.').first
+    end
+
+    # TODO: find good names for this method.
+
+    def basepath
+      @basepath ||= "#{controller.mapping}/#{name}".gsub(/^\/+/, '/')
+    end
+
+    # TODO: find good names for this method.
+    def fullpath
+      "#{path}/#{params.join('/')}".gsub(/^\/+/, '/')
+    end
+
+    # TODO: find good names for this method.
+    def extended_path
+      @extended_path ||= File.join(path, *params)
+    end
+
     # Hook for AspectHelper
 
     def before_process

data/lib/ramaze/adapter/cgi.rb

@@ -4,15 +4,18 @@
 require 'ramaze/adapter'
 
 module Ramaze::Adapter
+
+  # Our CGI adapter acts as wrapper for the Rack::Handler::CGI.
   class Cgi < Base
     class << self
-      def start host, ports
+
+      # start CGI in a new thread, host and port parameter are only taken
+      # to make it compatible with other adapters but have no influence and
+      # can be omitted
+      def start host = nil, ports = nil
         global = Ramaze::Global
         global.inform_to = :stderr if global.inform_to == $stdout
-        run_server
-      end
 
-      def run_server
         Thread.new do
           Thread.current[:task] = :cgi
           Rack::Handler::CGI.run(self)

data/lib/ramaze/adapter/fcgi.rb

@@ -4,13 +4,15 @@
 require 'ramaze/adapter'
 
 module Ramaze::Adapter
+
+  # Our Fcgi adapter acts as wrapper for the Rack::Handler::FastCGI.
   class Fcgi < Base
     class << self
-      def start host, ports
-        run_server
-      end
 
-      def run_server
+      # start FastCGI in a new thread, host and port parameter are only taken
+      # to make it compatible with other adapters but have no influence and
+      # can be omitted
+      def start host = nil, ports = nil
         Thread.new do
           Thread.current[:task] = :cgi
           Rack::Handler::FastCGI.run(self)

data/lib/ramaze/adapter/mongrel.rb

@@ -16,8 +16,12 @@ module Ramaze
   require 'rack/handler/mongrel'
 
   module Adapter
+
+    # Our Mongrel adapter acts as wrapper for the Rack::Handler::Mongrel.
     class Mongrel < Base
       class << self
+
+        # start server on given host and port.
         def run_server host, port
           server = ::Mongrel::HttpServer.new(host, port)
           server.register('/', ::Rack::Handler::Mongrel.new(self))

data/lib/ramaze/adapter/webrick.rb

@@ -5,19 +5,14 @@ require 'ramaze/adapter'
 require 'webrick'
 require 'rack/handler/webrick'
 
-module WEBrick
-  module HTTPServlet
-    class ProcHandler
-      alias do_PUT do_GET
-      alias do_DELETE do_GET
-    end
-  end
-end
-
 module Ramaze
   module Adapter
+
+    # Our WEBrick adapter acts as wrapper for the Rack::Handler::WEBrick.
     class WEBrick < Base
       class << self
+
+        # start server on given host and port, see below for possible options.
         def run_server host, port, options = {}
           options = {
             :Port        => port,
@@ -41,3 +36,19 @@ module Ramaze
     end
   end
 end
+
+# Extending on WEBrick module
+module WEBrick
+
+  # Extending on HTTPServlet
+  module HTTPServlet
+
+    # Extending on ProcHandler
+    #
+    # We alias PUT to GET and DELETE to GET so WEBrick handles them as well.
+    class ProcHandler
+      alias do_PUT do_GET
+      alias do_DELETE do_GET
+    end
+  end
+end

data/lib/ramaze/adapter.rb

@@ -109,7 +109,9 @@ module Ramaze
 
       def test_connection host, port
         Timeout.timeout(1) do
-          TCPServer.open(host, port){ true }
+          testsock = TCPServer.new(host, port)
+          testsock.close
+          true
         end
       rescue => ex
         Inform.error(ex)

data/lib/ramaze/cache/memcached.rb

@@ -62,33 +62,9 @@ module Ramaze
     def values_at(*keys)
       get_multi(*keys).values_at(*keys)
     end
-  end
-end
-
-# add the MemCache#clear method
-
-class MemCache
-
-  # MemCache.clear sends 'flush_all' command to all registered MemCache
-  # servers.
-
-  def clear
-    raise MemCacheError, "Update of readonly cache" if @readonly
-
-    @servers.each do |server|
-      server.flush_all
-    end
-  end
-
-  # implements the flushing of MemCache server. Flushes a single server,
-  # MemCache#clear can be used for clearing out all MemCache servers.
-
-  class Server
-
-    # Serverside implementation of the #clear functionality for MemCache
 
-    def flush_all
-      socket.write "flush_all\r\n"
+    def clear
+      @cache.flush_all
     end
   end
 end

data/lib/ramaze/cache.rb

@@ -12,6 +12,8 @@ module Ramaze
 
   class Cache
     include Enumerable
+
+    # Holds all the instances of Cache that are being added.
     CACHES = {} unless defined?(CACHES)
 
     attr_accessor :cache
@@ -47,33 +49,35 @@ module Ramaze
     end
 
     # Initializes the cache, defined by Global.cache
-
     def initialize(cache = Global.cache)
       @cache = cache.new
     end
 
+    # Get key.
     def [](key)
       @cache["#{@cache_name}:#{key}"]
     end
 
+    # Set key to value.
     def []=(key, value)
       @cache["#{@cache_name}:#{key}"] = value
     end
 
     # deletes the keys of each argument passed from Cache instance.
-
     def delete(*args)
       args.each do |arg|
         @cache.delete("#{@cache_name}:#{arg}")
       end
     end
 
+    # Empty this cache
     def clear
       @cache.clear
     end
 
-    def values_at(*args)
-      @cache.values_at(*args.map {|key| "#{@cache_name}:#{key}" })
+    # Answers with value for each key.
+    def values_at(*keys)
+      @cache.values_at(*keys.map {|key| "#{@cache_name}:#{key}" })
     end
   end
 end

data/lib/ramaze/controller/resolve.rb

@@ -15,7 +15,7 @@ module Ramaze
       def resolve(path)
         if found = Cache.resolved[path]
           if found.respond_to?(:relaxed_hash)
-            return found
+            return found.dup
           else
             Inform.warn("Found faulty `#{path}' in Cache.resolved, deleting it for sanity.")
             Cache.resolved.delete path
@@ -39,7 +39,10 @@ module Ramaze
 
             valid_action = (action.method or (params.empty? && template))
 
-            return Cache.resolved[path] = action if valid_action
+            if valid_action
+              Cache.resolved[path] = action
+              return action.dup
+            end
           end
         end
 
@@ -47,6 +50,8 @@ module Ramaze
         raise_no_controller(path)
       end
 
+      # 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"]
@@ -67,22 +72,30 @@ module Ramaze
                       :controller => self
       end
 
-      def resolve_template(action)
-        action = action.to_s
-        action_converted = action.split('__').inject{|s,v| s/v}
-        actions = [action, action_converted].compact
+      # 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}
+        possible_paths = [path, path_converted].compact
 
-        paths = template_paths.map{|pa| actions.map{|a| pa/a } }.flatten.uniq
+        paths = template_paths.map{|pa| possible_paths.map{|a| pa/a } }.flatten.uniq
         glob = "{#{paths.join(',')}}.{#{extension_order.join(',')}}"
 
         Dir[glob].first
       end
 
+      # Composes an array with the template-paths to look up in the right order.
+      # Usually this is composed of Global.template_root and the mapping of the
+      # controller and a second element for Global.public_root, which makes
+      # it possible to convert CSS on the fly and things like that.
+
       def template_paths
         @template_root ||= Global.template_root / Global.mapping.invert[self]
         [ @template_root, Global.public_root ].compact
       end
 
+      # Based on methodname and arity, tries to find the right method on current controller.
       def resolve_method(name, *params)
         if method = action_methods.delete(name)
           arity = instance_method(method).arity
@@ -93,6 +106,7 @@ module Ramaze
         return nil, []
       end
 
+      # methodnames that may be used for current controller.
       def action_methods
         exclude = Controller.trait[:exclude_action_modules]
 
@@ -102,6 +116,7 @@ module Ramaze
         meths - ancs.map(&:to_s)
       end
 
+      # Generate all possible permutations for given path.
       def pattern_for(path)
         atoms = path.split('/').grep(/\S/)
         atoms.unshift('')
@@ -129,6 +144,9 @@ module Ramaze
         patterns.reverse!
       end
 
+      # Uses custom defined engines and all available engines and throws it
+      # against the extensions for the template to find the most likely
+      # templating-engine to use ordered by priority and likelyhood.
       def extension_order
         t_extensions = Template::ENGINES
         engine = trait[:engine]
@@ -146,7 +164,7 @@ module Ramaze
       # Raises Ramaze::Error::NoAction
 
       def raise_no_action(controller, path)
-        Thread.current[:failed_controller] = controller
+        Thread.current[:controller] = controller
         raise Ramaze::Error::NoAction, "No Action found for `#{path}' on #{controller}"
       end
     end

data/lib/ramaze/controller.rb

@@ -43,7 +43,12 @@ module Ramaze
 
       def inherited controller
         controller.trait :actions_cached => Set.new
+        controller.trait :layout => {:all => nil, :deny => Set.new}
         Global.controllers << controller
+        if map = controller.mapping
+          Inform.debug("mapping #{map} => #{controller}")
+          Global.mapping[map] ||= controller
+        end
       end
 
       # called from Ramaze.startup, adds Cache.actions and Cache.patterns, walks
@@ -52,13 +57,9 @@ module Ramaze
 
       def startup options = {}
         Inform.debug("found Controllers: #{Global.controllers.inspect}")
-
-        Global.controllers.each do |controller|
-          if map = controller.mapping
-            Inform.debug("mapping #{map} => #{controller}")
-            Global.mapping[map] ||= controller
-          end
-        end
+        tr, pr = Global.template_root, Global.public_root
+        Inform.warn("Template root: #{tr} doesn't exist") unless File.directory?(tr)
+        Inform.warn("Public root: #{pr} doesn't exist") unless File.directory?(pr)
 
         if Global.mapping.empty?
           Inform.warn("No Controllers mapped, will serve /public only.")
@@ -87,8 +88,12 @@ module Ramaze
       end
 
       # Map Controller to the given syms or strings.
+      # Replaces old mappings.
+      # If you want to _add_ a mapping, just modify Global.mapping.
 
       def map(*syms)
+        Global.mapping.delete_if{|k,v| v == self}
+
         syms.each do |sym|
           Global.mapping[sym.to_s] = self
         end
@@ -100,6 +105,37 @@ module Ramaze
         Global.mapping[mapping.to_s]
       end
 
+      # Define a layout for all actions on this controller
+      #
+      # Example:
+      #   class Foo < Ramaze::Controller
+      #     layout :foo
+      #   end
+      #
+      #  This defines the action :foo to be layout of the controller and will
+      #  render the layout after any other action has been rendered, assigns
+      #  @content to the result of the action and then goes on rendering
+      #  the layout-action where @content may or may not be used, returning
+      #  whatever the layout returns.
+
+      def layout(meth_or_hash, &block)
+        if meth_or_hash.respond_to?(:to_hash)
+          meth_or_hash.each do |layout_name, *actions|
+            actions.flatten.each do |action|
+              trait[:layout][action.to_s] = R(self, layout_name)
+            end
+          end
+        else
+          trait[:layout][:all] = R(self, meth_or_hash)
+        end
+      end
+
+      def deny_layout(*actions)
+        actions.each do |action|
+          trait[:layout][:deny] << action.to_s
+        end
+      end
+
       # Define a template_root for Controller, returns the current template_root
       # if no argument is given.
       # Runs every given path through Controller::check_path
@@ -148,6 +184,7 @@ module Ramaze
 
       def handle path
         action = resolve(path)
+        Thread.current[:controller] = action.controller
         action.render
       end
     end

data/lib/ramaze/dispatcher/action.rb

@@ -3,6 +3,10 @@
 
 module Ramaze
   module Dispatcher
+
+    # This dispatcher is responsible for relaying requests to Controller::handle
+    # and filtering the results using FILTER.
+
     class Action
 
       # The response is passed to each filter by sending .call(response) to it.
@@ -20,7 +24,7 @@ module Ramaze
 
         def process(path)
           body = Controller.handle(path)
-          response = Dispatcher.build_response(body)
+          response = Response.current.build(body)
           FILTER.inject(response){|r,f| f.call(r) }
         rescue Ramaze::Error => ex
           ex

data/lib/ramaze/dispatcher/directory.rb

@@ -0,0 +1,115 @@
+#          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
+
+    # Generates a directory listing, see Ramaze::Controller::Directory for more
+    # information and how to create your own directory listing page
+    class Directory
+      class << self
+
+        # Entry point from Dispatcher::filter.
+        # Just a forwarder to build_listing, automatticly exiting if there is
+        # an error (defined by returning false in build_listing)
+        def process(path)
+          if Global.list_directories
+            response = build_listing(path)
+            Response.current.build(*response) if response
+          end
+        end
+
+        # Makes a request for http://yourserver/dirlist/path and returns the
+        # result. Due to this method, you can overwrite the action and create your
+        # own page. See Ramaze::Controller::Directory for more.
+        def build_listing(path)
+          dir = ::File.expand_path(Global.public_root/::File.expand_path(path, '/'))
+
+          if ::File.directory?(dir)
+            Inform.debug("Serving directory listing: #{dir}")
+
+            status = Ramaze::STATUS_CODE['OK']
+            header = {'Content-Type' => "text/html"}
+            body = list_for(dir)
+            [body, status, header]
+          end
+        end
+
+        def list_for(path)
+          display = path.gsub(/^#{Regexp.escape(Global.public_root)}\/?/, '/')
+          wrapper =
+%(<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
+"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
+  <head>
+    <title>Directory listing of #{display}</title>
+
+    <style type="text/css"> /*<![CDATA[*/ a, a:active {text-decoration: none; color: blue;} a:visited {color: #48468F;} a:hover, a:focus {text-decoration: underline; color: red;} body {background-color: #F5F5F5;} h2 {margin-bottom: 12px;} table {margin-left: 12px;} th, td { font-family: "Courier New", Courier, monospace; font-size: 10pt; text-align: left;} th { font-weight: bold; padding-right: 14px; padding-bottom: 3px;} td {padding-right: 14px;} td.s, th.s {text-align: right;} div.list { background-color: white; border-top: 1px solid #646464; border-bottom: 1px solid #646464; padding-top: 10px; padding-bottom: 14px;} div.foot { font-family: "Courier New", Courier, monospace; font-size: 10pt; color: #787878; padding-top: 4px;} /*]]>*/ </style>
+  </head>
+  <body>
+    <h2>Directory listing of #{display}</h2>
+    <div class="list">
+      <table summary="Directory Listing" cellpadding="0" cellspacing="0">
+        <thead>
+          <tr>
+            <th class="n">Name</th>
+            <th class="m">Last Modified</th>
+            <th class="s">Size</th>
+            <th class="t">Type</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr>
+            <td class="n"><a href="#{display/'..'}/">Parent Directory</a>/</td>
+            <td class="m">&nbsp;</td>
+            <td class="s">- &nbsp;</td>
+            <td class="t">Directory</td>
+          </tr>
+          %s
+          %s
+        </tbody>
+      </table>
+    </div>
+    <div class="foot">%s</div>
+  </body>
+</html>
+)
+
+          dirs, files = Dir[path/'*'].partition{|file| ::File.directory?(file) }
+          dir_body, file_body = [], []
+
+          dirs.each do |dir|
+            basename = ::File.basename(dir)
+            dir_body << %[<tr>
+            <td class="n"><a href="#{display/basename}">#{basename}/</a></td>
+            <td class="m">&nbsp;</td>
+            <td class="s">- &nbsp;</td>
+            <td class="t">Directory</td>
+          </tr>]
+          end
+
+          time_format = "%Y-%b-%d %H:%M:%S"
+          files.each do |file|
+            basename = ::File.basename(file)
+            time = ::File.mtime(file).strftime(time_format)
+            size = ::File.size(file).human_readable_filesize_format
+            mime = Tool::MIME.type_for(file)
+            file_body << %[<tr>
+            <td class="n"><a href="#{display/basename}">#{basename}</a></td>
+            <td class="m">#{time}</td>
+            <td class="s">#{size}</td>
+            <td class="t">#{mime}</td>
+          </tr>]
+          end
+
+          version = "ramaze/#{Ramaze::VERSION}"
+          wrapper % [
+            dir_body. join("\n          "),
+            file_body.join("\n          "),
+            version
+          ]
+        end
+      end
+    end
+  end
+end