ramaze 0.3.9.1 → 2008.06

data/lib/ramaze/contrib/rest.rb

@@ -0,0 +1,14 @@
+Ramaze::Route['REST dispatch'] = lambda{|path, request|
+  case request.request_method
+  when 'GET'
+    path << 'show/'
+  when 'POST'
+    path << 'create/'
+  when 'PUT'
+    path << 'update/'
+  when 'DELETE'
+    path << 'destroy/'
+  else
+    path
+  end
+}

data/lib/ramaze/controller.rb

@@ -50,7 +50,7 @@ module Ramaze
         Log.dev("found Controllers: #{Global.controllers.inspect}")
 
         check_path("Public root: '%s' doesn't exist", Global.public_root)
-        check_path("Template root: '%s' doesn't exist", Global.template_root)
+        check_path("View root: '%s' doesn't exist", Global.view_root)
 
         require 'ramaze/controller/main' if Global.mapping.empty?
 
@@ -72,8 +72,8 @@ module Ramaze
       def mapping
         global_mapping = Global.mapping.invert[self]
         return global_mapping if global_mapping
-        if ancestral_trait[:automap]
-          name = self.to_s.gsub('Controller', '').gsub('::', '/')
+        if ancestral_trait[:automap] && self.to_s !~ /#<Class:/
+          name = self.to_s.gsub('Controller', '').gsub('::', '/').clone
           name == 'Main' ? '/' : "/#{name.snake_case}"
         end
       end
@@ -126,25 +126,43 @@ module Ramaze
         end
       end
 
+      # Deny layout for passed names of actions.
+      # Name should be name of the method or template without extension, as
+      # String or Symbol
+      #
+      # Usage:
+      #   class MainController < Ramaze::Controller
+      #     deny_layout :atom
+      #
+      #     def atom
+      #       "I won't have layout"
+      #     end
+      #   end
+
       def deny_layout(*actions)
         actions.each do |action|
           layout[:deny] << action.to_s
         end
       end
 
-      # Define a template_root for Controller, returns the current template_root
+      # Define a view_root for Controller, returns the current view_root
       # if no argument is given.
       # Runs every given path through Controller::check_path
 
-      def template_root *args
+      def view_root *args
         if args.empty?
-          @template_root
+          @view_root
         else
-          check_path("#{self}.template_root: '%s' doesn't exist", *args)
-          @template_root = args.flatten
+          check_path("#{self}.view_root: '%s' doesn't exist", *args)
+          @view_root = args.flatten
         end
       end
 
+      def template_root(*args)
+        Ramaze.deprecated("Controller::template_root", "Controller::view_root")
+        view_root(*args)
+      end
+
       # This is used for template rerouting, takes action, optionally a
       # controller and action to route to.
       #
@@ -152,8 +170,8 @@ module Ramaze
       #   class MainController
       #     template :index, OtherController, :list
       #     template :foo, :bar
-      #     template :bar, :file => '/absolute/path' 
-      #     template :baz, :file => 'relative/path' 
+      #     template :bar, :file => '/absolute/path'
+      #     template :baz, :file => 'relative/path'
       #     template :abc, :controller => OtherController
       #     template :xyz, :controller => OtherController, :action => 'list'
       #
@@ -193,7 +211,7 @@ module Ramaze
             if file
               file = file.to_s
               unless Pathname(file).absolute?
-                root = [template_root || Global.template_root].flatten.first
+                root = [view_root || Global.view_root].flatten.first
                 file = File.join(root, file)
               end
               info[:file] = file
@@ -207,10 +225,19 @@ module Ramaze
           else
             controller, action, *ignored = argv
             controller, action = self, controller unless action
-            trait "#{this}_template" => {:controller => controller, :action => action} 
+            trait "#{this}_template" => {:controller => controller, :action => action}
         end
       end
 
+      # This is a method to specify the templating engine for your controller.
+      # It basically just is sugar for:
+      #   trait :engine => Haml
+      #
+      # Usage:
+      #   class MainController < Ramaze::Controller
+      #     engine :Haml
+      #   end
+
       def engine(name)
         name = Template.const_get(name)
       rescue NameError => ex
@@ -235,6 +262,12 @@ module Ramaze
         Thread.current[:controller] = action.controller
         action.render
       end
+
+      def relevant_ancestors(parent = Ramaze::Controller)
+        ancestors.select do |anc|
+          anc.ancestors.include?(parent)
+        end
+      end
     end
 
     private

