ramaze 0.1.1 → 0.1.2

data/lib/ramaze/cache/memcached.rb

@@ -11,7 +11,7 @@ module Ramaze
     # For your own usage you should use another namespace.
 
     def initialize(host = 'localhost', port = '11211', namespace = 'ramaze')
-      @cache = MemCache.new("#{host}:#{port}", :namespace => namespace)
+      @cache = MemCache.new("#{host}:#{port}", :namespace => namespace, :multithread => true)
     end
 
     # please read the documentation of memcache-client for further methods.
@@ -73,11 +73,7 @@ class MemCache
 
   class Server
     def flush_all
-      @mutex.lock if @multithread
-
       socket.write "flush_all\r\n"
-    ensure
-      @mutex.unlock if @multithread
     end
   end
 end

data/lib/ramaze/controller.rb

@@ -6,7 +6,6 @@ require 'ramaze/template'
 require 'ramaze/action'
 
 require 'ramaze/controller/resolve'
-require 'ramaze/controller/render'
 require 'ramaze/controller/error'
 
 module Ramaze
@@ -19,8 +18,6 @@ module Ramaze
 
     helper :redirect, :link, :file, :flash, :cgi
 
-    trait[:template_extensions] ||= {}
-
     # Whether or not to map this controller on startup automatically
 
     trait[:automap] ||= true
@@ -29,24 +26,33 @@ module Ramaze
 
     trait[:map] ||= nil
 
+    # Modules that are excluded from the Action lookup
+
     trait :exclude_action_modules => [Kernel, Object, PP::ObjectMixin]
 
+    # Caches patterns for the given path.
+
     trait :pattern_cache => Hash.new{|h,k| h[k] = Controller.pattern_for(k) }
 
     class << self
       include Ramaze::Helper
       extend Ramaze::Helper
 
+      # When Controller is subclassed the resulting class is placed in
+      # Global.controllers and a new trait :actions_cached is set on it.
+
       def inherited controller
         controller.trait :actions_cached => Set.new
         Global.controllers << controller
       end
 
+      # called from Ramaze.startup, adds Cache.actions and Cache.patterns, walks
+      # all controllers subclassed so far and adds them to the Global.mapping if
+      # they are not assigned yet.
+
       def startup options = {}
         Inform.debug("found Controllers: #{Global.controllers.inspect}")
 
-        Cache.add :actions, :patterns
-
         Global.controllers.each do |controller|
           if map = controller.mapping
             Inform.debug("mapping #{map} => #{controller}")
@@ -57,25 +63,37 @@ module Ramaze
         Inform.debug("mapped Controllers: #{Global.mapping.inspect}")
       end
 
+      # checks paths for existance and logs a warning if it doesn't exist yet.
+
       def check_path(path, message)
         Inform.warn(message) unless File.directory?(path)
       end
 
+      # if trait[:automap] is set and controller is not in Global.mapping yet
+      # this will build a new default mapping-point, (Main|Base|Index)* are put
+      # at '/' by default.
+
       def mapping
         global_mapping = Global.mapping.invert[self]
         return global_mapping if global_mapping
         if ancestral_trait[:automap]
           name = self.to_s.gsub('Controller', '').split('::').last
-          %w[Main Base Index].include?(name) ? '/' : "/#{name.snake_case}"
+          name == 'Main' ? '/' : "/#{name.snake_case}"
         end
       end
 
+      # Map Controller to the given syms or strings.
+
       def map(*syms)
         syms.each do |sym|
           Global.mapping[sym.to_s] = self
         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
+
       def template_root path = nil
         if path
           message = "#{self}.template_root is #{path} which does not exist"
@@ -86,33 +104,48 @@ module Ramaze
         end
       end
 
-      def public_root path = nil
-        if path
-          message = "#{self}.public_root is #{path} which does not exist"
-          check_path(path, message)
-          @public_root = path
-        else
-          @public_root
-        end
-      end
+      # This is used for template rerouting, takes action, optionally a
+      # controller and action to route to.
+      #
+      # Usage:
+      #   class MainController
+      #     template :index, OtherController, :list
+      #     template :foo, :bar
+      #
+      #     def index
+      #       'will use template from OtherController#list'
+      #     end
+      #
+      #     def foo
+      #       'will use template from self#bar'
+      #     end
+      #   end
 
       def template(this, from, that = nil)
         from, that = self, from unless that
         trait "#{this}_template" => [from, that.to_s]
       end
 
