ramaze 2009.03 → 2009.04

data/lib/ramaze/current/session.rb

@@ -1,179 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-begin
-  require 'digest/sha2'
-rescue LoadError
-  require 'digest/sha1'
-end
-
-require 'ramaze/current/session/flash'
-require 'ramaze/current/session/hash'
-
-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.
-  #
-  # The persistence is achieved by setting a cookie with the session_id to
-  # the client, which is then passed back and forth until the cookie is either
-  # deleted or expires.
-
-  class Session
-    # The unique id for the current session which is also passed on to the cookie.
-
-    attr_accessor :session_id
-
-    # This variable holds the current SessionFlash
-
-    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'
-
-    # 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)
-
-    # Limit the number of sessions one IP is allowed to hold.
-
-    IP_COUNT_LIMIT = 1000 unless defined?(IP_COUNT_LIMIT)
-
-    # Holds the default cookie used for sessions
-
-    COOKIE = { :path => '/' } unless defined?(COOKIE)
-
-    # Shortcut for Current.session
-    def self.current
-      Current.session
-    end
-
-    # called from Ramaze::startup and adds Cache.sessions if cookies are
-    # enabled
-
-    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
-    # given to us from Dispatcher#setup_environment.
-    #
-    # sets @session_id and @session_flash
-
-    def initialize(sess_or_request = Current.request)
-      return unless Global.sessions
-
-      if sess_or_request.respond_to?(:cookies)
-        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 = Session::Flash.new(self)
-      @current = nil
-      @dropped = false
-    end
-
-    # relay all messages we don't understand to the currently active session
-
-    def method_missing(*args, &block)
-      current.send(*args, &block)
-    end
-
-    # answers with the currently active session, which is set unless it is
-    # existing already, the session itself is an instance of SessionHash
-
-    def current
-      return @current if @current
-      @current = ( sessions[session_id] ||= Session::Hash.new(self) )
-    end
-
-    # shortcut to Cache.sessions
-
-    def sessions
-      Cache.sessions
-    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]
-    #
-    # 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
-      return if dropped
-
-      old = current.delete(:FLASH)
-      current[:FLASH_PREVIOUS] = old if old
-
-      request, response = Current.request, Current.response
-
-      hash = {:value => session_id}.merge(COOKIE)
-      response.set_cookie(SESSION_KEY, hash)
-
-      # 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

@@ -1,88 +0,0 @@
-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 initialize sess
-        @session = sess
-      end
-
-      # iterate over the combined session
-      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)
-        previous.delete(key)
-        current.delete(key)
-      end
-
-      # check if combined is empty
-
-      def empty?
-        combined.empty?
-      end
-
-      def merge!(hash)
-        current.merge!(hash)
-      end
-
-      def merge(hash)
-        current.merge(hash)
-      end
-
-      private
-
-      # Associated session object
-
-      def session
-        @session
-      end
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-module Ramaze
-  class Session
-
-    # The Session::Hash 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 Hash
-
-      # Sets @hash to an empty Hash
-
-      def initialize(session)
-        @session = session
-        @hash = {}
-      end
-
-      # relays all the methods to the @hash and updates the session_cache in
-      # Session.current.sessions if anything changes.
-
-      def method_missing(*args, &block)
-        result = @hash.send(*args, &block)
-        Cache.sessions[@session.session_id] = self
-        result
-      end
-
-      # Calls #inspect on the wrapped @hash
-
-      def inspect
-        @hash.inspect
-      end
-
-      # Use client side session variables
-
-      def client
-        Request.current['session.client'] ||= unmarshal(Request.current.cookies["#{Session::SESSION_KEY}-client"]) || {}
-      end
-
-      private
-
-      # Marshal a session hash into safe cookie data. Include an integrity hash.
-      def marshal(session)
-        data = [ Marshal.dump(session) ].pack('m').chop
-        "#{data}--#{generate_digest(data)}"
-      end
-
-      # Unmarshal cookie data to a hash and verify its integrity.
-      def unmarshal(cookie)
-        return unless cookie
-        data, digest = cookie.split('--')
-        return nil unless digest == generate_digest(data)
-        Marshal.load(data.unpack('m').first)
-      end
-
-      # Generate the inline SHA512 message digest. Larger (128 bytes) than SHA256
-      # (64 bytes) or RMD160 (40 bytes), but small relative to the 4096 byte
-      # max cookie size.
-      def generate_digest(data)
-        Digest::SHA512.hexdigest "#{data}#{Session.trait[:secret]}"
-      end
-    end
-  end
-end