data/lib/ramaze/controller/error.rb

@@ -26,18 +26,18 @@ module Ramaze
       end
 
       backtrace_size = Global.backtrace_size
-      @backtrace = error.backtrace[0..20].map do |line|
+      @backtrace = error.backtrace[0..20].map{|line|
         file, lineno, meth = *Ramaze.parse_backtrace(line)
         lines = Ramaze.caller_lines(file, lineno, backtrace_size)
 
         [ lines, lines.object_id.abs, file, lineno, meth ]
-      end
+      }
 
       # for backwards-compat with old error.zmr
       @colors = [255] * @backtrace.size
 
-      @title = ::CGI.escapeHTML(title)
-      @editor = (ENV['EDITOR'] || 'vim')
+      @title = h(title)
+      @editor = ENV['EDITOR'] || 'vim'
       title
     rescue Object => ex
       Log.error(ex)

data/lib/ramaze/controller/resolve.rb

@@ -3,7 +3,10 @@
 
 module Ramaze
   class Controller
-    FILTER = [ :cached, :default ] unless defined?(FILTER)
+    # TODO:
+    #   * fix caching, see todos below
+    #     FILTER = [ :cached, :default ] unless defined?(FILTER)
+    FILTER = [ :default ] unless defined?(FILTER)
 
     class << self
 
@@ -54,14 +57,21 @@ module Ramaze
 
         raise_no_controller(path) if controllers.empty? or mapping.empty?
 
-        patterns = Cache.patterns[path] ||= pattern_for(path)
+        # TODO:
+        #   * following code is dangerous (DoS):
+        #     patterns = Cache.patterns[path] ||= pattern_for(path)
+
         first_controller = nil
 
-        patterns.each do |controller, method, params|
+        # Look through the possible ways of interpreting the path until we find
+        # one that matches an existing controller action.
+        patterns_for(path) do |controller, method, params|
           if controller = mapping[controller]
             first_controller ||= controller
 
             action = controller.resolve_action(method, *params)
+            next unless action
+
             template = action.template
 
             valid_action =
@@ -72,8 +82,10 @@ module Ramaze
               end
 
             if valid_action
-              Cache.resolved[path] = action
-              return action.dup
+              # TODO:
+              #   * dangerous as well
+              #     Cache.resolved[path] = action
+              return action
             end
           end
         end
@@ -106,11 +118,14 @@ module Ramaze
           template ||= resolve_template(path)
         end
 
-        Action.create :path       => path,
-                      :method     => method,
-                      :params     => params,
-                      :template   => template,
-                      :controller => self
+        action =
+          Action.create :path       => path,
+                        :method     => method,
+                        :params     => params,
+                        :template   => template,
+                        :controller => self
+        return false unless action.valid_rest?
+        action
       end
 
       # Search the #template_paths for a fitting template for path.
@@ -128,14 +143,14 @@ module Ramaze
       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
+      # Usually this is composed of Global.view_root and the mapping of the
       # controller.
 
       def template_paths
-        if paths = template_root
+        if paths = view_root
           paths
         else
-          template_root(Global.template_root / Global.mapping.invert[self])
+          view_root(Global.view_root / Global.mapping.invert[self])
         end
       end
 
@@ -151,15 +166,15 @@ module Ramaze
         return nil, []
       end
 
+      # List or create a list of action methods to be cached
+
       def cached_action_methods
         Cache.action_methods[self] ||= action_methods
       end
 
       # methodnames that may be used for current controller.
       def action_methods
-        ancs = ancestors.select{|ancestor|
-          ancestor <= Ramaze::Controller
-        } + Helper::LOOKUP.to_a
+        ancs = relevant_ancestors + Helper::LOOKUP.to_a
 
         ancs.reverse.inject [] do |meths, anc|
           meths +
@@ -168,34 +183,33 @@ module Ramaze
         end
       end
 
