ramaze 0.3.5 → 0.3.9

data/lib/ramaze/contrib/profiling.rb

@@ -0,0 +1,36 @@
+require "ruby-prof"
+
+module Ramaze
+  module Dispatcher
+    class ActionProfiler < Action
+      def self.process(path)
+        if RubyProf.running?
+          super
+        else
+          result = RubyProf.profile { super }
+          output = StringIO.new
+          printer = RubyProf::FlatPrinter.new(result)
+          options = {
+            :min_percent => Contrib::Profiling.trait[:min_percent],
+            :print_file => false
+          }
+          printer.print(output, options)
+          output.string.split("\n").each do |line|
+            Log.info(line)
+          end
+        end
+      end
+    end
+  end
+
+  module Contrib
+    class Profiling
+      trait :min_percent => 1
+
+      def self.startup
+        Dispatcher::FILTER.delete(Dispatcher::Action)
+        Dispatcher::FILTER << Dispatcher::ActionProfiler
+      end
+    end
+  end
+end

data/lib/ramaze/contrib/sequel_cache.rb

@@ -0,0 +1,92 @@
+#
+# drop-in replacement for Ramaze's built-in MemoryCache built on the Sequel.
+# to use with sessions do
+#
+#   Ramaze::Global::cache_alternative[:sessions] = Ramaze::SequelCache
+#
+# to use with everything do
+#
+#   Ramaze::Global::cache = Ramaze::SequelCache
+#
+
+class Ramaze::SequelCache
+  class Table < Sequel::Model(:ramaze_cache_t)
+    set_schema do
+      primary_key :id
+      string :key
+      string :value
+      index :key, :unique => true
+    end
+
+    ## use sequel's built-in serialize function if you like execptions: the
+    ## serialized data blows up the sql
+    ## serialize :value, :format => :marshal
+
+    transform :value => [
+      lambda{|value| Marshal.load(Base64.decode64(value))},
+      lambda{|value| Base64.encode64(Marshal.dump(value))},
+    ]
+  end
+
+  def table() Table end
+  def t() Table end
+
+  def self.[] key
+    record = Table.find :key => key
+    record ? record.value : nil
+  end
+
+  def self.[]= key, value
+    begin
+      Table.create :key => key, :value => value
+    rescue
+      Table.filter(:key => key).update :value => value
+      unless Table.find(:key => key)
+        Table.create :key => key, :value => value rescue nil
+      end
+    end
+    # ruby always returns 'value' for []= !
+  rescue
+    nil
+  end
+
+  def self.values_at *keys
+    keys.map{|key| Table[key]}
+  end
+
+  def self.delete *keys
+    keys.map do |key|
+      record = Table[key]
+      record.delete if record
+    end
+  end
+
+  def self.clear
+    Table.delete_all
+  end
+
+  def self.new
+    self
+  end
+
+  def self.to_sym
+    name.split(%r/::/).last.to_sym
+  end
+end
+
+
+
+
+if $0 == __FILE__
+  case ARGV.first
+    when /create|up/
+      Ramaze::SequelCache::Table.create_table!
+    when /drop|down/
+      Ramaze::SequelCache::Table.drop_table
+    else
+      abort "usage: ruby #{ __FILE__ } create/up | drop/down"
+  end
+else
+  Ramaze::SequelCache::Table.create_table! unless
+    Ramaze::SequelCache::Table.table_exists?
+end

data/lib/ramaze/controller.rb

@@ -13,10 +13,9 @@ module Ramaze
   # The Controller is responsible for combining and rendering actions.
 
   class Controller
-    include Ramaze::Helper
-    extend Ramaze::Helper
+    include Helper::Methods
 
-    helper :redirect, :link, :file, :flash, :cgi
+    helper :redirect, :link, :sendfile, :flash, :cgi, :partial
 
     # Whether or not to map this controller on startup automatically
 
@@ -26,27 +25,19 @@ 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 => {}
-        controller.trait :layout => {:all => nil, :deny => Set.new}
         Global.controllers << controller
         if map = controller.mapping
-          Inform.dev("mapping #{map} => #{controller}")
+          Log.dev("mapping #{map} => #{controller}")
           Global.mapping[map] ||= controller
         end
       end
@@ -56,26 +47,22 @@ module Ramaze
       # they are not assigned yet.
 
       def startup options = {}
-        Inform.dev("found Controllers: #{Global.controllers.inspect}")
+        Log.dev("found Controllers: #{Global.controllers.inspect}")
 
-        { 'Template' => Global.template_root,
-          'Public'   => Global.public_root }.each do |type, path|
-          unless File.directory?(path)
-            Inform.warn("#{type} root: #{path} doesn't exist")
-          else
-            Inform.info("#{type} root: #{File.expand_path path}")
-          end
-        end
+        check_path("Public root: '%s' doesn't exist", Global.public_root)
+        check_path("Template root: '%s' doesn't exist", Global.template_root)
 
         require 'ramaze/controller/main' if Global.mapping.empty?
 
