ramaze 0.1.2 → 0.1.3

data/lib/proto/template/index.xhtml

@@ -7,9 +7,9 @@
     <ol>
       <li><code>template/index.xhtml</code>, which this text</li>
       <li><code>src/elements/page.rb</code>, which is the Element around this text</li>
-      <li><code>src/controllers/main.rb</code>, where you can change the header of this page and the        <a href="/notemplate">notemplate</a> action</li> 
+      <li><code>src/controllers/main.rb</code>, where you can change the header of this page and the <a href="/notemplate">notemplate</a> action</li>
       <li><code>src/model.rb</code>, which is the the persistent backend for your app</li>
     </ol>
   </p>
-  <p>You can also read the tutorial in the <code>doc/</code> directory of ramaze or browse the <a href="http://ramaze.rubyforge.org/rdoc/files/doc/README.html">rdocs</a><p> 
+  <p>You can also read the tutorial in the <code>doc/</code> directory of ramaze or browse the <a href="http://ramaze.rubyforge.org/rdoc/files/doc/README.html">rdocs</a></p>
 </Page>

data/lib/ramaze.rb

@@ -4,6 +4,7 @@
 # The main namespace for Ramaze
 module Ramaze
   BASEDIR = File.dirname(File.expand_path(__FILE__))
+  SEEED = $0.dup
   $:.unshift BASEDIR
 end
 
@@ -15,6 +16,7 @@ require 'ramaze/snippets'
 require 'ramaze/inform'
 require 'ramaze/global'
 require 'ramaze/cache'
+require 'ramaze/tool'
 
 # Startup
 require 'ramaze/controller'
@@ -42,10 +44,13 @@ module Ramaze
       Inform.info("Starting up Ramaze (Version #{VERSION})")
 
       starter = caller[0].split(':').first
-      return unless ($0 == starter or options.delete(:force))
 
-      trait[:essentials].each do |obj|
-        obj.startup(options)
+      if $0 == starter or options.delete(:force)
+        SEEED.replace(starter)
+
+        trait[:essentials].each do |obj|
+          obj.startup(options)
+        end
       end
     end
 

data/lib/ramaze/action/render.rb

@@ -22,6 +22,11 @@ module Ramaze
       end
     end
 
+    # Return the cached output of the action if it exists, otherwise do a
+    # normal Action#uncached_render and store the output in the Cache.actions.
+    # Action#cached_render is only called if Action#should_cache? returns
+    # true.
+
     def cached_render
       action_cache = Cache.actions
 
@@ -34,6 +39,9 @@ module Ramaze
       action_cache[relaxed_hash] = uncached_render
     end
 
+    # The 'normal' rendering process. Passes the Action instance to
+    # Action#engine.transform, which returns the output of the action.
+
     def uncached_render
       [ before_process,
         engine.transform(self),
@@ -41,6 +49,9 @@ module Ramaze
       ].join
     end
 
+    # return true if the action is flagged for caching. Called by
+    # Action#render.
+
     def should_cache?
       ctrait = controller.trait
       actions_cached = ctrait[:actions_cached]

data/lib/ramaze/adapter/base.rb

@@ -27,22 +27,26 @@ module Ramaze
           Inform.debug("Stopping #{self.class}")
         end
 
+        # This is called by Rack with the usual env, subsequently calls
+        # ::respond with it.
+        #
+        # The method itself acts just as a wrapper for benchmarking and then
+        # calls .finish on the current response after ::respond has finished.
+
         def call(env)
           if Ramaze::Global.benchmarking
-            time = Benchmark.measure{ respond env }
+            time = Benchmark.measure{ respond(env) }
             Inform.debug("request took #{time.real}s")
           else
             respond env
           end
 
-          finish
+          Thread.current[:response].finish
         end
 
-        def finish
-          response = Thread.current[:response]
-
-          response.finish
-        end
+        # Initializes Request with env and an empty Response. Records the
+        # request into Ramaze::Record if Global.record is true.
+        # Then goes on and calls Dispatcher::handle with request and response.
 
         def respond env
           request, response = Request.new(env), Response.new

data/lib/ramaze/cache.rb

@@ -14,18 +14,29 @@ module Ramaze
     include Enumerable
     CACHES = {} unless defined?(CACHES)
 
+    attr_accessor :cache
+
     class << self
 
