ramaze 0.1.2 → 0.1.3

data/lib/ramaze/dispatcher/action.rb

@@ -1,9 +1,6 @@
 #          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
@@ -16,10 +13,17 @@ module Ramaze
       ]
 
       class << self
+
+        # 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)
           body = Controller.handle(path)
           response = Dispatcher.build_response(body)
           FILTER.inject(response){|r,f| f.call(r) }
+        rescue Ramaze::Error => ex
+          ex
         end
       end
     end

data/lib/ramaze/dispatcher/error.rb

@@ -3,6 +3,13 @@
 
 module Ramaze
   module Dispatcher
+
+    # Last resort dispatcher, tries to recover as much information as possible
+    # from the past request and takes the appropiate actions.
+    #
+    # You can configure it over the HANDLE_ERROR constant or by defining error
+    # actions in your controllers.
+
     class Error
       HANDLE_ERROR = {
                           Exception => [ 500, '/error' ],
@@ -13,13 +20,23 @@ module Ramaze
       class << self
         trait :last_error => nil
 
-        def process error
+        def process(error, metainfo = {})
           log_error(error)
 
           Thread.current[:exception] = error
 
           key = error.class.ancestors.find{|a| HANDLE_ERROR[a]}
           status, path = *HANDLE_ERROR[key || Exception]
+          status ||= 500
+
+          if controller = metainfo[:controller]
+            begin
+              action = Controller.resolve(controller.mapping + path)
+              return Dispatcher.build_response(action.render, status)
+            rescue Ramaze::Error
+              Inform.debug("No custom error page found on #{controller}, going to #{path}")
+            end
+          end
 
           unless error.message =~ %r(`#{path.split('/').last}')
             Response.current.status = status
@@ -29,7 +46,7 @@ module Ramaze
           Dispatcher.build_response(error.message, status)
         rescue Object => ex
           Inform.error(ex)
-          Dispatcher.build_response(ex.message, status || 500)
+          Dispatcher.build_response(ex.message, status)
         end
 
         def log_error error
@@ -42,6 +59,11 @@ module Ramaze
             Inform.error(error)
           end
         end
+
+        def current
+          Thread.current[:exception]
+        end
+
       end
     end
   end

data/lib/ramaze/dispatcher/file.rb

@@ -3,22 +3,28 @@
 
 module Ramaze
   module Dispatcher
+
+    # First of the dispatchers, looks up the public path and serves the
+    # file if found.
+
     class File
       class << self
+
+        # 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)
           Dispatcher.build_response(file, Ramaze::STATUS_CODE['OK'])
         end
 
-        def lookup_paths
-          [ Global.public_proto, Global.public_root ].flatten
-        end
+        # returns file-handle with the open file on success, setting the
+        # Content-Type as found in Tool::MIME
 
         def open_file(path)
-          paths = lookup_paths.map{|pa| pa/path}
-          file = paths.find{|way| ::File.file?(way)}
+          file = Global.public_root/path
 
-          if file
+          if ::File.file?(file)
             response = Response.current
             response['Content-Type'] = Tool::MIME.type_for(file)
             Inform.debug("Serving static: #{file}")

data/lib/ramaze/global.rb

@@ -53,9 +53,6 @@ module Ramaze
     o "Specify port",
       :port => 7000, :cli => 7000
 
-    o "Specify the shadowing public directory (default in proto)",
-      :public_proto => ( BASEDIR / 'proto' / 'public' )
-
     o "Specify the public directory of your application serving static files",
       :public_root => File.expand_path('./public')
 

data/lib/ramaze/global/dsl.rb

@@ -6,12 +6,21 @@ module Ramaze
   OPTIONS     = {}
   CLI_OPTIONS = []
 
+  # DSL for specifying Globap options before initializing Global
+
   module GlobalDSL
     class << self
+
+      # The method that takes the block containing the DSL, used like in
+      # lib/ramaze/global.rb
+
       def option_dsl(&block)
         instance_eval(&block)
       end
 
+      # Takes a doc-string and then the option as hash, another :cli key can
+      # be given that will expose this option via the bin/ramaze.
+
       def o(doc, options = {})
         cli_given = options.has_key?(:cli)
         cli = options.delete(:cli)

data/lib/ramaze/global/globalstruct.rb

@@ -2,7 +2,13 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
-  class GlobalStruct < Struct.new('Global', *OPTIONS.keys)
+  unless defined?(GlobalStruct) # prevent problems for SourceReload
+    class GlobalStruct < Struct.new('Global', *OPTIONS.keys)
+    end
+  end
+
+  class GlobalStruct
+
     ADAPTER_ALIAS = {
       :webrick => :WEBrick,
       :mongrel => :Mongrel,

data/lib/ramaze/helper/aspect.rb

@@ -60,12 +60,14 @@ module Ramaze
 
   class Action
     def before_process
-      block = controller.ancestral_trait[:aspects][:before][method]
+      return unless aspects = controller.ancestral_trait[:aspects]
+      block = aspects[:before][method]
       instance.instance_eval(&block) if block
     end
 
     def after_process
-      block = controller.ancestral_trait[:aspects][:after][method]
+      return unless aspects = controller.ancestral_trait[:aspects]
+      block = aspects[:after][method]
       instance.instance_eval(&block) if block
     end
   end

data/lib/ramaze/helper/cgi.rb

@@ -27,13 +27,13 @@ module Ramaze
     end
 
     # shortcut for GCI.unescapeHTML
-    
+
     def html_unescape(string)
       CGI.unescapeHTML(string)
     end
 
     # one-letter versions help in case like #{h foo.inspect}
-    # ERb/ERuby/Rails compatible 
+    # ERb/ERuby/Rails compatible
     alias h html_escape
     alias u url_encode
 

data/lib/ramaze/helper/file.rb

@@ -2,6 +2,9 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
+
+  # Helper for quickly push out files with the proper mimetype.
+
   module FileHelper
     private
 

data/lib/ramaze/helper/link.rb

@@ -79,5 +79,25 @@ module Ramaze
     def Rs(*atoms)
       R(Controller.current, *atoms)
     end
+
+    # Give it a path with character to split at and one to join the crumbs with.
+    # It will generate a list of links that act as pointers to previous pages on
+    # this path.
+    #
+    # Example:
+    #   breadcrumbs('/path/to/somewhere')
+    #
+    #   # results in this, newlines added for readability:
+    #
+    #   <a href="/path">path</a>/
+    #   <a href="/path/to">to</a>/
+    #   <a href="/path/to/somewhere">somewhere</a>
+
+    def breadcrumbs(path, split = '/', join = '/')
+      atoms = path.split(split).reject{|a| a.empty?}
+      crumbs = atoms.inject([]){|s,v| s << [s.last,v]}
+      bread = crumbs.map{|a| A(a[-1], :href=>(a*'/'))}
+      bread.join(join)
+    end
   end
 end

data/lib/ramaze/helper/markaby.rb

@@ -2,6 +2,9 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
+
+  # Allows you to use some shortcuts for markaby in your Controller.
+
   module MarkabyHelper
     private
 

data/lib/ramaze/helper/pager.rb

@@ -111,7 +111,7 @@ class Pager
 
   # Return the index of the previous page.
 
-  def previous_page
+  def prev_page
     [@page - 1, 1].max
   end
 
@@ -121,17 +121,10 @@ class Pager
     [@page + 1, @page_count].min
   end
 
-  # A set of helpers to create links to common pages.
-
-  for target in [:first, :last, :previous, :next]
-    eval %{
-      def link_#{target}_page
-        target_uri(#{target}_page)
-      end
-      alias_method :#{target}_page_uri, :link_#{target}_page
-      alias_method :#{target}_page_href, :link_#{target}_page
-    }
-  end
+  def link_first_page; target_uri(first_page); end
+  def link_last_page; target_uri(last_page); end
+  def link_prev_page; target_uri(prev_page); end
+  def link_next_page; target_uri(next_page); end
 
   # Iterator
 
@@ -208,15 +201,15 @@ class Pager
 
     unless first_page?
       nav << %{
-        <div class="first"><a href="#{first_page_href}">First</a></div>
-        <div class="previous"><a href="#{previous_page_href}">Previous</a></div>
+        <div class="first"><a href="#{link_first_page}">First</a></div>
+        <div class="previous"><a href="#{link_prev_page}">Previous</a></div>
       }
     end
 
     unless last_page?
       nav << %{
-        <div class="last"><a href="#{last_page_href}">Last</a></div>
-        <div class="next"><a href="#{next_page_href}">Next</a></div>
+        <div class="last"><a href="#{link_last_page}">Last</a></div>
+        <div class="next"><a href="#{link_next_page}">Next</a></div>
       }
     end
 
@@ -249,7 +242,7 @@ private
 
   def target_uri(page)
     params = Request.current.params.dup.update(@key => page)
-    Rs(Controller.current.action.method, params)
+    Rs(Action.current.method, params)
   end
 
 end

data/lib/ramaze/helper/partial.rb

@@ -14,15 +14,21 @@ module Ramaze
 
     def render_partial(url, options = {})
       saved = {}
-      options.keys.each {|x| saved[x] = request.params[x] }
+      options.keys.each {|x| saved[x] = Request.current.params[x] }
+      saved_action = Thread.current[:action]
 
-      request.params.update(options)
+      Request.current.params.update(options)
 
       Controller.handle(url)
     ensure
-      options.keys.each {|x| request.params[x] = saved[x] }
+      Thread.current[:action] = saved_action
+      options.keys.each {|x| Request.current.params[x] = saved[x] }
     end
 
+    # Generate from a filename in template_root of the given (or current)
+    # controller a new action.
+    # Any option you don't pass is instead taken from Action.current
+
     def render_template(file, options = {})
       current = Action.current
       options[:binding]     ||= current.binding

data/lib/ramaze/inform/analogger.rb

@@ -5,17 +5,31 @@ require 'swiftcore/Analogger/Client'
 
 module Ramaze
 
+  # Informer for the Swiftcore Analogger logging system.
+  #
+  # You can find it at http://analogger.swiftcore.org and install with
+  # gem install analogger
+
   class Analogger < ::Swiftcore::Analogger::Client
     include Informing
 
+    # identifier for your application
     trait :name => 'walrus'
+
+    # Host analogger runs on
     trait :host => '127.0.0.1'
+
+    # Port analogger runs on
     trait :port => 6766
 
+    # Create a new instance, parameters default to the traits.
+
     def initialize(name = class_trait[:name], host = class_trait[:host], port = class_trait[:port])
       super
     end
 
+    # integration to Informing
+
     def inform(tag, *args)
       log(tag, args.join("\n"))
     end

data/lib/ramaze/inform/growl.rb

@@ -4,6 +4,9 @@
 require 'ruby-growl'
 
 module Ramaze
+
+  # Informer for the growl notification system on OSX.
+
   class Growl < ::Growl
 
     trait :defaults => {
@@ -14,11 +17,15 @@ module Ramaze
       :default_notifies => %w[error warn info]
     }
 
+    # Takes the options from the default trait for merging.
+
     def initialize(options = {})
       options = class_trait[:defaults].merge(options).values_at(:host, :name, :all_notifies, :default_notifies, :password)
       super(*options)
     end
 
+    # integration to Informing
+
     def inform(tag, *args)
       notify(tag.to_s, Time.now.strftime("%X"), args.join("\n")[0..100])
     rescue Errno::EMSGSIZE

data/lib/ramaze/inform/hub.rb

@@ -4,12 +4,19 @@
 require 'set'
 
 module Ramaze
+
+  # Bundles different informer instances and sends incoming messages to each.
+  # This is the default with Informer as only member.
+
   class LogHub
     include Informing
 
     attr_accessor :loggers
     attr_accessor :ignored_tags
 
+    # Takes a list of instances or classes (which will be initialized) and that
+    # are added to @loggers. All messages are then sent to each member.
+
     def initialize(*loggers)
       @loggers = loggers
       @ignored_tags = Set.new
@@ -21,6 +28,8 @@ module Ramaze
       @loggers.compact!
     end
 
+    # integration to Informing
+
     def inform(tag, *args)
       return if @ignored_tags.include?(tag)
       @loggers.each do |logger|

data/lib/ramaze/inform/informer.rb

@@ -2,10 +2,14 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
+
+  # A minimal logger for Ramaze, supports files, CLI, colors and some
+  # customization.
+
   class Informer
     include Informing
 
-    attr_accessor :out, :colorize
+    attr_accessor :out, :colorize, :log_levels
 
     # Should Ramaze try to use colors?
     trait :colorize => true
@@ -24,7 +28,7 @@ module Ramaze
       :error => :red,
     }
 
-    def initialize(out = $stdout)
+    def initialize(out = $stdout, log_levels = [:debug, :error, :info, :warn])
       @colorize = false
 
       @out =
@@ -46,6 +50,8 @@ module Ramaze
       if @out.respond_to?(:tty?) and class_trait[:colorize]
         @colorize = @out.tty?
       end
+
+      @log_levels = log_levels
     end
 
     def shutdown
@@ -56,7 +62,7 @@ module Ramaze
     end
 
     def inform tag, *messages
-      return if closed?
+      return if closed? || !@log_levels.include?(tag)
       messages.flatten!
 
       prefix = tag.to_s.upcase.ljust(5)