-        Inform.debug("mapped Controllers: #{Global.mapping.inspect}")
+        Log.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)
+      def check_path(message, *paths)
+        paths.each do |path|
+          Log.warn(message % path) unless File.directory?(path)
+        end
       end
 
       # if trait[:automap] is set and controller is not in Global.mapping yet
@@ -86,7 +73,7 @@ module Ramaze
         global_mapping = Global.mapping.invert[self]
         return global_mapping if global_mapping
         if ancestral_trait[:automap]
-          name = self.to_s.gsub('Controller', '').split('::').last
+          name = self.to_s.gsub('Controller', '').gsub('::', '/')
           name == 'Main' ? '/' : "/#{name.snake_case}"
         end
       end
@@ -122,23 +109,26 @@ module Ramaze
       #  the layout-action where @content may or may not be used, returning
       #  whatever the layout returns.
 
-      def layout(meth_or_hash)
-        if meth_or_hash.respond_to?(:to_hash)
-          meth_or_hash.each do |layout_name, *actions|
-            layout_name = R(self, layout_name) if layout_name.to_s !~ /\A\//
-            actions.flatten.each do |action|
-              trait[:layout][action.to_s] = layout_name
+      def layout(*meth_or_hash)
+        if meth_or_hash.empty?
+          trait[:layout] ||= ( ancestral_trait[:layout] || {:all => nil, :deny => Set.new} ).dup
+        else
+          meth_or_hash = meth_or_hash.first
+          if meth_or_hash.respond_to?(:to_hash)
+            meth_or_hash.each do |layout_name, *actions|
+              actions.flatten.each do |action|
+                layout[action.to_s] = layout_name
+              end
             end
+          else
+            layout[:all] = meth_or_hash
           end
-        else
-          layout_name = R(self, meth_or_hash) if meth_or_hash.to_s !~ /\A\//
-          trait[:layout][:all] = layout_name || meth_or_hash
         end
       end
 
       def deny_layout(*actions)
         actions.each do |action|
-          trait[:layout][:deny] << action.to_s
+          layout[:deny] << action.to_s
         end
       end
 
@@ -146,13 +136,12 @@ module Ramaze
       # if no argument is given.
       # Runs every given path through Controller::check_path
 
-      def template_root path = nil
-        if path and path = path.to_s
-          message = "#{self}.template_root is #{path} which does not exist"
-          check_path(path, message)
-          @template_root = path
-        else
+      def template_root *args
+        if args.empty?
           @template_root
+        else
+          check_path("#{self}.template_root: '%s' doesn't exist", *args)
+          @template_root = args.flatten
         end
       end
 
@@ -163,6 +152,10 @@ module Ramaze
       #   class MainController
       #     template :index, OtherController, :list
       #     template :foo, :bar
+      #     template :bar, :file => '/absolute/path' 
+      #     template :baz, :file => 'relative/path' 
+      #     template :abc, :controller => OtherController
+      #     template :xyz, :controller => OtherController, :action => 'list'
       #
       #     def index
       #       'will use template from OtherController#list'
@@ -171,18 +164,58 @@ module Ramaze
       #     def foo
       #       'will use template from self#bar'
       #     end
+      #
+      #     def bar
+      #       'will use template from /absolute/path'
+      #     end
+      #
+      #     def baz
+      #       'will use template from relative/path'
+      #     end
+      #
+      #     def abc
+      #       'will use template from OtherController#index'
+      #     end
+      #
+      #     def xyz
+      #       'will use template from OtherController#list'
+      #     end
       #   end
 
-      def template(this, from, that = nil)
-        from, that = self, from unless that
-        trait "#{this}_template" => [from, that.to_s]
+      def template(this, *argv)
+        case argv.first
+          when Hash
+            options, *ignored = argv
+            controller = options[:controller] || options['controller']
+            action = options[:action] || options['action']
+            file = options[:file] || options['file']
+            info = {}
+            if file
+              file = file.to_s
+              unless Pathname(file).absolute?
+                root = [template_root || Global.template_root].flatten.first
+                file = File.join(root, file)
+              end
+              info[:file] = file
+            else
+              controller ||= self
+              action = (action || 'index').to_s
+              info[:controller] = controller
+              info[:action] = action
+            end
+            trait "#{this}_template" => info
+          else
+            controller, action, *ignored = argv
+            controller, action = self, controller unless action
+            trait "#{this}_template" => {:controller => controller, :action => action} 
+        end
       end
 
       def engine(name)
-        name = Ramaze::Template.const_get(name)
+        name = Template.const_get(name)
       rescue NameError => ex
-        Inform.warn ex
-        Inform.warn "Try to use passed engine directly"
+        Log.warn ex
+        Log.warn "Try to use passed engine directly"
       ensure
         trait :engine => name
       end

data/lib/ramaze/controller/error.rb

@@ -12,15 +12,20 @@ module Ramaze
     # holds the exception thrown.
 
     def error
-      error = Ramaze::Dispatcher::Error.current
+      error = Dispatcher::Error.current
       title = error.message
 
       unless Action.current.template
         response['Content-Type'] = 'text/plain'
