camping 1.4.2 → 1.5

data/lib/camping.rb

@@ -1,51 +1,52 @@
-%w[rubygems active_record markaby metaid tempfile uri].each{|l|require l}
-module Camping;C=self;F=__FILE__;S=IO.read(F).gsub(/_+FILE_+/,F.dump)
-module Helpers;def R c,*args;p=/\(.+?\)/;args.inject(c.urls.find{|x|x.scan(p).
-size==args.size}.dup){|str,a|str.sub(p,(a.__send__(a.class.primary_key)rescue
-a).to_s)} end;def URL c='/',*a;c=R(c,*a)if c.respond_to?:urls;c=self/c;c=
-"//"+@env.HTTP_HOST+c if c[/^\//];URI(c) end;def / p;p[/^\//]?@root+p:p end
-def errors_for o;ul.errors{o.errors.each_full{|x|li x}}if o.errors.any? end end
-module Base;include Helpers;attr_accessor :input,:cookies,:env,:headers,:body,
-:status,:root;def method_missing m,*a,&b;s=m==:render ? markaview(*a,&b):eval(
-"markaby.#{m}(*a,&b)");s=markaview(:layout){s} if Views.method_defined?:layout
-r 200,s.to_s end;def r s,b,h={};@status=s;@headers.merge!(h);@body=b end;def 
-redirect *a;r 302,'','Location'=>URL(*a) end;def initialize r,e,m;e=H[e.to_hash]
-@status,@method,@env,@headers,@root=200,m.downcase,e,{'Content-Type'=>"text/htm\
-l"},e.SCRIPT_NAME.sub(/\/$/,'');@k=C.kp e.HTTP_COOKIE;q=C.qs_parse e.QUERY_STRING
-@in=r;if %r|\Amultipart/form-.*boundary=\"?([^\";,]+)|n.match e.CONTENT_TYPE;b=
-/(?:\r?\n|\A)#{Regexp::quote("--#$1")}(?:--)?\r$/;until @in.eof?;fh=H[];for l in
-@in;case l;when "\r\n":break;when /^Content-Disposition: form-data;/:fh.u H[*$'.
-scan(/(?:\s(\w+)="([^"]+)")/).flatten];when /^Content-Type: (.+?)(\r$|\Z)/m;fh[
+%w[active_support markaby tempfile uri].map{|l|require l}
+module Camping;Apps=[];C=self;S=IO.read(__FILE__).sub(/S=I.+$/,'')
+P="Cam\ping Problem!";module Helpers;def R c,*g;p=/\(.+?\)/;g.inject(c.
+urls.find{|x|x.scan(p).size==g.size}.dup){|s,a|s.sub p,C.escape((a[
+a.class.primary_key]rescue a))}end;def URL c='/',*a;c=R(c,*a)if c.
+respond_to?:urls;c=self/c;c="//"+@env.HTTP_HOST+c if c[/^\//];URI(c)end;def/p
+p[/^\//]?@root+p : p end;def errors_for o;ul.errors{o.errors.each_full{|x|li x}
+}if o.errors.any?end end;module Base;include Helpers;attr_accessor:input,
+:cookies,:env,:headers,:body,:status,:root;def method_missing*a,&b
+a.shift if a[0]==:render;m=Mab.new({},self);s=m.capture{send(*a,&b)};s=m.layout{s}if
+/^_/!~a[0].to_s and m.respond_to?:layout;s end;def r s,b,h={};@status=s;@headers. 
+merge!h;@body=b end;def redirect*a;r 302,'','Location'=>URL(*a)end;Z="\r\n"
+def initialize r,e,m;e=H[e.to_hash];@status,@method,@env,@headers,@root=200,m.
+downcase,e,{'Content-Type'=>"text/html"},e.SCRIPT_NAME.sub(/\/$/,'')
+@k=C.kp e.HTTP_COOKIE;q=C.qs_parse e.QUERY_STRING;@in=r
+if%r|\Amultipart/form-.*boundary=\"?([^\";,]+)|n.match e.CONTENT_TYPE
+b=/(?:\r?\n|\A)#{Regexp::quote("--#$1")}(?:--)?\r$/;until@in.eof?;fh=H[];for l in@in
+case l;when Z;break;when/^Content-D.+?: form-data;/;fh.u H[*$'.
+scan(/(?:\s(\w+)="([^"]+)")/).flatten];when/^Content-Type: (.+?)(\r$|\Z)/m;fh[
 :type]=$1;end;end;fn=fh[:name];o=if fh[:filename];o=fh[:tempfile]=Tempfile.new(:C)
-o.binmode;else;fh="";end;while l=@in.read(16384);if l=~b;o<<$`.chomp;@in.seek(-$'.
+o.binmode;else;fh=""end;while l=@in.read(16384);if l=~b;o<<$`.chomp;@in.seek(-$'.
 size,IO::SEEK_CUR);break;end;o<<l;end;q[fn]=fh if fn;fh[:tempfile].rewind if
-fh.is_a?H;end;elsif @method=="post";q.u C.qs_parse(@in.read) end;@cookies,@input=
-@k.dup,q.dup end;def service *a;@body=send(@method,*a)if respond_to?@method
-@headers["Set-Cookie"]=@cookies.map{|k,v|"#{k}=#{C.escape(v)}; path=#{self/"/"}\
-" if v != @k[k]}.compact;self end;def to_s;"Status: #{@status}\n#{@headers.map{
-|k,v|[*v].map{|x|"#{k}: #{x}"}*"\n"}*"\n"}\n\n#{@body}" end;def markaby;Mab.new(
-instance_variables.map{|iv|[iv[1..-1],instance_variable_get(iv)]}) end;def 
-markaview m,*a,&b;h=markaby;h.send m,*a,&b;h.to_s end end;class R;include Base
-end;module Controllers;class NotFound;def get p;r(404,div{h1 "Cam\ping Problem!"
-h2 p+" not found"}) end end;class ServerError;include Base;def get k,m,e;r(500,
-Mab.new{h1 "Cam\ping Problem!";h2 "#{k}.#{m}";h3 "#{e.class} #{e.message}:";ul{
-e.backtrace.each{|bt|li(bt)}}}.to_s)end end;class<<self;def R *urls;Class.new(
-R){meta_def(:urls){urls}}end;def D path;constants.inject(nil){|d,c|k=const_get c
-k.meta_def(:urls){["/#{c.downcase}"]}if !(k<R);d||([k,$~[1..-1]]if k.urls.find{
-|x|path=~/^#{x}\/?$/})}||[NotFound,[path]] end end end;class<<self;def goes m
-eval(S.gsub(/Camping/,m.to_s),TOPLEVEL_BINDING)end;def escape s;s.to_s.gsub(
-/([^ a-zA-Z0-9_.-]+)/n){'%'+$1.unpack('H2'*$1.size).join('%').upcase}.tr ' ','+'
-end;def un s;s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){[$1.delete('%'
-)].pack('H*')} end;def qs_parse q,d='&;';m=proc{|_,o,n|o.u(n,&m)rescue([*o
-]<<n)};q.to_s.split(/[#{d}] */n).inject(H[]){|h,p|k,v=un(p).split('=',2)
-h.u k.split(/[\]\[]+/).reverse.inject(v){|x,i|H[i,x]},&m}end;def kp(s);c=
-qs_parse(s,';,')end;def run r=$stdin,e=ENV;k,a=Controllers.D un("/#{e['PATH_INFO']
-}".gsub(/\/+/,'/'));k.send:include,C,Base,Models;k.new(r,e,(m=e['REQUEST_METHOD'
-]||"GET")).service *a;rescue=>x;Controllers::ServerError.new(r,e,'get').service(
-k,m,x)end end;module Views;include Controllers,Helpers end;module Models;A=
-ActiveRecord;Base=A::Base;def Base.table_name_prefix;"#{name[/^(\w+)/,1]}_".
-downcase.sub(/^(#{A}|camping)_/i,'')end end;class Mab<Markaby::Builder;include \
-Views;def tag! *g,&b;h=g[-1];[:href,:action,:src].map{|a|(h[a]=self/h[a])rescue
+fh.is_a?H;end;elsif@method=="post";q.u C.qs_parse(@in.read)end;@cookies,@input=
+@k.dup,q.dup end;def service*a;@body=send(@method,*a)if respond_to?@method
+@headers["Set-Cookie"]=@cookies.map{|k,v|"#{k}=#{C.escape(v)}; path=#{self/'/'
+}"if v!=@k[k]}-[nil];self end;def to_s;"Status: #{@status}#{Z+@headers.map{|k,v|
+[*v].map{|x|"#{k}: #{x}"}}*Z+Z*2+@body}"end;end
+X=module Controllers;@r=[];class<<self;def r;@r;end;def R*u;r=@r;Class.new{
+meta_def(:urls){u};meta_def(:inherited){|x|r<<x}}end;def M;def M;end;constants.map{|c|
+k=const_get(c);k.send:include,C,Base,Models;r[0,0]=k if !r.include?k;k.meta_def(
+:urls){["/#{c.downcase}"]}if !k.respond_to?:urls}end;def D p;r.map{|k|k.urls.
+map{|x|return k,$~[1..-1]if p=~/^#{x}\/?$/}};[NotFound,[p]]end end;class 
+NotFound<R();def get p;r(404,Mab.new{h1 P;h2 p+" not found"})end end;class 
+ServerError<R();def get k,m,e;r(500,Mab.new{h1 P;h2"#{k}.#{m}";h3"#{e.class
+} #{e.message}:";ul{e.backtrace.each{|bt|li(bt)}}}.to_s)end end;self;end;class<<
+self;def goes m;eval S.gsub(/Camping/,m.to_s).gsub("A\pps=[]","Cam\ping::Apps<<\
+self"),TOPLEVEL_BINDING;end;def escape s;s.to_s.gsub(/[^ \w.-]+/n){'%'+($&.
+unpack('H2'*$&.size)*'%').upcase}.tr(' ','+')end;def un s;s.tr('+',' ').gsub(
+/%([\da-f]{2})/in){[$1].pack('H*')}end;def qs_parse q,d='&;';m=proc{|_,o,n|o.u(
+n,&m)rescue([*o]<<n)};q.to_s.split(/[#{d}] */n).inject(H[]){|h,p|k,v=un(p).
+split('=',2);h.u k.split(/[\]\[]+/).reverse.inject(v){|x,i|H[i,x]},&m}end;def
+kp s;c=qs_parse(s,';,')end;def run r=$stdin,e=ENV;X.M;k,a=X.D un("/#{e[
+'PATH_INFO']}".gsub(/\/+/,'/'));k.new(r,e,(m=e['REQUEST_METHOD']||"GET")).Y.
+service *a;rescue Exception=>x;X::ServerError.new(r,e,'get').service(k,m,x)end
+def method_missing m,c,*a;X.M;k=X.const_get(c).new(StringIO.new,H['HTTP_HOST',
+'','SCRIPT_NAME','','HTTP_COOKIE',''],m.to_s);H.new(a.pop).each{|e,f|k.send(
+"#{e}=",f)}if Hash===a[-1];k.service *a;end;end;module Views;include X,Helpers
+end;module Models;autoload:Base,'camping/db';def Y;self;end;end;class Mab<Markaby::Builder
+include Views;def tag!*g,&b;h=g[-1];[:href,:action,:src].map{|a|(h[a]=self/h[a])rescue
 0};super end end;H=HashWithIndifferentAccess;class H;def method_missing m,*a
-if m.to_s=~/=$/;self[$`]=a[0];elsif a.empty?;self[m];else;raise NoMethodError,
-"#{m}" end end;alias_method:u,:regular_update;end end
+m.to_s=~/=$/?self[$`]=a[0]:a==[]?self[m]:raise(NoMethodError,"#{m}")end
+alias_method:u,:regular_update;end end

data/lib/camping/db.rb

@@ -0,0 +1,78 @@
+class MissingLibrary < Exception #:nodoc: all
+end
+begin
+    require 'active_record'
+rescue LoadError => e
+    raise MissingLibrary, "ActiveRecord could not be loaded (is it installed?): #{e.message}"
+end
+
+$AR_EXTRAS = %{
+  Base = ActiveRecord::Base unless const_defined? :Base
+
+  def Y; ActiveRecord::Base.verify_active_connections!; self; end
+
+  class SchemaInfo < Base
+  end
+
+  def self.V(n)
+    @final = [n, @final.to_i].max
+    m = (@migrations ||= [])
+    Class.new(ActiveRecord::Migration) do
+      meta_def(:version) { n }
+      meta_def(:inherited) { |k| m << k }
+    end
+  end
+
+  def self.create_schema(opts = {})
+    opts[:assume] ||= 0
+    opts[:version] ||= @final
+    if @migrations
+      unless SchemaInfo.table_exists?
+        ActiveRecord::Schema.define do
+          create_table SchemaInfo.table_name do |t|
+            t.column :version, :float
+          end
+        end
+      end
+
+      si = SchemaInfo.find(:first) || SchemaInfo.new(:version => opts[:assume])
+      if si.version < opts[:version]
+        @migrations.each do |k|
+          k.migrate(:up) if si.version < k.version and k.version <= opts[:version]
+          k.migrate(:down) if si.version > k.version and k.version > opts[:version]
+        end
+        si.update_attributes(:version => opts[:version])
+      end
+    end
+  end
+}
+
+module Camping
+  module Models
+    A = ActiveRecord
+    # Base is an alias for ActiveRecord::Base.  The big warning I'm going to give you
+    # about this: *Base overloads table_name_prefix.*  This means that if you have a
+    # model class Blog::Models::Post, it's table name will be <tt>blog_posts</tt>.
+    #
+    # ActiveRecord is not loaded if you never reference this class.  The minute you
+    # use the ActiveRecord or Camping::Models::Base class, then the ActiveRecord library
+    # is loaded.
+    Base = A::Base
+
+    # The default prefix for Camping model classes is the topmost module name lowercase
+    # and followed with an underscore.
+    #
+    #   Tepee::Models::Page.table_name_prefix
+    #     #=> "tepee_pages"
+    #
+    def Base.table_name_prefix
+        "#{name[/\w+/]}_".downcase.sub(/^(#{A}|camping)_/i,'')
+    end
+    module_eval $AR_EXTRAS
+  end
+end
+Camping::S.sub! "autoload:Base,'camping/db'", ""
+Camping::S.sub! "def Y;self;end", $AR_EXTRAS
+Camping::Apps.each do |app|
+    app::Models.module_eval $AR_EXTRAS
+end

data/lib/camping/fastcgi.rb

@@ -0,0 +1,198 @@
+# == About camping/fastcgi.rb
+#
+# Camping works very well with FastCGI, since your application is only loaded
+# once -- when FastCGI starts.  In addition, this class lets you mount several
+# Camping apps under a single FastCGI process, to help save memory costs.
+#
+# So where do you use the Camping::FastCGI class?  Use it in your application's
+# postamble and then you can point your web server directly at your application.
+# See Camping::FastCGI docs for more.
+require 'camping'
+require 'fcgi'
+
+module Camping
+# Camping::FastCGI is a small class for hooking one or more Camping apps up to
+# FastCGI.  Generally, you'll use this class in your application's postamble.
+#
+# == The Smallest Example
+#
+#  if __FILE__ == $0
+#    require 'camping/fastcgi'
+#    Camping::FastCGI.start(YourApp)
+#  end
+#
+# This example is stripped down to the basics.  The postamble has no database
+# connection.  It just loads this class and calls Camping::FastCGI.start.
+#
+# Now, in Lighttpd or Apache, you can point to your app's file, which will
+# be executed, only to discover that your app now speaks the FastCGI protocol.
+#
+# Here's a sample lighttpd.conf (tested with Lighttpd 1.4.11) to serve as example:
+#
+#   server.port                 = 3044
+#   server.bind                 = "127.0.0.1"
+#   server.modules              = ( "mod_fastcgi" )
+#   server.document-root        = "/var/www/camping/blog/" 
+#   server.errorlog             = "/var/www/camping/blog/error.log" 
+#   
+#   #### fastcgi module
+#   fastcgi.server = ( "/" => ( 
+#     "localhost" => ( 
+#       "socket" => "/tmp/camping-blog.socket",
+#       "bin-path" => "/var/www/camping/blog/blog.rb",
+#       "check-local" => "disable",
+#       "max-procs" => 1 ) ) )
+#
+# The file <tt>/var/www/camping/blog/blog.rb</tt> is the Camping app with
+# the postamble.
+#
+# == Mounting Many Apps
+#
+#  require 'camping/fastcgi'
+#  fast = Camping::FastCGI.new
+#  fast.mount("/blog", Blog)
+#  fast.mount("/tepee", Tepee)
+#  fast.mount("/", Index)
+#  fast.start
+#
+class FastCGI
+    CHUNK_SIZE=(4 * 1024)
+
+    # Creates a Camping::FastCGI class with empty mounts.
+    def initialize
+        @mounts = {}
+    end
+    # Mounts a Camping application.  The +dir+ being the name of the directory
+    # to serve as the application's root.  The +app+ is a Camping class.
+    def mount(dir, app)
+        dir.gsub!(/\/{2,}/, '/')
+        dir.gsub!(/\/+$/, '')
+        @mounts[dir] = app
+    end
+    # 
+    # Starts the FastCGI main loop.
+    def start
+        FCGI.each do |req|
+            dir, app = nil
+            begin
+                root, path = "/"
+                if ENV['FORCE_ROOT'] and ENV['FORCE_ROOT'].to_i == 1
+                  path = req.env['REQUEST_URI']
+                else
+                  root = req.env['SCRIPT_NAME']
+                  path = req.env['PATH_INFO']
+                end
+
+                dir, app = @mounts.max { |a,b| match(path, a[0]) <=> match(path, b[0]) }
+                unless dir and app
+                    dir, app = '/', Camping
+                end
+                yield dir, app if block_given?
+
+                req.env['SERVER_SCRIPT_NAME'] = req.env['SCRIPT_NAME']
+                req.env['SERVER_PATH_INFO'] = req.env['PATH_INFO']
+                req.env['SCRIPT_NAME'] = File.join(root, dir)
+                req.env['PATH_INFO'] = path.gsub(/^#{dir}/, '')
+
+                controller = app.run(req.in, req.env)
+                sendfile = nil
+                headers = {}
+                controller.headers.each do |k, v|
+                  if k =~ /^X-SENDFILE$/i and !ENV['SERVER_X_SENDFILE']
+                    sendfile = v
+                  else
+                    headers[k] = v
+                  end
+                end
+
+                body = controller.body
+                controller.body = ""
+                controller.headers = headers
+
+                req.out << controller.to_s
+                if sendfile
+                  File.open(sendfile, "rb") do |f|
+                    while chunk = f.read(CHUNK_SIZE) and chunk.length > 0
+                      req.out << chunk
+                    end
+                  end
+                elsif body.respond_to? :read
+                  while chunk = body.read(CHUNK_SIZE) and chunk.length > 0
+                    req.out << chunk
+                  end
+                  body.close if body.respond_to? :close
+                else
+                  req.out << body.to_s
+                end
+            rescue Exception => e
+                req.out << "Content-Type: text/html\r\n\r\n" +
+                    "<h1>Camping Problem!</h1>" +
+                    "<h2><strong>#{root}</strong>#{path}</h2>" + 
+                    "<h3>#{e.class} #{esc e.message}</h3>" +
+                    "<ul>" + e.backtrace.map { |bt| "<li>#{esc bt}</li>" }.join + "</ul>" +
+                    "<hr /><p>#{req.env.inspect}</p>"
+            ensure
+                req.finish
+            end
+        end
+    end
+
+    # A simple single-app starter mechanism
+    #
+    #   Camping::FastCGI.start(Blog)
+    #
+    def self.start(app)
+        cf = Camping::FastCGI.new
+        cf.mount("/", app)
+        cf.start
+    end
+
+    # Serve an entire directory of Camping apps. (See 
+    # http://code.whytheluckystiff.net/camping/wiki/TheCampingServer.)
+    #
+    # Use this method inside your FastCGI dispatcher:
+    #
+    #   #!/usr/local/bin/ruby
+    #   require 'rubygems'
+    #   require 'camping/fastcgi'
+    #   Camping::Models::Base.establish_connection :adapter => 'sqlite3', :database => "/path/to/db"
+    #   Camping::FastCGI.serve("/home/why/cvs/camping/examples")
+    # 
+    def self.serve(path, index=nil)
+        require 'camping/reloader'
+        if File.directory? path
+            fast = Camping::FastCGI.new
+            script_load = proc do |script|
+                app = Camping::Reloader.new(script)
+                fast.mount("/#{app.mount}", app)
+                app
+            end
+            Dir[File.join(path, '*.rb')].each &script_load
+            fast.mount("/", index) if index
+
+            fast.start do |dir, app|
+                 Dir[File.join(path, dir, '*.rb')].each do |script|
+                     smount = "/" + File.basename(script, '.rb')
+                     script_load[script] unless @mounts.has_key? smount
+                 end
+            end
+        else
+            start(Camping::Reloader.new(path))
+        end
+    end
+
+    private
+
+    def match(path, mount)
+        m = path.match(/^#{Regexp::quote mount}(\/|$)/)
+        if m; m.end(0)
+        else  -1
+        end
+    end
+
+    def esc(str)
+        str.gsub(/&/n, '&amp;').gsub(/\"/n, '&quot;').gsub(/>/n, '&gt;').gsub(/</n, '&lt;')
+    end
+
+end
+end

data/lib/camping/reloader.rb

@@ -0,0 +1,169 @@
+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
+
+                begin
+                    Camping::Models::Session.create_schema
+                rescue MissingSourceFile
+                    puts "** #$0 stopped: SQLite3 not found, please install."
+                    puts "** See http://code.whytheluckystiff.net/camping/wiki/BeAlertWhenOnSqlite3 for instructions."
+                    exit
+                end
+
+                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