ptomato-ramaze 2009.02

data/lib/ramaze/current/response.rb

@@ -0,0 +1,37 @@
+#          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(new_body = body, status = status, new_header = {})
+      self.header.merge!(new_header)
+
+      self.body, self.status = new_body, status
+    end
+
+    def body=(obj)
+      if obj.respond_to?(:stat)
+        @length = obj.stat.size
+        @body = obj
+      elsif obj.respond_to?(:size)
+        @body = []
+        @length = 0
+        write(obj)
+      else
+        raise(ArgumentError, "Invalid body: %p" % obj)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1,62 @@
+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/current/session.rb

@@ -0,0 +1,179 @@
+#          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.rb

@@ -0,0 +1,51 @@
+require 'ramaze/current/request'
+require 'ramaze/current/response'
+require 'ramaze/current/session'
+
+module Ramaze
+  class Current
+    include Trinity
+    extend Trinity
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      setup(env)
+      before_call
+      record
+
+      @app.call(env)
+      finish
+    ensure
+      after_call
+    end
+
+    def record
+      return unless filter = Global.record
+      request = Current.request
+      Record << request if filter.call(request)
+    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 self.call(env)
+    end
+
+    def before_call
+    end
+
+    def after_call
+    end
+  end
+end

data/lib/ramaze/dispatcher/action.rb

@@ -0,0 +1,50 @@
+#          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 Dispatcher
+
+    # This dispatcher is responsible for relaying requests to Controller::handle
+    # and filtering the results using FILTER.
+
+    class Action
+
+      # The response is passed to each filter by sending .call(response) to it.
+
+      FILTER = OrderedSet[
+        # Ramaze::Tool::Localize,
+      ] unless defined?(FILTER)
+
+      class << self
+        include Trinity
+
+        # Takes path, asks Controller to handle it and builds a response on
+        # success. The response is then passed to each member of FILTER for
+        # post-processing.
+
+        def call(path)
+          log(path)
+
+          catch(:respond) {
+            response.write Controller.handle(path)
+          }
+
+          FILTER.each{|f| f.call(response)}
+          response
+        rescue Ramaze::Error => ex
+          ex
+        end
+
+        # Logs the request via Log#info unless it's boring.
+
+        def log(path)
+          case path
+          when *Global.boring
+          else
+            Log.info("Dynamic request from #{request.ip}: #{request.request_uri}")
+          end
+        end
+      end
+    end
+  end
+end