rubycas-server 0.5.1 → 0.6.0

data/vendor/camping-1.5.180/lib/camping/session.rb

@@ -1,123 +0,0 @@
-# == About camping/session.rb
-#
-# This file contains two modules which supply basic sessioning to your Camping app.
-# Again, we're dealing with a pretty little bit of code: approx. 60 lines.
-# 
-# * Camping::Models::Session is a module which adds a single <tt>sessions</tt> table
-#   to your database.
-# * Camping::Session is a module which you will mix into your application (or into
-#   specific controllers which require sessions) to supply a <tt>@state</tt> variable
-#   you can use in controllers and views.
-#
-# For a basic tutorial, see the *Getting Started* section of the Camping::Session module.
-require 'camping'
-
-module Camping::Models
-# A database table for storing Camping sessions.  Contains a unique 32-character hashid, a
-# creation timestamp, and a column of serialized data called <tt>ivars</tt>. 
-class Session < Base
-    serialize :ivars
-    def []=(k, v) # :nodoc:
-        self.ivars[k] = v
-    end
-    def [](k) # :nodoc:
-        self.ivars[k] rescue nil
-    end
-
-    RAND_CHARS = [*'A'..'Z'] + [*'0'..'9'] + [*'a'..'z']
-
-    # Generates a new session ID and creates a row for the new session in the database.
-    def self.generate cookies
-        rand_max = RAND_CHARS.size
-        sid = (0...32).inject("") { |ret,_| ret << RAND_CHARS[rand(rand_max)] }
-        sess = Session.create :hashid => sid, :ivars => Camping::H[]
-        cookies.camping_sid = sess.hashid
-        sess
-    end
-
-    # Gets the existing session based on the <tt>camping_sid</tt> available in cookies.
-    # If none is found, generates a new session.
-    def self.persist cookies
-        if cookies.camping_sid
-            session = Camping::Models::Session.find_by_hashid cookies.camping_sid
-        end
-        unless session
-            session = Camping::Models::Session.generate cookies
-        end
-        session
-    end
-
-    # Builds the session table in the database.  To be used in your application's
-    # <tt>create</tt> method.
-    #
-    # Like so:
-    #
-    #   def Blog.create
-    #       Camping::Models::Session.create_schema
-    #       unless Blog::Models::Post.table_exists?
-    #           ActiveRecord::Schema.define(&Blog::Models.schema)
-    #       end
-    #   end
-    #
-    def self.create_schema
-        unless table_exists?
-            ActiveRecord::Schema.define do
-                create_table :sessions, :force => true do |t|
-                    t.column :id,          :integer, :null => false
-                    t.column :hashid,      :string,  :limit => 32
-                    t.column :created_at,  :datetime
-                    t.column :ivars,       :text
-                end
-            end
-            reset_column_information
-        end
-    end
-end
-end
-
-module Camping
-# The Camping::Session module is designed to be mixed into your application or into specific
-# controllers which require sessions.  This module defines a <tt>service</tt> method which
-# intercepts all requests handed to those controllers.
-#
-# == Getting Started
-#
-# To get sessions working for your application:
-#
-# 1. <tt>require 'camping/session'</tt>
-# 2. Mixin the module: <tt>module YourApp; include Camping::Session end</tt>
-# 3. In your application's <tt>create</tt> method, add a call to <tt>Camping::Models::Session.create_schema</tt>
-# 4. Throughout your application, use the <tt>@state</tt> var like a hash to store your application's data. 
-# 
-# If you are unfamiliar with the <tt>create</tt> method, see 
-# http://code.whytheluckystiff.net/camping/wiki/GiveUsTheCreateMethod.
-#
-# == A Few Notes
-#
-# * The session ID is stored in a cookie. Look in <tt>@cookies.camping_sid</tt>.
-# * The session data is stored in the <tt>sessions</tt> table in your database.
-# * All mounted Camping apps using this class will use the same database table.
-# * However, your application's data is stored in its own hash.
-# * Session data is only saved if it has changed. 
-module Session
-    # This <tt>service</tt> method, when mixed into controllers, intercepts requests
-    # and wraps them with code to start and close the session.  If a session isn't found
-    # in the database it is created.  The <tt>@state</tt> variable is set and if it changes,
-    # it is saved back into the database.
-    def service(*a)
-        session = Camping::Models::Session.persist @cookies
-        app = self.class.name.gsub(/^(\w+)::.+$/, '\1')
-        @state = (session[app] ||= Camping::H[])
-        hash_before = Marshal.dump(@state).hash
-        s = super(*a)
-        if session
-            hash_after = Marshal.dump(@state).hash
-            unless hash_before == hash_after
-                session[app] = @state
-                session.save
-            end
-        end
-        s
-    end
-end
-end

data/vendor/camping-1.5.180/lib/camping/webrick.rb

@@ -1,68 +0,0 @@
-# == About camping/webrick.rb
-#
-# For many who have Ruby installed, Camping and WEBrick is a great option.
-# It's definitely the easiest configuration, however some performance is sacrificed.
-# For better speed, check out Mongrel at http://mongrel.rubyforge.org/, which comes
-# with Camping hooks and is supported by the Camping Tool.
-require 'camping'
-require 'webrick/httpservlet/abstract.rb'
-
-module WEBrick
-# WEBrick::CampingHandler is a very simple handle for hosting Camping apps in
-# a WEBrick server.  It's used much like any other WEBrick handler.
-# 
-# == Mounting a Camping App
-#
-# Assuming Camping.goes(:Blog), the Blog application can be mounted alongside
-# other WEBrick mounts.
-#
-#   s = WEBrick::HTTPServer.new(:BindAddress => host, :Port => port)
-#   s.mount "/blog", WEBrick::CampingHandler, Blog
-#   s.mount_proc("/") { ... }
-#
-# == How Does it Compare?
-#
-# Compared to other handlers, WEBrick is well-equipped in terms of features.
-# 
-# * The <tt>X-Sendfile</tt> header is supported, along with etags and 
-#   modification time headers for the file served.  Since this handler
-#   is a subclass of WEBrick::HTTPServlet::DefaultFileHandler, all of its
-#   logic is used.
-# * IO is streaming up and down.  When you upload a file, it is streamed to
-#   the server's filesystem.  When you download a file, it is streamed to
-#   your browser.
-#
-# While WEBrick is a bit slower than Mongrel and FastCGI options, it's 
-# a decent choice, for sure!
-class CampingHandler < WEBrick::HTTPServlet::DefaultFileHandler
-    # Creates a CampingHandler, which answers for the application within +klass+.
-    def initialize(server, klass)
-        super(server, klass)
-        @klass = klass
-    end
-    # Handler for WEBrick requests (also aliased as do_POST).
-    def service(req, resp)
-puts @klass.inspect
-puts req.body.inspect
-puts req.meta_vars.inspect
-        controller = @klass.run((req.body and StringIO.new(req.body)), req.meta_vars)
-        resp.status = controller.status
-        @local_path = nil
-        controller.headers.each do |k, v|
-            if k =~ /^X-SENDFILE$/i
-                @local_path = v
-            else
-                [*v].each do |vi|
-                    resp[k] = vi
-                end
-            end
-        end
-
-        if @local_path
-            do_GET(req, resp)
-        else
-            resp.body = controller.body.to_s
-        end
-    end
-end
-end