+      # Initializes the Cache for the general caches Ramaze uses.
+      # Cache#startup is called by Ramaze#startup, when initializing the
+      # Ramaze.trait(:essentials).
+
       def startup(options)
         Cache.add :compiled, :actions, :patterns, :resolved, :shield
       end
 
       # This will define a method to access a new cache directly over
-      # sinleton-methods on Cache
+      # singleton-methods on Cache.
+      #---
+      # The @cache_name is internally used for caches which do not save
+      # different caches in different namespaces, for example memcached.
+      #+++
 
       def add *keys
         keys.each do |key|
           CACHES[key] = new
+          CACHES[key].instance_variable_set("@cache_name", key)
           self.class.class_eval do
             define_method(key){ CACHES[key] }
           end
@@ -35,30 +46,34 @@ module Ramaze
 
     end
 
+    # Initializes the cache, defined by Global.cache
+
     def initialize(cache = Global.cache)
       @cache = cache.new
     end
 
     def [](key)
-      @cache[key.to_s]
+      @cache["#{@cache_name}:#{key}"]
     end
 
     def []=(key, value)
-      @cache[key.to_s] = 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(arg.to_s)
+        @cache.delete("#{@cache_name}:#{arg}")
       end
     end
 
-    def method_missing(meth, *args, &block)
-      if @cache.respond_to?(meth)
-        @cache.send(meth, *args, &block)
-      else
-        super
-      end
+    def clear
+      @cache.clear
+    end
+
+    def values_at(*args)
+      @cache.values_at(*args.map {|key| "#{@cache_name}:#{key}" })
     end
   end
 end

data/lib/ramaze/cache/memcached.rb

@@ -3,6 +3,10 @@
 require 'memcache'
 
 module Ramaze
+
+  # Cache based on the memcache library which utilizes the memcache-daemon to
+  # store key/value pairs in namespaces.
+
   class MemcachedCache
 
     # Create a new MemcachedCache with host, port and a namespace that defaults
@@ -10,7 +14,8 @@ module Ramaze
     #
     # For your own usage you should use another namespace.
 
-    def initialize(host = 'localhost', port = '11211', namespace = 'ramaze')
+    def initialize(host = 'localhost', port = '11211', namespace = SEEED)
+      namespace = Digest::SHA1.hexdigest(namespace)[0..16]
       @cache = MemCache.new("#{host}:#{port}", :namespace => namespace, :multithread => true)
     end
 
@@ -63,6 +68,10 @@ 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
 
@@ -71,7 +80,13 @@ class MemCache
     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"
     end

data/lib/ramaze/cache/yaml_store.rb

@@ -3,6 +3,10 @@
 require 'yaml/store'
 
 module Ramaze
+
+  # Cache based on _whys YAML::Store, which uses PStore to serialize objects
+  # as YAML in a thread-safe manner.
+
   class YAMLStoreCache
 
     attr_accessor :file
@@ -23,16 +27,22 @@ module Ramaze
       end
     end
 
+    # Loads @file into memory via YAML::load_file
+
     def underlying_yaml
       YAML.load_file(@file)
     end
 
+    # clears the YAML::Store based cache, by emptying the YAML file.
+
     def clear
       transaction do |y|
         File.open(@file, 'w+'){|f| f.puts({}.to_yaml)}
       end
     end
 
+    # Deletes the key from YAML::Store based cache.
+
     def delete(key)
       transaction do |y|
         y.delete(key)

data/lib/ramaze/controller.rb

@@ -60,7 +60,11 @@ module Ramaze
           end
         end
 
-        Inform.debug("mapped Controllers: #{Global.mapping.inspect}")
+        if Global.mapping.empty?
+          Inform.warn("No Controllers mapped, will serve /public only.")
+        else
+          Inform.debug("mapped Controllers: #{Global.mapping.inspect}")
+        end
       end
 
       # checks paths for existance and logs a warning if it doesn't exist yet.
@@ -70,7 +74,7 @@ module Ramaze
       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
+      # this will build a new default mapping-point, MainController is put
       # at '/' by default.
 
       def mapping
@@ -90,6 +94,12 @@ module Ramaze
         end
       end
 
+      # Returns the Controller at a mapped path.
+
+      def at(mapping)
+        Global.mapping[mapping.to_s]
+      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

data/lib/ramaze/controller/error.rb

@@ -8,14 +8,20 @@ module Ramaze
     #
     # Error-pages can be in whatever the templating-engine of your controller
     # is set to.
-    #   Thread.current[:exception]
+    #   Ramaze::Dispatcher::Error.current
     # holds the exception thrown.
 
     def error
