ramaze 0.3.5 → 0.3.9

data/lib/ramaze/current.rb

@@ -0,0 +1,70 @@
+require 'ramaze/current/request'
+require 'ramaze/current/response'
+require 'ramaze/current/session'
+
+module Ramaze
+  module Current
+    class << self
+      include Trinity
+
+      def call(env)
+        setup(env)
+        before_call
+
+        if filter = Global.record
+          request = Current.request
+          Record << request if filter[request]
+        end
+
+        Dispatcher.handle
+
+        finish
+      ensure
+        after_call
+      end
+
+      def setup(env)
+        self.request = Request.new(env)
+        self.response = Response.new
+        self.session = Session.new
+      end
+
+      def finish
+        session.finish if session
+        response.finish
+      end
+
+      def before(&block)
+        @before = block if block
+        @before
+      end
+
+      def before_call
+        if before
+          begin
+            before.call
+          rescue Object => e
+            Ramaze::Log.error e 
+            raise
+          end
+        end
+      end
+
+      def after(&block)
+        @after = block if block
+        @after
+      end
+
+      def after_call
+        if after
+          begin
+            after.call
+          rescue Object => e
+            Ramaze::Log.error e 
+            raise
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/{trinity → current}/request.rb

@@ -1,11 +1,6 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-require 'cgi'
-require 'tmpdir'
-require 'digest/md5'
-require 'ipaddr'
-require 'rack'
 require 'rack/request'
 
 module Ramaze
@@ -20,9 +15,7 @@ module Ramaze
       #
       # You can call this from everywhere with Ramaze::Request.current
 
-      def current
-        Thread.current[:request]
-      end
+      def current() Current.request end
     end
 
     # you can access the original @request via this method_missing,
@@ -48,7 +41,7 @@ module Ramaze
 
     ipv4 = %w[ 127.0.0.1/32 192.168.0.0/16 172.16.0.0/12 10.0.0.0/8 169.254.0.0/16 ]
     ipv6 = %w[ fc00::/7 fe80::/10 fec0::/10 ::1 ]
-    LOCAL = (ipv4 + ipv6).map{|a| IPAddr.new(a)}
+    LOCAL = (ipv4 + ipv6).map{|a| IPAddr.new(a)} unless defined?(LOCAL)
 
     # --
     # Mongrel somehow puts together multiple IPs when proxy is involved.
@@ -99,7 +92,7 @@ module Ramaze
       #  # In your Controller:
       #
       #  def paste
-      #    name, syntax = request.params['paste'].values_at('name', 'syntax')
+      #    name, syntax = request['paste'].values_at('name', 'syntax')
       #    paste = Paste.create_with(:name => name, :syntax => syntax)
       #    redirect '/'
       #  end
@@ -107,7 +100,7 @@ module Ramaze
       #  # Or, easier:
       #
       #  def paste
-      #    paste = Paste.create_with(request.params)
+      #    paste = Paste.create_with(request['paste'])
       #    redirect '/'
       #  end
 
@@ -118,10 +111,20 @@ module Ramaze
         @ramaze_params = {}
 
         @rack_params.each do |key, value|
-          outer_key, inner_key = key.scan(/^(.+)\[(.*?)\]$/).first
-          if outer_key and inner_key
-            @ramaze_params[outer_key] ||= {}
-            @ramaze_params[outer_key][inner_key] = value
+          if key =~ /^(.*?)(\[.*\])/
+            prim, nested = $~.captures
+            ref = @ramaze_params
+
+            keys = nested.scan(/\[([^\]]+)\]/).flatten
+            keys.unshift prim
+
+            keys.each_with_index do |k, i|
+              if i + 1 >= keys.size
+                ref[k] = value
+              else
+                ref = ref[k] ||= {}
+              end
+            end
           else
             @ramaze_params[key] = value
           end
@@ -130,5 +133,49 @@ module Ramaze
         @ramaze_params
       end
     end
