Pistos-ramaze 2008.09

data/lib/ramaze/current/request.rb

@@ -0,0 +1,205 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'rack/request'
+
+module Ramaze
+
+  # The purpose of this class is to act as a simple wrapper for Rack::Request
+  # and provide some convinient methods for our own use.
+
+  class Request < ::Rack::Request
+    class << self
+
+      # get the current request out of STATE[:request]
+      #
+      # You can call this from everywhere with Ramaze::Request.current
+
+      def current() Current.request end
+    end
+
+    # you can access the original @request via this method_missing,
+    # first it tries to match your method with any of the HTTP parameters
+    # then, in case that fails, it will relay to @request
+
+    def method_missing meth, *args
+      key = meth.to_s.upcase
+      return env[key] if env.has_key?(key)
+      super
+    end
+
+    def request_uri
+      env['REQUEST_URI'] || path_info
+    end
+
+    def ip
+      if addr = env['HTTP_X_FORWARDED_FOR']
+        addr.split(',').last.strip
+      else
+        env['REMOTE_ADDR']
+      end
+    end
+
+    # Request is from a local network?
+    # Checks both IPv4 and IPv6
+
+    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)} unless defined?(LOCAL)
+
+    # --
+    # Mongrel somehow puts together multiple IPs when proxy is involved.
+    # ++
+
+    def local_net?(address = ip)
+      addr = IPAddr.new(address)
+      LOCAL.find{|range| range.include?(addr) }
+    rescue ArgumentError => ex
+      raise ArgumentError, ex unless ex.message == 'invalid address'
+    end
+
+    def [](key, *rest)
+      return params[key.to_s] if rest.empty?
+      [key, *rest].map{|k| params[k.to_s] }
+    end
+
+    def to_ivs(*args)
+      instance = Action.current.instance
+      args.each do |arg|
+        next unless value = self[arg]
+        instance.instance_variable_set("@#{arg}", value)
+      end
+    end
+
+    unless method_defined?(:rack_params)
+      alias rack_params params
+
+      # Wrapping Request#params to support a one-level hash notation.
+      # It doesn't support anything really fancy, so be conservative in its use.
+      #
+      # See if following provides something useful for us:
+      # http://redhanded.hobix.com/2006/01/25.html
+      #
+      # Example Usage:
+      #
+      #  # Template:
+      #
+      #  <form action="/paste">
+      #    <input type="text" name="paste[name]" />
+      #    <input type="text" name="paste[syntax]" />
+      #    <input type="submit" />
+      #  </form>
+      #
+      #  # In your Controller:
+      #
+      #  def paste
+      #    name, syntax = request['paste'].values_at('name', 'syntax')
+      #    paste = Paste.create_with(:name => name, :syntax => syntax)
+      #    redirect '/'
+      #  end
+      #
+      #  # Or, easier:
+      #
+      #  def paste
+      #    paste = Paste.create_with(request['paste'])
+      #    redirect '/'
+      #  end
+
+      def params
+        return {} if put?
+        return @ramaze_params if @ramaze_params
+
+        begin
+          @rack_params ||= rack_params
+        rescue EOFError => ex
+          @rack_params = {}
+          Log.error(ex)
+        end
+
+        @ramaze_params = {}
+
+        @rack_params.each do |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
+                # 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
+            @ramaze_params[key] = value
+          end
+        end
+
+        @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
+
+    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

@@ -0,0 +1,39 @@
+#          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, header = header)
+      header.each do |key, value|
+        self[key] = value
+      end
+
+      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,87 @@
+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
+
+      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,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/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.rb

@@ -0,0 +1,110 @@
+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
+__END__
+
+  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_given? ? block : @before
+      end
+
+      def before_call
+        return unless before
+        before.call
+      rescue Object => e
+        Ramaze::Log.error e
+        raise e
+      end
+
+      def after(&block)
+        @after = block_given? ? block : @after
+      end
+
+      def after_call
+        return unless after
+        after.call
+      rescue Object => e
+        Ramaze::Log.error e
+        raise e
+      end
+    end
+  end
+end