+      # Return Controller of current Action
+
       def current
-        Thread.current[:controller]
+        action = Action.current
+        action.instance || action.controller
       end
 
+      # Entering point for Dispatcher, first Controller::resolve(path) and then
+      # renders the resulting Action.
+
       def handle path
-        controller, action = *resolve(path)
-        controller.render(action)
+        action = resolve(path)
+        action.render
       end
     end
 
     private
 
+    # Simplistic render, rerouting to Controller.handle(*args)
+
     def render *args
       self.class.handle(*args)
     end

data/lib/ramaze/controller/resolve.rb

@@ -13,7 +13,10 @@ module Ramaze
       # manveru: everything further down is considered 500
 
       def resolve(path)
-        #Inform.debug("resolve_controller('#{path}')")
+        if found = Cache.resolved[path]
+          return found
+        end
+
         mapping     = Global.mapping
         controllers = Global.controllers
 
@@ -31,7 +34,7 @@ module Ramaze
 
             valid_action = (action.method or (params.empty? && action.template))
 
-            return controller, action if valid_action
+            return Cache.resolved[path] = action if valid_action
           end
         end
 
@@ -52,8 +55,11 @@ module Ramaze
           template ||= resolve_template(path)
         end
 
-        hash = {:method => method, :params => params, :template => template}
-        Action.fill(hash)
+        Action.create :path       => path,
+                      :method     => method,
+                      :params     => params,
+                      :template   => template,
+                      :controller => self
       end
 
       def resolve_template(action)
@@ -68,13 +74,8 @@ module Ramaze
       end
 
       def template_paths
-        first_path =
-          if template_root = @template_root
-            template_root
-          else
-            Global.template_root / Global.mapping.invert[self]
-          end
-        [ first_path, public_root, Global.public_root ].compact
+        @template_root ||= Global.template_root / Global.mapping.invert[self]
+        [ @template_root, Global.public_root, Global.public_proto ].compact
       end
 
       def resolve_method(name, *params)
@@ -128,17 +129,21 @@ module Ramaze
       end
 
       def extension_order
-        t_extensions = Controller.trait[:template_extensions]
+        t_extensions = Template::ENGINES
         engine = trait[:engine]
-        c_extensions = t_extensions.reject{|k,v| v != engine}.keys
-        all_extensions = t_extensions.keys
+        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
       end
 
+      # Raises Ramaze::Error::NoController
+
       def raise_no_controller(path)
         raise Ramaze::Error::NoController, "No Controller found for `#{path}'"
       end
 
+      # Raises Ramaze::Error::NoAction
+
       def raise_no_action(controller, path)
         raise Ramaze::Error::NoAction, "No Action found for `#{path}' on #{controller}"
       end

data/lib/ramaze/dispatcher.rb

@@ -14,21 +14,9 @@ require 'ramaze/dispatcher/file'
 module Ramaze
   module Dispatcher
 
-    trait :dispatch => [
-      Dispatcher::File,
-      Dispatcher::Action,
-    ]
-
-    trait :handle_error => {
-        Exception =>
-          [ STATUS_CODE["Internal Server Error"], '/error' ],
-        Ramaze::Error::NoAction =>
-          [ STATUS_CODE["Not Found"], '/error' ],
-        Ramaze::Error::NoController =>
-          [ STATUS_CODE["Not Found"], '/error' ],
-      }
-
-    Cache.add :shield
+    # requests are passed to every
+
+    FILTER = [ Dispatcher::File, Dispatcher::Action ] unless defined?(FILTER)
 
     trait :shielded => [ STATUS_CODE["Not Found"] ]
 
@@ -88,14 +76,20 @@ module Ramaze
         end
       end
 
+      # Calls .process(path) on every class in Dispatcher::FILTER until one
+      # returns something else than false/nil.
+      # Raises NoAction otherwise.
+
       def filter path
-        trait[:dispatch].each do |dispatcher|
+        FILTER.each do |dispatcher|
           result = dispatcher.process(path)
           return result if result
         end
         raise Ramaze::Error::NoAction, "No Dispatcher found for `#{path}'"
       end
 
+      # build a response, default values are from the current response.
+
       def build_response body = response.body, status = response.status, head = response.header
         set_cookie if Global.cookies
         head.each do |key, value|
@@ -107,6 +101,9 @@ module Ramaze
         return response
       end
 