-      # Generate all possible permutations for given path.
-      def pattern_for(path)
-        atoms = path.to_s.split('/').grep(/\S/)
-        atoms.unshift('')
-        patterns, joiner = [], '/'
-
-        atoms.size.times do |enum|
-          enum += 1
-          pattern = atoms.dup
-
-          controller = pattern[0, enum].join(joiner)
-          controller.gsub!(/^__/, '/')
-          controller = "/" if controller == ""
-
-          pattern = pattern[enum..-1]
-          args, temp = [], []
-
-          patterns << [controller, 'index', atoms[enum..-1]]
-
-          until pattern.empty?
-            args << pattern.shift
-            joined = args.join('__')
-            patterns << [controller, joined, pattern.dup]
-            patterns << [controller, "#{joined}__index", pattern.dup]
+      # Iterator that yields potential ways in which a given path could be mapped
+      # to controller, action and params. It produces them in strict order, with
+      # longest controller path favoured, then longest action path.
+
+      def patterns_for path
+        # Split into fragments, and remove empty ones (which split may have output).
+        # The to_s is vital as sometimes we are passed an array.
+        fragments = path.to_s.split '/'
+        fragments.delete ''
+
+        # Work through all the possible splits of controller and 'the rest' (action
+        # + params) starting with longest possible controller.
+        fragments.length.downto(0) do |ca_split|
+          controller = '/' + fragments[0...ca_split].join('/')
+
+          # Work on the remaining portion, generating all the action/params splits.
+          fragments.length.downto(ca_split) do |ap_split|
+            action = fragments[ca_split...ap_split].join '__'
+            params = fragments[ap_split..-1]
+            if action.empty?
+              yield controller, 'index', params
+            else
+              yield controller, "#{action}__index", params
+              yield controller, action, params
+            end
           end
         end
-
-        patterns.reverse!
       end
 
       # Uses custom defined engines and all available engines and throws it
@@ -213,6 +227,11 @@ module Ramaze
         all_extensions
       end
 
+      # Raises Ramaze::Error::NoFilter
+      # TODO:
+      #   * is this called at all for anybody?
+      #     I think everybody does have filters.
+
       def raise_no_filter(path)
         raise Ramaze::Error::NoFilter, "No Filter found for `#{path}'"
       end

data/lib/ramaze/current.rb

@@ -44,7 +44,7 @@ module Ramaze
           begin
             before.call
           rescue Object => e
-            Ramaze::Log.error e 
+            Ramaze::Log.error e
             raise
           end
         end
@@ -60,7 +60,7 @@ module Ramaze
           begin
             after.call
           rescue Object => e
-            Ramaze::Log.error e 
+            Ramaze::Log.error e
             raise
           end
         end

data/lib/ramaze/current/request.rb

@@ -107,7 +107,14 @@ module Ramaze
       def params
         return {} if put?
         return @ramaze_params if @ramaze_params
-        @rack_params ||= rack_params
+
+        begin
+          @rack_params ||= rack_params
+        rescue EOFError => ex
+          @rack_params = {}
+          Log.error(ex)
+        end
+
         @ramaze_params = {}
 
         @rack_params.each do |key, value|
@@ -122,7 +129,13 @@ module Ramaze
               if i + 1 >= keys.size
                 ref[k] = value
               else
-                ref = ref[k] ||= {}
+                # in case the value is a string we cannot let it be ref next
+                # time, so throw it away
+                if ref[k].is_a?(String)
+                  ref = ref[k] = {}
+                else
+                  ref = ref[k] ||= {}
+                end
               end
             end
           else
@@ -177,5 +190,15 @@ module Ramaze
       keys = keys.map{|k| k.to_s }
       params.reject{|k,v| not keys.include?(k) }
     end
+
+    def domain(path = '/')
+      scheme = env['rack.url_scheme'] || 'http'
+      host = env['HTTP_HOST']
+      URI("#{scheme}://#{host}#{path}")
+    end
+
+    def locales
+      env['HTTP_ACCEPT_LANGUAGE'].to_s.split(/(?:,|;q=[\d.,]+)/)
+    end
   end
 end

data/lib/ramaze/current/response.rb

@@ -4,9 +4,17 @@
 module Ramaze
   class Response < Rack::Response
     class << self
+      # Alias for Current::response
       def current() Current.response end
     end
 
+    def initialize(body = [], status = 200, header = {}, &block)
+      header['Content-Type'] ||= Global.content_type
+      header['Accept-Charset'] = Global.accept_charset if Global.accept_charset
+      super
+    end
+
+    # Build/replace this responses data
     def build(body = body, status = status, header = header)
       header.each do |key, value|
         self[key] = value

data/lib/ramaze/current/session.rb

@@ -1,10 +1,10 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-if RUBY_VERSION >= "1.9.0"
-  require 'digest/sha1'
-else
+begin
   require 'digest/sha2'
