Pistos-ramaze 2009.02 → 2009.04.08

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/dispatcher/action.rb

@@ -1,50 +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.
-
-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

data/lib/ramaze/dispatcher/directory.rb

@@ -1,119 +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.
-
-module Ramaze
-  class Dispatcher
-
-    # Generates a directory listing, see Ramaze::Controller::Directory for more
-    # information and how to create your own directory listing page
-    class Directory
-      class << self
-
-        # Entry point from Dispatcher::filter.
-        # Just a forwarder to build_listing, automatticly exiting if there is
-        # an error (defined by returning false in build_listing)
-        def call(path)
-          if Global.list_directories
-            response = build_listing(path)
-            Response.current.build(*response) if response
-          end
-        end
-
-        # Makes a request for http://yourserver/dirlist/path and returns the
-        # result. Due to this method, you can overwrite the action and create your
-        # own page. See Ramaze::Controller::Directory for more.
-        def build_listing(path)
-          dir = ::File.expand_path(Global.public_root/::File.expand_path(path, '/'))
-
-          if ::File.directory?(dir)
-            Log.debug("Serving directory listing: #{dir}")
-            Session.current.drop! if Session.current
-
-            status = Ramaze::STATUS_CODE['OK']
-            header = {'Content-Type' => "text/html"}
-            body = list_for(dir)
-            [body, status, header]
-          end
-        end
-
-        # Nicely formatted listing for given path, template is "stolen" from
-        # lighttpd
-        def list_for(path)
-          root = ::File.expand_path(Global.public_root)
-          display = path.gsub(/^#{Regexp.escape(root)}\/?/, '/')
-          wrapper =
-%(<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
-"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
-  <head>
-    <title>Directory listing of #{display}</title>
-
-    <style type="text/css"> /*<![CDATA[*/ a, a:active {text-decoration: none; color: blue;} a:visited {color: #48468F;} a:hover, a:focus {text-decoration: underline; color: red;} body {background-color: #F5F5F5;} h2 {margin-bottom: 12px;} table {margin-left: 12px;} th, td { font-family: "Courier New", Courier, monospace; font-size: 10pt; text-align: left;} th { font-weight: bold; padding-right: 14px; padding-bottom: 3px;} td {padding-right: 14px;} td.s, th.s {text-align: right;} div.list { background-color: white; border-top: 1px solid #646464; border-bottom: 1px solid #646464; padding-top: 10px; padding-bottom: 14px;} div.foot { font-family: "Courier New", Courier, monospace; font-size: 10pt; color: #787878; padding-top: 4px;} /*]]>*/ </style>
-  </head>
-  <body>
-    <h2>Directory listing of #{display}</h2>
-    <div class="list">
-      <table summary="Directory Listing" cellpadding="0" cellspacing="0">
-        <thead>
-          <tr>
-            <th class="n">Name</th>
-            <th class="m">Last Modified</th>
-            <th class="s">Size</th>
-            <th class="t">Type</th>
-          </tr>
-        </thead>
-        <tbody>
-          <tr>
-            <td class="n"><a href="#{display/'..'}/">Parent Directory</a>/</td>
-            <td class="m">&nbsp;</td>
-            <td class="s">- &nbsp;</td>
-            <td class="t">Directory</td>
-          </tr>
-          %s
-          %s
-        </tbody>
-      </table>
-    </div>
-    <div class="foot">%s</div>
-  </body>
-</html>
-)
-
-          dirs, files = Dir[path/'*'].partition{|file| ::File.directory?(file) }
-          dir_body, file_body = [], []
-
-          dirs.sort.each do |dir|
-            basename = ::File.basename(dir)
-            dir_body << %[<tr>
-            <td class="n"><a href="#{display/basename}">#{basename}/</a></td>
-            <td class="m">&nbsp;</td>
-            <td class="s">- &nbsp;</td>
-            <td class="t">Directory</td>
-          </tr>]
-          end
-
-          time_format = "%Y-%b-%d %H:%M:%S"
-          files.sort.each do |file|
-            basename = ::File.basename(file)
-            time = ::File.mtime(file).strftime(time_format)
-            size = ::File.size(file).filesize_format
-            mime = Tool::MIME.type_for(file)
-            file_body << %[<tr>
-            <td class="n"><a href="#{display/basename}">#{basename}</a></td>
-            <td class="m">#{time}</td>
-            <td class="s">#{size}</td>
-            <td class="t">#{mime}</td>
-          </tr>]
-          end
-
-          version = "ramaze/#{Ramaze::VERSION}"
-          wrapper % [
-            dir_body. join("\n          "),
-            file_body.join("\n          "),
-            version
-          ]
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/dispatcher/error.rb

@@ -1,108 +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.
-
-module Ramaze
-  class Dispatcher
-
-    # Last resort dispatcher, tries to recover as much information as possible
-    # from the past request and takes the appropiate actions.
-    #
-    # You can configure it over the HANDLE_ERROR constant or by defining error
-    # actions in your controllers.
-
-    class Error
-
-      # The class of exception is matched when an error occurs and the status
-      # code is set. The absolute URLs are used as fallback in case of a total
-      # failure.
-      HANDLE_ERROR = {
-                          Exception => [ 500, '/error' ],
-            Ramaze::Error::NoAction => [ 404, '/error' ],
-        Ramaze::Error::NoController => [ 404, '/error' ],
-      }
-
-      class << self
-        trait :last_error => nil
-
-        # Takes exception, of metainfo only :controller is used at the moment.
-        # Then goes on to try and find the correct response status and path.
-        # In case metainfo has a controller we try to get the action for the
-        # path on it, dispatching there if we find one.
-        # Otherwise a plain-text error message is set as response.
-        def call(error, metainfo = {})
-          log_error(error)
-
-          STATE[:exception] = error
-          response = Response.current
-
-          key = error.class.ancestors.find{|a| HANDLE_ERROR[a]}
-          status, path = *HANDLE_ERROR[key || Exception]
-          status ||= 500
-
-          if controller = metainfo[:controller]
-            newpath = (controller.mapping + path).squeeze('/')
-            action_response = Dispatcher::Action.call(newpath)
-            case action_response
-            when Ramaze::Error
-              Log.debug("No custom error page found on #{controller}, going to #{path}")
-            else
-              action_response.status = status
-              return action_response
-            end
-          end
-
-          if path and error.message !~ /`#{path}'/
-            response.status = status
-            return Dispatcher.dispatch_to(path)
-          else
-            response.build(error.message, status)
-          end
-        rescue Object => ex
-          Log.error(ex)
-          begin
-            m = ex.message
-            c = ex.class
-            b = [ex.backtrace].flatten.join("\n")
-            body = <<-html
-            ==== Error ====\n
-              #{ m } (#{ c })
-              #{ b }\n
-            ==== Request ====\n
-              #{ Request.current.pretty }\n
-            ==== Request ====\n
-              #{ Response.current.pretty }\n
-            ==== Session ====\n
-              #{ Session.current.pretty }\n
-            ==== Global ====\n
-              #{ Global.pretty }\n
-            html
-            response['Content-Type'] = 'text/plain'
-            response.build(body.unindent, status)
-          rescue Object
-            raise
-          end
-        end
-
-        # Only logs new errors with full backtrace, repeated errors are shown
-        # only with their message.
-        def log_error error
-          error_message = error.message
-
-          if trait[:last_error] == error_message or error.is_a? Ramaze::Error::NoAction
-            Log.error(error_message)
-          else
-            trait[:last_error] = error_message
-            Log.error(error)
-          end
-        end
-
-        # Handle to current exception.
-        # Only works inside request/response cycle.
-        def current
-          STATE[:exception]
-        end
-
-      end
-    end
-  end
-end

data/lib/ramaze/dispatcher/file.rb

@@ -1,100 +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 "time"
-require 'digest/md5'
-
-module Ramaze
-  class Dispatcher
-
-    # First of the dispatchers, looks up the public path and serves the
-    # file if found.
-
-    class File
-      # These names are checked for serving from public directory.
-      # They take priority over Actions which comes later in the FILTER
-      INDICES = %w[index.htm index.xhtml index.html index]
-
-      class << self
-        include Trinity
-
-        # Entry point from Dispatcher::filter.
-        # searches for the file and builds a response with status 200 if found.
-
-        def call(path)
-          return unless file = open_file(Rack::Utils.unescape(path))
-          Session.current.drop! if Session.current
-          if file == :NotModified
-            return response.build([], STATUS_CODE['Not Modified'])
-          end
-          response.build(file, STATUS_CODE['OK'])
-        end
-
-        # returns file-handle with the open file on success, setting the
-        # Content-Type as found in Tool::MIME
-
-        def open_file(path)
-          file = resolve_path(path)
-
-          if ::File.file?(file)
-            return unless in_public?(file)
-            response['Content-Type'] = Tool::MIME.type_for(file) unless ::File.extname(file).empty?
-            mtime = ::File.mtime(file)
-            response['Last-Modified'] = mtime.httpdate
-            response['ETag']= Digest::MD5.hexdigest(file+mtime.to_s).inspect
-            if modified_since = request.env['HTTP_IF_MODIFIED_SINCE']
-              return :NotModified unless Time.parse(modified_since) < mtime
-            elsif match = request.env['HTTP_IF_NONE_MATCH']
-              # Should be a unique string enclosed in ""
-              # To avoiding more file reading we use mtime and filepath
-              # we could throw in inode and size for more uniqueness
-              return :NotModified if response['ETag']==match
-            end
-            log(file)
-            ::File.open(file, 'rb')
-          end
-        end
-
-        # If path matches a directory in public_root, return that directory path, unless
-        # there is an index file in that directory, in which case return path for that.
-        # If path is not a directory, simply return given path in public_root.
-        # Either way, the returned path always starts with public_root.
-
-        def resolve_path(path)
-          joined = ::File.join(Global.public_root, path)
-
-          if ::File.directory?(joined)
-            glob = ::File.join(joined, "{#{INDICES.join(',')}}")
-            Dir[glob].first || joined
-          else
-            joined
-          end
-        end
-
-        # Determine whether a path is in the public directory for better
-        # security.
-        def in_public?(path)
-          expand(path).start_with?(expand(Global.public_root))
-        end
-
-        private
-
-        # Shortcut for Ramaze::Dispatcher::File#expand_path(path).
-        # Returns the absolute path of passed argument e.g.
-        # "/Users/rikur/ramaze_tests/public/foo.txt"
-
-        def expand(path)
-          ::File.expand_path(path)
-        end
-
-        def log(file)
-          case file
-          when *Global.boring
-          else
-            Log.debug("Serving static: #{file}")
-          end
-        end
-      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