+      # finalizes the session and assigns the key to the response via
+      # set_cookie.
+
       def set_cookie
         session.finalize
         hash = {:value => session.session_id, :path => '/'}

data/lib/ramaze/dispatcher/action.rb

@@ -10,7 +10,7 @@ module Ramaze
 
       # The response is passed to each filter by sending .call(response) to it.
 
-      trait :filter => [
+      FILTER = [
         # Ramaze::Tool::Localize,
         # Ramaze::Tool::Tidy
       ]
@@ -19,8 +19,7 @@ module Ramaze
         def process(path)
           body = Controller.handle(path)
           response = Dispatcher.build_response(body)
-          filter = ancestral_trait[:filter]
-          filter.inject(response){|r,f| f.call(r) }
+          FILTER.inject(response){|r,f| f.call(r) }
         end
       end
     end

data/lib/ramaze/dispatcher/error.rb

@@ -4,6 +4,12 @@
 module Ramaze
   module Dispatcher
     class Error
+      HANDLE_ERROR = {
+                          Exception => [ 500, '/error' ],
+            Ramaze::Error::NoAction => [ 404, '/error' ],
+        Ramaze::Error::NoController => [ 404, '/error' ],
+      }
+
       class << self
         trait :last_error => nil
 
@@ -11,10 +17,9 @@ module Ramaze
           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]
+          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

data/lib/ramaze/dispatcher/file.rb

@@ -11,10 +11,7 @@ module Ramaze
         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)}
+          [ Global.public_proto, Global.public_root ].flatten
         end
 
         def open_file(path)

data/lib/ramaze/error.rb

@@ -5,17 +5,17 @@ module Ramaze
 
   # The general Namespace for Ramazes Errorclasses
 
-  module Error
+  class Error < StandardError
     # No action found on Controller
-    class NoAction < StandardError; end
+    class NoAction < Error; end
 
     # No Controller found for request
-    class NoController < StandardError; end
+    class NoController < Error; end
 
     # Wrong parameter count for action
-    class WrongParameterCount < StandardError; end
+    class WrongParameterCount < Error; end
 
     # Error while transformation in template
-    class Template < StandardError; end
+    class Template < Error; end
   end
 end

data/lib/ramaze/global.rb

@@ -29,6 +29,9 @@ module Ramaze
     o "Turn on cookies for all requests.",
       :cookies => true, :cli => true
 
+    o "Compile Templates",
+      :compile => false, :cli => false
+
     o "All subclasses of Controller are collected here.",
       :controllers => Set.new
 
@@ -51,7 +54,10 @@ module Ramaze
       :port => 7000, :cli => 7000
 
     o "Specify the shadowing public directory (default in proto)",
-      :public_root => ( BASEDIR / 'proto' / 'public' )
+      :public_proto => ( BASEDIR / 'proto' / 'public' )
+
+    o "Specify the public directory of your application serving static files",
+      :public_root => File.expand_path('./public')
 
     o "Record all Request objects by assigning a filtering Proc to me.",
       :record => false

data/lib/ramaze/global/globalstruct.rb

@@ -56,7 +56,7 @@ module Ramaze
     end
 
     def ports
-      (port..(port + (spawn - 1)))
+      (port.to_i..(port.to_i + (spawn.to_i - 1)))
     end
 
     def sourcereload=(interval)
@@ -71,8 +71,6 @@ module Ramaze
       keys.map{|key| __send__(key)}
     end
 
-    private # Internal helpers
-
     def create_member key, value = nil
       Inform.warn "Create #{key}=#{value.inspect} on Global"
 

data/lib/ramaze/helper/aspect.rb

@@ -56,19 +56,17 @@ module Ramaze
       meths = instance_methods(false)
       wrap(*meths, &block)
     end
+  end
 
-    def before_process(action)
-      block = ancestral_trait[:aspects][:before][action.method]
-      before = action.controller.instance_eval(&block) if block
-      before
+  class Action
+    def before_process
+      block = controller.ancestral_trait[:aspects][:before][method]
+      instance.instance_eval(&block) if block
     end
 
-    def after_process(action)
-      block = ancestral_trait[:aspects][:after][action.method]
-      after = action.controller.instance_eval(&block) if block
-      after
+    def after_process
+      block = controller.ancestral_trait[:aspects][:after][method]
+      instance.instance_eval(&block) if block
     end
-
-    module_function :before_process, :after_process
   end
 end