+rescue LoadError
+  require 'digest/sha1'
 end
 
 require 'ramaze/current/session/flash'
@@ -28,6 +28,10 @@ module Ramaze
 
     attr_accessor :flash
 
+    # Flag whether or not to drop this session on the floor
+
+    attr_accessor :dropped
+
     # secret salt for client-side session data
 
     trait :secret => 'change_me_please_123'
@@ -46,19 +50,42 @@ module Ramaze
 
     # Holds the default cookie used for sessions
 
-    COOKIE = { :path => '/' }
+    COOKIE = { :path => '/' } unless defined?(COOKIE)
 
-    class << self
-      def current
-        Current.session
-      end
+    # Shortcut for Current.session
+    def self.current
+      Current.session
+    end
 
-      # called from Ramaze::startup and adds Cache.sessions if cookies are
-      # enabled
+    # called from Ramaze::startup and adds Cache.sessions if cookies are
+    # enabled
 
-      def startup(options = {})
-        Cache.add(:sessions) if Global.sessions
-      end
+    def self.startup(options = {})
+      Cache.add(:sessions) if Global.sessions
+    end
+
+    # retrieve a specific session given a session id
+
+    def self.[](sess_id)
+      Session.new(sess_id)
+    end
+
+    # generate a random (and hopefully unique) id for the current session.
+    #
+    # It consists of the current time, the current request, the current PID of
+    # ruby and object_id of this instance.
+    #
+    # All this is joined by some calls to Kernel#rand and returned as a
+    # Digest::SHA256::hexdigest
+
+    def self.random_key
+      h = [
+        Time.now.to_f.to_s, rand,
+        Current.request.hash, rand,
+        Process.pid, rand,
+        object_id, rand
+      ].join
+      Digest::SHA256.hexdigest(h)
     end
 
     # Initialize a new Session, requires the original Rack::Request instance
@@ -66,17 +93,26 @@ module Ramaze
     #
     # sets @session_id and @session_flash
 
-    def initialize(request = Current.request)
+    def initialize(sess_or_request = Current.request)
       return unless Global.sessions
-      @session_id = (request.cookies[SESSION_KEY] || random_key)
 
-      unless IP_COUNT.nil?
+      if sess_or_request.is_a?(Request)
+        request = sess_or_request
+        @session_id = request.cookies[SESSION_KEY] || Session.random_key
+      else
+        request = nil
+        @session_id = sess_or_request
+      end
+
+      unless IP_COUNT.nil? or request.nil?
         ip = request.ip
         IP_COUNT[ip] << @session_id
         sessions.delete(IP_COUNT[ip].shift) if IP_COUNT[ip].size > IP_COUNT_LIMIT
       end
 
-      @flash = Ramaze::Session::Flash.new
+      @flash = Session::Flash.new(self)
+      @current = nil
+      @dropped = false
     end
 
     # relay all messages we don't understand to the currently active session
@@ -89,7 +125,10 @@ module Ramaze
     # existing already, the session itself is an instance of SessionHash
 
     def current
-      sessions[session_id] ||= Session::Hash.new
+      unless @current
+        @current = ( sessions[session_id] ||= Session::Hash.new(self) )
+      end
+      @current
     end
 
     # shortcut to Cache.sessions
@@ -98,30 +137,18 @@ module Ramaze
       Cache.sessions
     end
 
-    # generate a random (and hopefully unique) id for the current session.
-    #
-    # It consists of the current time, the current request, the current PID of
-    # ruby and object_id of this instance.
-    #
-    # All this is joined by some calls to Kernel#rand and returned as a
-    # Digest::SHA256::hexdigest
-
-    def random_key
-      h = [
-        Time.now.to_f.to_s, rand,
-        Current.request.hash, rand,
-        Process.pid, rand,
-        object_id, rand
-      ].join
-      Digest::SHA256.hexdigest(h)
-    end
-
     # Inspect on Session.current
 
     def inspect
       current.inspect
     end
 
+    # don't finish this session
+
+    def drop!
+      self.dropped = true
+    end
+
     # at the end of a request delete the current[:FLASH] and assign it to
     # current[:FLASH_PREVIOUS]
     #
@@ -133,6 +160,7 @@ module Ramaze
 
     def finish
       return unless Global.sessions
+      return if dropped
 
       old = current.delete(:FLASH)
       current[:FLASH_PREVIOUS] = old if old