-      error = Thread.current[:exception]
-      @backtrace = error.backtrace[0..20]
+      error = Ramaze::Dispatcher::Error.current
       title = error.message
 
+      unless Action.current.template
+        response['Content-Type'] = 'text/plain'
+        return [title, "", error.backtrace].flatten.join("\n")
+      end
+
+      @backtrace = error.backtrace[0..20]
+
       @colors = []
       min = 200
       max = 255

data/lib/ramaze/controller/resolve.rb

@@ -14,7 +14,12 @@ module Ramaze
 
       def resolve(path)
         if found = Cache.resolved[path]
-          return found
+          if found.respond_to?(:relaxed_hash)
+            return found
+          else
+            Inform.warn("Found faulty `#{path}' in Cache.resolved, deleting it for sanity.")
+            Cache.resolved.delete path
+          end
         end
 
         mapping     = Global.mapping
@@ -32,7 +37,7 @@ module Ramaze
             action = controller.resolve_action(method, *params)
             template = action.template
 
-            valid_action = (action.method or (params.empty? && action.template))
+            valid_action = (action.method or (params.empty? && template))
 
             return Cache.resolved[path] = action if valid_action
           end
@@ -75,7 +80,7 @@ module Ramaze
 
       def template_paths
         @template_root ||= Global.template_root / Global.mapping.invert[self]
-        [ @template_root, Global.public_root, Global.public_proto ].compact
+        [ @template_root, Global.public_root ].compact
       end
 
       def resolve_method(name, *params)
@@ -100,28 +105,24 @@ module Ramaze
       def pattern_for(path)
         atoms = path.split('/').grep(/\S/)
         atoms.unshift('')
-        patterns, joiners = [], ['/']
+        patterns, joiner = [], '/'
 
         atoms.size.times do |enum|
           enum += 1
-          joiners << '__' if enum == 3
-
-          joiners.each do |joinus|
-            pattern = atoms.dup
+          pattern = atoms.dup
 
-            controller = pattern[0, enum].join(joinus)
-            controller.gsub!(/^__/, '/')
-            controller = "/" if controller == ""
+          controller = pattern[0, enum].join(joiner)
+          controller.gsub!(/^__/, '/')
+          controller = "/" if controller == ""
 
-            pattern = pattern[enum..-1]
-            args, temp = [], []
+          pattern = pattern[enum..-1]
+          args, temp = [], []
 
-            patterns << [controller, 'index', atoms[enum..-1]]
+          patterns << [controller, 'index', atoms[enum..-1]]
 
-            until pattern.empty?
-              args << pattern.shift
-              patterns << [controller, args.join( '__' ), pattern.dup]
-            end
+          until pattern.empty?
+            args << pattern.shift
+            patterns << [controller, args.join( '__' ), pattern.dup]
           end
         end
 
@@ -145,6 +146,7 @@ module Ramaze
       # Raises Ramaze::Error::NoAction
 
       def raise_no_action(controller, path)
+        Thread.current[:failed_controller] = controller
         raise Ramaze::Error::NoAction, "No Action found for `#{path}' on #{controller}"
       end
     end

data/lib/ramaze/dispatcher.rb

@@ -12,6 +12,10 @@ require 'ramaze/dispatcher/error'
 require 'ramaze/dispatcher/file'
 
 module Ramaze
+
+  # The Dispatcher receives requests from adapters and sets up the proper environment
+  # to process them and respond.
+
   module Dispatcher
 
     # requests are passed to every
@@ -35,7 +39,7 @@ module Ramaze
           dispatch(path)
         end
       rescue Object => error
-        Dispatcher::Error.process(error)
+        Dispatcher::Error.process(error, :path => path, :request => request)
       end
 
       def dispatch(path)
@@ -78,14 +82,19 @@ module Ramaze
 
       # Calls .process(path) on every class in Dispatcher::FILTER until one
       # returns something else than false/nil.
-      # Raises NoAction otherwise.
 
       def filter path
+        result = nil
         FILTER.each do |dispatcher|
           result = dispatcher.process(path)
-          return result if result
+          return result if result and not result.respond_to?(:exception)
         end
-        raise Ramaze::Error::NoAction, "No Dispatcher found for `#{path}'"
+
+        meta = {
+          :path => path,
+          :controller => Thread.current[:failed_controller]
+        }
+        Dispatcher::Error.process(result, meta)
       end
 
       # build a response, default values are from the current response.