-        return [title, "", error.backtrace].flatten.join("\n")
+        respond %(
+          #{error.message}
+            #{error.backtrace.join("\n            ")}
+
+          #{PP.pp request, '', 200}
+        ).ui
       end
 
-      backtrace_size = Ramaze::Global.backtrace_size
+      backtrace_size = Global.backtrace_size
       @backtrace = error.backtrace[0..20].map do |line|
         file, lineno, meth = *Ramaze.parse_backtrace(line)
         lines = Ramaze.caller_lines(file, lineno, backtrace_size)
@@ -31,11 +36,11 @@ module Ramaze
       # for backwards-compat with old error.zmr
       @colors = [255] * @backtrace.size
 
-      @title = CGI.escapeHTML(title)
+      @title = ::CGI.escapeHTML(title)
       @editor = (ENV['EDITOR'] || 'vim')
       title
     rescue Object => ex
-      Inform.error(ex)
+      Log.error(ex)
     end
   end
 end

data/lib/ramaze/controller/resolve.rb

@@ -3,24 +3,24 @@
 
 module Ramaze
   class Controller
-    FILTER = [ :cached, :routed, :default ] unless defined?(FILTER)
+    FILTER = [ :cached, :default ] unless defined?(FILTER)
 
     class << self
 
       # 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
+      def resolve(path, routed = false)
+        @routed = routed
+
+        FILTER.each do |filter|
+          answer = if filter.respond_to?(:call)
+                     filter.call(path)
+                   else
+                     send(filter.to_s, path)
+                   end
           return answer if answer
         end
 
@@ -35,7 +35,7 @@ module Ramaze
           if found.respond_to?(:relaxed_hash)
             return found.dup
           else
-            Inform.warn("Found faulty `#{path}' in Cache.resolved, deleting it for sanity.")
+            Log.warn("Found faulty `#{path}' in Cache.resolved, deleting it for sanity.")
             Cache.resolved.delete path
           end
         end
@@ -43,33 +43,6 @@ module Ramaze
         nil
       end
 
-      # Routing filter
-      # Loops over Route.trait[:routes] to find a matching route
-
-      def routed(path)
-        Route.trait[:routes].each do |key, val|
-          if key.is_a?(Regexp)
-            if md = path.match(key)
-              new_path = val % md.to_a[1..-1]
-              return resolve(new_path, :routed)
-            end
-
-          elsif val.respond_to?(:call)
-            if new_path = val.call(path, request)
-              return resolve(new_path, :routed)
-            end
-
-          elsif val.is_a?(String)
-            return resolve(val, :routed) if path == key
-
-          else
-            Inform.error "Invalid route #{key} => #{val}"
-          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.
@@ -91,7 +64,12 @@ module Ramaze
             action = controller.resolve_action(method, *params)
             template = action.template
 
-            valid_action = (action.method or (params.empty? && template))
+            valid_action =
+              if Action.stack.size > 0 || Global.actionless_templates
+                action.method or (params.empty? && template)
+              else
+                action.method
+              end
 
             if valid_action
               Cache.resolved[path] = action
@@ -100,6 +78,11 @@ module Ramaze
           end
         end
 
+        if !@routed and new_path = Route.resolve(path)
+          Log.dev("Routing from `#{path}' to `#{new_path}'")
+          return resolve(new_path, true)
+        end
+
         raise_no_action(first_controller, path) if first_controller
         raise_no_controller(path)
       end
@@ -109,9 +92,12 @@ module Ramaze
 
       def resolve_action(path, *parameter)
         path, parameter = path.to_s, parameter.map{|e| e.to_s}
-        if alternate_template = trait["#{path}_template"]
-          t_controller, t_path = *alternate_template
-          template = t_controller.resolve_template(t_path)
+        if info = trait["#{path}_template"]
+          template = info[:file]
+          unless template
+            controller, action = info.values_at :controller, :action
+            template = controller.resolve_template(action)
+          end
         end
 
         method, params = resolve_method(path, *parameter)
@@ -146,8 +132,11 @@ module Ramaze
       # controller.
 
       def template_paths
-        @template_root ||= Global.template_root / Global.mapping.invert[self]
-        [ @template_root ]
+        if paths = template_root
+          paths
+        else
+          template_root(Global.template_root / Global.mapping.invert[self])
+        end
       end
 
       # Based on methodname and arity, tries to find the right method on current controller.
@@ -168,14 +157,13 @@ module Ramaze
 
       # methodnames that may be used for current controller.
       def action_methods
-        exclude = Controller.trait[:exclude_action_modules]
+        ancs = ancestors.select{|ancestor|
+          ancestor <= Ramaze::Controller
+        } + Helper::LOOKUP.to_a
 
-        ancs = (ancestors - exclude).select{|a| a.is_a?(Module) }
         meths = ancs.map{|a|
           a.instance_methods(false).map{|iv| iv.to_s }
         }.flatten.uniq
-        # fix for facets/more/paramix
-        meths - ancs.map{|a| a.to_s}
       end
 
       # Generate all possible permutations for given path.