ramaze 0.3.9.1 → 2023.01.06

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

@@ -1,67 +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 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
-
-      private
-
-      # Session.current or {}
-
-      def session
-        Current.session || {}
-      end
-    end
-  end
-end

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

@@ -1,65 +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
-        @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[Current.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

@@ -1,153 +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.
-
-if RUBY_VERSION >= "1.9.0"
-  require 'digest/sha1'
-else
-  require 'digest/sha2'
-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
-
-    # 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 => '/' }
-
-    class << self
-      def current
-        Current.session
-      end
-
-      # called from Ramaze::startup and adds Cache.sessions if cookies are
-      # enabled
-
-      def startup(options = {})
-        Cache.add(:sessions) if Global.sessions
-      end
-    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(request = Current.request)
-      return unless Global.sessions
-      @session_id = (request.cookies[SESSION_KEY] || random_key)
-
-      unless IP_COUNT.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 = Ramaze::Session::Flash.new
-    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
-      sessions[session_id] ||= Session::Hash.new
-    end
-
-    # shortcut to Cache.sessions
-
-    def sessions
-      Cache.sessions
-    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 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
-
-    # Inspect on Session.current
-
-    def inspect
-      current.inspect
-    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
-
-      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,40 +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
-  module 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.new(
-        # 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 process(path)
-          Log.info("Dynamic request from #{request.ip}: #{request.request_uri}")
-
-          catch(:respond) {
-            body = Controller.handle(path)
-            response = Response.current.build(body)
-          }
-          FILTER.each{|f| f.call(response)}
-          response
-        rescue Ramaze::Error => ex
-          ex
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/dispatcher/directory.rb

@@ -1,116 +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
-  module 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 process(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}")
-
-            status = Ramaze::STATUS_CODE['OK']
-            header = {'Content-Type' => "text/html"}
-            body = list_for(dir)
-            [body, status, header]
-          end
-        end
-
-        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
-  module 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 process(error, metainfo = {})
-          log_error(error)
-
-          Thread.current[: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.process(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 Global.error_page 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 || []).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
-          Thread.current[:exception]
-        end
-
-      end
-    end
-  end
-end

data/lib/ramaze/dispatcher/file.rb

@@ -1,87 +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
-  module 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 process(path)
-          return unless file = open_file(CGI.unescape(path))
-          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) or ::File.file?(file=file/'index')
-            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
-
-        def resolve_path(path)
-          joined = ::File.join(Global.public_root, path)
-
-          if ::File.directory?(joined)
-            Dir[joined/"{#{INDICES.join(',')}}"].first || joined
-          else
-            joined
-          end
-        end
-
-        def in_public?(path)
-          expand(path).start_with?(expand(Global.public_root))
-        end
-
-        private
-
-        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