rubycas-server 0.4.2 → 0.5.0

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

@@ -0,0 +1,163 @@
+module Camping
+# == The Camping Reloader
+#
+# Camping apps are generally small and predictable.  Many Camping apps are
+# contained within a single file.  Larger apps are split into a handful of
+# other Ruby libraries within the same directory.
+#
+# Since Camping apps (and their dependencies) are loaded with Ruby's require
+# method, there is a record of them in $LOADED_FEATURES.  Which leaves a
+# perfect space for this class to manage auto-reloading an app if any of its
+# immediate dependencies changes.
+#
+# == Wrapping Your Apps
+#
+# Since bin/camping and the Camping::FastCGI class already use the Reloader,
+# you probably don't need to hack it on your own.  But, if you're rolling your
+# own situation, here's how.
+#
+# Rather than this:
+#
+#   require 'yourapp'
+#
+# Use this:
+#
+#   require 'camping/reloader'
+#   Camping::Reloader.new('/path/to/yourapp.rb')
+#
+# The reloader will take care of requiring the app and monitoring all files
+# for alterations.
+class Reloader
+    attr_accessor :klass, :mtime, :mount, :requires
+
+    # Creates the reloader, assigns a +script+ to it and initially loads the
+    # application.  Pass in the full path to the script, otherwise the script
+    # will be loaded relative to the current working directory.
+    def initialize(script)
+        @script = File.expand_path(script)
+        @mount = File.basename(script, '.rb')
+        @requires = nil
+        load_app
+    end
+
+    # Find the application, based on the script name.
+    def find_app(title)
+        @klass = Object.const_get(Object.constants.grep(/^#{title}$/i)[0]) rescue nil
+    end
+
+    # If the file isn't found, if we need to remove the app from the global
+    # namespace, this will be sure to do so and set @klass to nil.
+    def remove_app
+        Object.send :remove_const, @klass.name if @klass
+        @klass = nil
+    end
+
+    # Loads (or reloads) the application.  The reloader will take care of calling
+    # this for you.  You can certainly call it yourself if you feel it's warranted.
+    def load_app
+        title = File.basename(@script)[/^([\w_]+)/,1].gsub /_/,'' 
+        begin
+            all_requires = $LOADED_FEATURES.dup
+            load @script
+            @requires = ($LOADED_FEATURES - all_requires).select do |req|
+                req.index(File.basename(@script) + "/") == 0 || req.index(title + "/") == 0
+            end
+        rescue Exception => e
+            puts "!! trouble loading #{title}: [#{e.class}] #{e.message}"
+            puts e.backtrace.join("\n")
+            find_app title
+            remove_app
+            return
+        end
+
+        @mtime = mtime
+        find_app title
+        unless @klass and @klass.const_defined? :C
+            puts "!! trouble loading #{title}: not a Camping app, no #{title.capitalize} module found"
+            remove_app
+            return
+        end
+        
+        Reloader.conditional_connect
+        @klass.create if @klass.respond_to? :create
+        @klass
+    end
+
+    # The timestamp of the most recently modified app dependency.
+    def mtime
+        ((@requires || []) + [@script]).map do |fname|
+            fname = fname.gsub(/^#{Regexp::quote File.dirname(@script)}\//, '')
+            begin
+                File.mtime(File.join(File.dirname(@script), fname))
+            rescue Errno::ENOENT
+                remove_app
+                @mtime
+            end
+        end.max
+    end
+
+    # Conditional reloading of the app.  This gets called on each request and
+    # only reloads if the modification times on any of the files is updated.
+    def reload_app 
+        return if @klass and @mtime and mtime <= @mtime
+
+        if @requires
+            @requires.each { |req| $LOADED_FEATURES.delete(req) }
+        end
+        k = @klass
+        Object.send :remove_const, k.name if k
+        load_app
+    end
+
+    # Conditionally reloads (using reload_app.)  Then passes the request through
+    # to the wrapped Camping app.
+    def run(*a)
+        reload_app
+        if @klass
+            @klass.run(*a) 
+        else
+            Camping.run(*a)
+        end
+    end
+
+    # Returns source code for the main script in the application.
+    def view_source
+        File.read(@script)
+    end
+
+    class << self
+        def database=(db)
+            @database = db
+        end
+        def log=(log)
+            @log = log
+        end
+        def conditional_connect
+            # If database models are present, `autoload?` will return nil.
+            unless Camping::Models.autoload? :Base
+                require 'logger'
+                require 'camping/session'
+                Camping::Models::Base.establish_connection @database if @database
+
+                case @log
+                when Logger
+                    Camping::Models::Base.logger = @log
+                when String
+                    Camping::Models::Base.logger = Logger.new(@log == "-" ? STDOUT : @log)
+                end
+
+                Camping::Models::Session.create_schema
+
+                if @database and @database[:adapter] == 'sqlite3'
+                    begin
+                        require 'sqlite3_api'
+                    rescue LoadError
+                        puts "!! Your SQLite3 adapter isn't a compiled extension."
+                        abort "!! Please check out http://code.whytheluckystiff.net/camping/wiki/BeAlertWhenOnSqlite3 for tips."
+                    end
+                end
+            end
+        end
+    end
+end
+end

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

@@ -0,0 +1,123 @@
+# == 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

@@ -0,0 +1,65 @@
+# == 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)
+        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