data/lib/ramaze/dispatcher.rb

@@ -1,145 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'ramaze/error'
-require 'ramaze/tool/mime'
-
-require 'ramaze/dispatcher/action'
-require 'ramaze/dispatcher/error'
-require 'ramaze/dispatcher/file'
-require 'ramaze/dispatcher/directory'
-
-module Ramaze
-
-  # The Dispatcher receives requests from adapters and sets up the proper environment
-  # to process them and respond.
-
-  class Dispatcher
-    def initialize(*args)
-      Dispatcher.call(*args)
-    end
-
-    # requests are passed to every
-    FILTER = OrderedSet[ Dispatcher::File, Dispatcher::Action ]
-
-    # Response codes to cache the output of for repeated requests.
-    trait :shielded => [ STATUS_CODE["Not Found"] ]
-
-    class << self
-      include Trinity
-
-      # Entry point for Adapter#respond, takes a Rack::Request and
-      # Rack::Response, sets up the environment and the goes on to dispatch
-      # for the given path from rack_request.
-      #
-      # +env+ will be ignored, it's just for compatibility with rack middleware
-      def call(env = nil)
-        path = request.path_info.squeeze('/')
-        path.sub!(/^#{Regexp.escape(Global.prefix)}/, '/')
-        path.squeeze!('/')
-
-        if new_path = Rewrite.resolve(path)
-          path = new_path
-          Log.dev("Rewriting `#{path}' to `#{path}'")
-        end
-
-        case path
-        when *Global.ignore
-          unless ::File.exist?(Dispatcher::File.resolve_path(path))
-            return response.build(Global.ignore_body, Global.ignore_status)
-          end
-        end
-
-        general_dispatch path
-      rescue Object => exception
-        error(exception)
-      end
-      alias handle call
-
-      # protects against recursive dispatch and reassigns the path_info in the
-      # request, the rest of the request is kept intact.
-      def dispatch_to(path)
-        if request.path_info == path
-          if error = STATE[:exception]
-            raise error
-          else
-            raise "Recursive redirect from #{path} to #{path}"
-          end
-        end
-        request.path_info = path
-        general_dispatch path
-      end
-
-      # splits up the dispatch based on Global.shield
-      def general_dispatch(path)
-        if Global.shield
-          shielded_dispatch path
-        else
-          dispatch path
-        end
-      end
-
-      # Protects somewhat against hammering of erroring paths, since error-pages
-      # take a while to build in the default mode it is possible to decrease
-      # overall speed quite a bit by hitting Ramaze with such paths.
-      # shielded_dispatch checks the path and caches erronous responses so they
-      # won't be recreated but simply pushed out again without stopping at the
-      # Controller.
-      # Please note that this is just minor protection and the best option is to
-      # create a performant error-page instead.
-      def shielded_dispatch(path)
-        shield_cache = Cache.shield
-        handled = shield_cache[path]
-        return handled if handled
-
-        dispatched = dispatch(path)
-
-        unless trait[:shielded].include?(dispatched.status)
-          dispatched
-        else
-          shield_cache[path] = dispatched
-        end
-      end
-
-      # filters the path until a response or redirect is thrown or a filter is
-      # successful, builds a response from the returned hash in case of throws.
-      def dispatch(path)
-        catch(:respond){
-          redirected = catch(:redirect){
-            filter(path)
-            throw(:respond)
-          }
-          response.build(*redirected)
-        }
-      end
-
-      # Calls .call(path) on every object in Dispatcher::FILTER until one
-      # returns something else than false/nil.
-
-      def filter(path)
-        result = nil
-        FILTER.each do |dispatcher|
-          result = dispatcher.call(path)
-          return result if result and not result.respond_to?(:exception)
-        end
-
-        error(result, :path => path)
-      end
-
-      def error(obj, meta = {})
-        controller = STATE[:controller]
-        meta[:controller] ||= controller if controller
-
-        if Global.error_page
-          Dispatcher::Error.call(obj, meta)
-        else
-          message = "No action for '#{meta[:path]}'"
-          message << " on '#{Rack::Utils.escape_html(controller)}'" if controller
-
-          raise(obj) if obj.respond_to?(:message)
-          raise(Ramaze::Error, message)
-        end
-      end
-    end
-  end
-end