clivecrous-ramaze 0.3.9.5

data/lib/ramaze/current/response.rb

@@ -0,0 +1,27 @@
+#          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
+      # 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
+      end
+
+      self.body, self.status = body, status
+      self
+    end
+  end
+end

data/lib/ramaze/current/session.rb

@@ -0,0 +1,181 @@
+#          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.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 = 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
+      unless @current
+        @current = ( sessions[session_id] ||= Session::Hash.new(self) )
+      end
+      @current
+    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

@@ -0,0 +1,79 @@
+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)
+        current.delete(key)
+      end
+
+      # check if combined is empty
+
+      def empty?
+        combined.empty?
+      end
+
+      private
+
+      # Associated session object
+
+      def session
+        @session
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+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 sess
+        @session = sess
+        @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)
+        old = @hash.dup
+        result = @hash.send(*args, &block)
+        unless old == @hash
+          Cache.sessions[@session.session_id] = self
+        end
+        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)
+        if cookie
+          data, digest = cookie.split('--')
+          return nil unless digest == generate_digest(data)
+          Marshal.load(data.unpack('m').first)
+        end
+      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

@@ -0,0 +1,137 @@
+#          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.
+
+  module Dispatcher
+
+    # requests are passed to every
+    FILTER = [ Dispatcher::File, Dispatcher::Action ] unless defined?(FILTER)
+
+    # 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.
+      def handle
+        path = request.path_info.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
+
+      # 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 = Thread.current[: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 = Thread.current[:controller]
+        meta[:controller] ||= controller if controller
+
+        if Global.middleware
+          message = "No action for '#{meta[:path]}'"
+          message << " on '#{CGI.escapeHTML(controller.to_s)}'" if controller
+
+          raise(obj) if obj.respond_to?(:message)
+          raise(Ramaze::Error, message)
+        else
+          Dispatcher::Error.call(obj, meta)
+        end
+      end
+    end
+  end
+end