+
+    # Interesting HTTP variables from env
+
+    def http_vars
+      env.reject{ |k,v|
+        k.to_s !~ /USER|HOST|REQUEST|REMOTE|FORWARD|REFER|PATH|QUERY|VERSION|KEEP|CACHE/
+      }
+    end
+
+    def to_s
+      p, c, e = params.inspect, cookies.inspect, http_vars.inspect
+      %{#<Ramaze::Request params=#{p} cookies=#{c} env=#{e}>}
+    end
+    alias inspect to_s
+
+    def pretty_print pp
+      p, c, e = params, cookies, http_vars
+      pp.object_group(self){
+        { 'params' => params,
+          'cookies' => cookies,
+          'env' => http_vars }.each do |name, hash|
+          pp.breakable
+          pp.text " @#{name}="
+          pp.nest(name.length+3){ pp.pp_hash hash }
+        end
+      }
+    end
+
+    # Answers with a subset of request.params with only the key/value pairs for
+    # which you pass the keys.
+    # Valid keys are objects that respond to :to_s
+    #
+    # Example:
+    #   request.params
+    #   # => {'name' => 'jason', 'age' => '45', 'job' => 'lumberjack'}
+    #   request.sub('name')
+    #   # => {'name' => 'jason'}
+    #   request.sub(:name, :job)
+    #   # => {'name' => 'jason', 'job' => 'lumberjack'}
+
+    def subset(*keys)
+      keys = keys.map{|k| k.to_s }
+      params.reject{|k,v| not keys.include?(k) }
+    end
   end
 end

data/lib/ramaze/current/response.rb

@@ -0,0 +1,19 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  class Response < Rack::Response
+    class << self
+      def current() Current.response end
+    end
+
+    def build(body = body, status = status, header = header)
+      header.each do |key, value|
+        self[key] = value
+      end
+
+      self.body, self.status = body, status
+      self
+    end
+  end
+end

data/lib/ramaze/{trinity → current}/session.rb

@@ -7,39 +7,10 @@ else
   require 'digest/sha2'
 end
 
-module Ramaze
-
-  # The SessionHash acts as the wrapper for a simple Hash
-  #
-  # Its purpose is to notify the underlying cache, in which the sessions
-  # are stored, about updates.
-
-  class SessionHash
-
-    # Sets @hash to an empty Hash
-
-    def initialize
-      @hash = {}
-    end
-
-    # relays all the methods to the @hash and updates the session_cache in
-    # Session.current.sessions if anything changes.
+require 'ramaze/current/session/flash'
+require 'ramaze/current/session/hash'
 
-    def method_missing(*args, &block)
-      old = @hash.dup
-      result = @hash.send(*args, &block)
-      unless old == @hash
-        Cache.sessions[Session.current.session_id] = self
-      end
-      result
-    end
-
-    # Calls #inspect on the wrapped @hash
-
-    def inspect
-      @hash.inspect
-    end
-  end
+module Ramaze
 
   # The purpose of Session is to hold key/value pairs like a Hash for a series
   # of # request/response cycles from the same client.
@@ -49,7 +20,6 @@ module Ramaze
   # deleted or expires.
 
   class Session
-
     # The unique id for the current session which is also passed on to the cookie.
 
     attr_accessor :session_id
@@ -58,13 +28,17 @@ module Ramaze
 
     attr_accessor :flash
 
+    # secret salt for client-side session data
+
+    trait :secret => 'change_me_please_123'
+
     # the key used for the cookie
 
     SESSION_KEY = '_ramaze_session_id' unless defined?(SESSION_KEY)
 
     # Holds counter for IPs
 
-    IP_COUNT = Hash.new{|h,k| h[k] = OrderedSet.new} unless defined?(IP_COUNT)
+    IP_COUNT = ::Hash.new{|h,k| h[k] = OrderedSet.new} unless defined?(IP_COUNT)
 
     # Limit the number of sessions one IP is allowed to hold.
 
@@ -75,6 +49,9 @@ module Ramaze
     COOKIE = { :path => '/' }
 
     class << self
+      def current
+        Current.session
+      end
 
       # called from Ramaze::startup and adds Cache.sessions if cookies are
       # enabled
@@ -82,13 +59,6 @@ module Ramaze
       def startup(options = {})
         Cache.add(:sessions) if Global.sessions
       end
-
-      # answers with Thread.current[:session] which holds the current session
-      # set by the Dispatcher#setup_environment.
-
-      def current
-        Thread.current[:session]
-      end
     end
 
     # Initialize a new Session, requires the original Rack::Request instance
@@ -96,16 +66,17 @@ module Ramaze
     #
     # sets @session_id and @session_flash
 
-    def initialize request
+    def initialize(request = Current.request)
+      return unless Global.sessions
       @session_id = (request.cookies[SESSION_KEY] || random_key)
 
       unless IP_COUNT.nil?
-        ip = request.remote_addr
+        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::SessionFlash.new
+      @flash = Ramaze::Session::Flash.new
     end
 
     # relay all messages we don't understand to the currently active session
@@ -118,7 +89,7 @@ module Ramaze
     # existing already, the session itself is an instance of SessionHash
 
     def current
-      sessions[session_id] ||= SessionHash.new
+      sessions[session_id] ||= Session::Hash.new
     end
 
     # shortcut to Cache.sessions
@@ -138,7 +109,7 @@ module Ramaze
     def random_key
       h = [
         Time.now.to_f.to_s, rand,
-        Thread.current[:request].hash, rand,
+        Current.request.hash, rand,
         Process.pid, rand,
         object_id, rand
       ].join
@@ -156,76 +127,27 @@ module Ramaze
     #
     # this is needed so flash can iterate over requests
     # and always just keep the current and previous key/value pairs.
+    #
+    # finalizes the session and assigns the key to the response via
+    # set_cookie.
+
+    def finish
+      return unless Global.sessions
 
-    def finalize
       old = current.delete(:FLASH)
       current[:FLASH_PREVIOUS] = old if old
-    end
-  end
-
-  # The purpose of this class is to act as a unifier of the previous
-  # and current flash.
-  #
-  # Flash means pairs of keys and values that are held only over one
-  # request/response cycle. So you can assign a key/value in the current
-  # session and retrieve it in the current and following request.
-  #
-  # Please see the FlashHelper for details on the usage as you won't need
-  # to touch this class at all.
 
-  class SessionFlash
+      request, response = Current.request, Current.response
 
-    # the current session[:FLASH_PREVIOUS]
+      hash = {:value => session_id}.merge(COOKIE)
+      response.set_cookie(SESSION_KEY, hash)
 
-    def previous
-      session[:FLASH_PREVIOUS] || {}
-    end
-
-    # the current session[:FLASH]
-
-    def current
-      session[:FLASH] ||= {}
-    end
-
-    # combined key/value pairs of previous and current
-    # current keys overshadow the old ones.
-
-    def combined
-      previous.merge(current)
-    end
-
-    # flash[key] in your Controller
-
-    def [](key)
-      combined[key]
-    end
-
-    # flash[key] = value in your Controller
-
-    def []=(key, value)
-      prev = session[:FLASH] || {}
-      prev[key] = value
-      session[:FLASH] = prev
-    end
-
-    # Inspects the combined SessionFlash
-
-    def inspect
-      combined.inspect
-    end
-
-    # Delete a key
-
-    def delete(key)
-      session[:FLASH].delete(key)
-    end
-
-    private
-
-    # Session.current or {}
-
-    def session
-      Session.current || {}
+      # set client side session cookie
+      if val = request['session.client'] and
+         (!val.empty? or request.cookies["#{SESSION_KEY}-client"])
+        cookie = hash.merge(:value => marshal(val))
+        response.set_cookie("#{SESSION_KEY}-client", cookie)
+      end
     end
   end
 end

data/lib/ramaze/current/session/flash.rb

@@ -0,0 +1,67 @@
+module Ramaze
+  class Session
+    # The purpose of this class is to act as a unifier of the previous
+    # and current flash.
+    #
+    # Flash means pairs of keys and values that are held only over one
+    # request/response cycle. So you can assign a key/value in the current
+    # session and retrieve it in the current and following request.
+    #
+    # Please see the FlashHelper for details on the usage as you won't need
+    # to touch this class at all.
+    class Flash
+      include Enumerable
+      def each(&block)
+        combined.each(&block)
+      end
+
+      # the current session[:FLASH_PREVIOUS]
+      def previous
+        session[:FLASH_PREVIOUS] || {}
+      end
+
+      # the current session[:FLASH]
+      def current
+        session[:FLASH] ||= {}
+      end
+
+      # combined key/value pairs of previous and current
+      # current keys overshadow the old ones.
+      def combined
+        previous.merge(current)
+      end
+
+      # flash[key] in your Controller
+      def [](key)
+        combined[key]
+      end
+
+      # flash[key] = value in your Controller
+      def []=(key, value)
+        prev = session[:FLASH] || {}
+        prev[key] = value
+        session[:FLASH] = prev
+      end
+
+      # Inspects the combined SessionFlash
+
+      def inspect
+        combined.inspect
+      end
+
+      # Delete a key
+
+      def delete(key)
+        current.delete(key)
+      end
+
+      private
+
+      # Session.current or {}
+
+      def session
+        Current.session || {}
+      end
+    end
+  end
+end