camping 1.5.180 → 2.0.rc0

data/lib/camping.rb

@@ -1,55 +1,40 @@
-%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,h=/\(.+?\)/,g.grep(Hash)
-(g-=h).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))}+(h.any?? "?"+h[0].map{|x|x.map{|z|C.
-escape z}*"="}*"&": "")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.capture{send(: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 to_a;[@status,@body,@headers]end
-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.qsp 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(-$'.
-size,IO::SEEK_CUR);break;end;o<<l;end;C.qsp(fn,'&;',fh,q) if fn;fh[:tempfile].rewind if
-fh.is_a?H;end;elsif@method=="post";q.u C.qsp(@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;a=[];@headers.map{|k,v|[*v].map{|x|a<<
-"#{k}: #{x}"}};"Status: #{@status}#{Z+a*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 qsp q,d='&;',y=nil,z=H[];m=proc{|_,o,n|o.u(
-n,&m)rescue([*o]<<n)};q.to_s.split(/[#{d}] */n).inject((b,z=z,H[])[0]){|h,p|k,v=un(p).
-split('=',2);h.u k.split(/[\]\[]+/).reverse.inject(y||v){|x,i|H[i,x]},&m}end;def
-kp s;c=qsp(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 Object=>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
-m.to_s=~/=$/?self[$`]=a[0]:a==[]?self[m]:raise(NoMethodError,"#{m}")end
-alias_method:u,:regular_update;end end
+require "uri";require "rack";class Object;def meta_def m,&b;(class<<self;self
+end).send:define_method,m,&b end end;module Camping;C=self;S=IO.read(__FILE__
+)rescue nil;P="<h1>Cam\ping Problem!</h1><h2>%s</h2>";U=Rack::Utils;Apps=[]
+class H<Hash;def method_missing m,*a;m.to_s=~/=$/?self[$`]=a[0]:a==[]?self[m.
+to_s]:super end;undef id,type if ??==63;end;module Helpers;def R c,*g;p,h=
+/\(.+?\)/,g.grep(Hash);g-=h;raise"bad route"unless u=c.urls.find{|x|break x if
+x.scan(p).size==g.size&&/^#{x}\/?$/=~(x=g.inject(x){|x,a|x.sub p,U.escape((a[
+a.class.primary_key]rescue a))})};h.any?? u+"?"+U.build_query(h[0]):u end;def
+/ p;p[0]==?/?@root + p : p end;def URL c='/',*a;c=R(c, *a) if c.respond_to?(
+:urls);c=self/c;c=@request.url[/.{8,}?(?=\/)/]+c if c[0]==?/;URI c end end
+module Base;attr_accessor:env,:request,:root,:input,:cookies,:state,:status,
+:headers,:body;def render v,*a,&b;mab(/^_/!~v.to_s){send(v,*a,&b)} end;def
+mab l=nil,&b;m=Mab.new({},self);s=m.capture(&b);s=m.capture{layout{s}} if l &&
+m.respond_to?(:layout);s end;def r s,b,h={};b,h=h,b if Hash===b;@status=s;
+@headers.merge!(h);@body=b;end;def redirect *a;r 302,'','Location'=>URL(*a).
+to_s;end;def r404 p;P%"#{p} not found"end;def r500 k,m,e;raise e;end;def r501 m
+P%"#{m.upcase} not implemented"end;def to_a;@env['rack.session']=@state;r=Rack::
+Response.new(@body,@status,@headers);@cookies.each{|k,v|next if @old_cookies[
+k]==v;v={:value=>v,:path=>self/"/"} if String===v;r.set_cookie(k,v)};r.to_a;end
+def initialize(env,m) r=@request=Rack::Request.new(@env=env);@root,@input,
+@cookies,@state,@headers,@status,@method=r.script_name.sub(/\/$/,''),n(r.params
+),H[@old_cookies = r.cookies],H[r.session],{},m=~/r(\d+)/?$1.to_i: 200,m end;def
+n h;Hash===h ?h.inject(H[]){|m,(k,v)|m[k]=n(v);m}: h end;def service *a;r=catch(
+:halt){send(@method,*a)};@body||=r;self;end;end;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 D p,m;p='/'if !p||!p[0];r.map{|k|k.urls.map{|x|return(k.
+instance_method(m)rescue nil)?[k,m,*$~[1..-1]]:[I,'r501',m]if p=~/^#{x}\/?$/}}
+[I,'r404',p] end;N=H.new{|_,x|x.downcase}.merge! "N"=>'(\d+)',"X"=>'([^/]+)',
+"Index"=>'';def M;def M;end;constants.map{|c|k=const_get(c);k.send:include,C,
+Base,Helpers,Models;@r=[k]+r if r-[k]==r;k.meta_def(:urls){ [ "/#{c.scan(
+/.[^A-Z]*/).map(&N.method(:[]))*'/'}"]}if !k.respond_to?:urls}end end;I=R()
+end;X=Controllers;class<<self;def goes m;Apps<<eval(S.gsub(/Camping/,m.to_s),
+TOPLEVEL_BINDING) end;def call e;X.M;p=e['PATH_INFO']=U.unescape(e['PATH_INFO'])
+k,m,*a=X.D p,e['REQUEST_METHOD'].downcase;k.new(e,m).service(*a).to_a;rescue
+r500(:I,k,m,$!,:env=>e).to_a;end;def method_missing m,c,*a;X.M;h=Hash===a[-1]?
+a.pop: {};e=H[Rack::MockRequest.env_for('',h.delete(:env)||{})];k=X.const_get(c
+).new(e,m.to_s);h.each{|i,v|k.send"#{i}=",v};k.service(*a);end;def use*a,&b;m=a.
+shift.new(method(:call),*a,&b);meta_def(:call){|e|m.call(e)}end end;module Views
+include X,Helpers end;module Models;autoload:Base,
+'camping/ar';end;autoload:Mab,'camping/mab';C end

data/lib/camping/{db.rb → ar.rb}

@@ -9,13 +9,11 @@ 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
+    @final = [n, @final.to_f].max
     m = (@migrations ||= [])
     Class.new(ActiveRecord::Migration) do
       meta_def(:version) { n }
@@ -37,7 +35,7 @@ $AR_EXTRAS = %{
 
       si = SchemaInfo.find(:first) || SchemaInfo.new(:version => opts[:assume])
       if si.version < opts[:version]
-        @migrations.each do |k|
+        @migrations.sort_by { |m| m.version }.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
@@ -71,8 +69,7 @@ module Camping
     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
+Camping::S.sub! /autoload\s*:Base\s*,\s*['"]camping\/ar['"]/, $AR_EXTRAS
+Camping::Apps.each do |c|
+  c::Models.module_eval $AR_EXTRAS
 end

data/lib/camping/mab.rb

@@ -0,0 +1,26 @@
+class MissingLibrary < Exception #:nodoc: all
+end
+begin
+    require 'markaby'
+rescue LoadError => e
+    raise MissingLibrary, "Markaby could not be loaded (is it installed?): #{e.message}"
+end
+
+$MAB_CODE = %{
+  # The Mab class wraps Markaby, allowing it to run methods from Camping::Views
+  # and also to replace :href, :action and :src attributes in tags by prefixing the root
+  # path.
+  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
+}
+
+Camping::S.sub! /autoload\s*:Mab\s*,\s*['"]camping\/mab['"]/, $MAB_CODE
+Camping::Apps.each do |c|
+  c.module_eval $MAB_CODE
+end

data/lib/camping/reloader.rb

@@ -1,163 +1,191 @@
 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
+  # == 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::Server 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'
+  #   reloader = Camping::Reloader.new('/path/to/yourapp.rb')
+  #   blog = reloader.apps[:Blog]
+  #   wiki = reloader.apps[:Wiki]
+  #
+  # The <tt>blog</tt> and <tt>wiki</tt> objects will behave exactly like your
+  # Blog and Wiki, but they will update themselves if yourapp.rb changes.
+  #
+  # You can also give Reloader more than one script.
+  class Reloader
+    attr_reader :scripts
+    
+    # This is a simple wrapper which causes the script to reload (if needed)
+    # on any method call.  Then the method call will be forwarded to the
+    # app.
+    class App < (defined?(BasicObject) ? BasicObject : Object) # :nodoc:
+      if superclass == ::Object
+        instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+      end
+      
+      attr_accessor :app, :script
+      
+      def initialize(script)
+        @script = script
+      end
+      
+      # Reloads if needed, before calling the method on the app.
+      def method_missing(meth, *args, &blk)
+        @script.reload!
+        @app.send(meth, *args, &blk)
+      end
     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 /_/,'' 
+    
+    # This class is doing all the hard work; however, it only works on
+    # single files.  Reloader just wraps up support for multiple scripts
+    # and hides away some methods you normally won't need.
+    class Script # :nodoc:
+      attr_reader :apps, :file, :dir, :extras
+      
+      def initialize(file)
+        @file = File.expand_path(file)
+        @dir = File.dirname(@file)
+        @extras = File.join(@dir, File.basename(@file, ".rb"))
+        @mtime = Time.at(0)
+        @requires = []
+        @apps = {}
+      end
+      
+      # Loads the apps availble in this script.  Use <tt>apps</tt> to get
+      # the loaded apps.
+      def load_apps
+        all_requires = $LOADED_FEATURES.dup
+        all_apps = Camping::Apps.dup
+        
         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
+          load(@file)
         rescue Exception => e
-            puts "!! trouble loading #{title}: [#{e.class}] #{e.message}"
-            puts e.backtrace.join("\n")
-            find_app title
-            remove_app
-            return
+          puts "!! Error loading #{@file}:"
+          puts "#{e.class}: #{e.message}"
+          puts e.backtrace
+          puts "!! Error loading #{@file}, see backtrace above"
         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
+        
+        @requires = ($LOADED_FEATURES - all_requires).map do |req|
+          full = full_path(req)
+          full if full == @file or full.index(@extras) == 0
         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) }
+        @mtime = mtime
+        
+        new_apps = (Camping::Apps - all_apps)
+        old_apps = @apps.dup
+        @apps = new_apps.inject({}) do |hash, app|
+          key = app.name.to_sym
+          hash[key] = (old = old_apps[key]) || App.new(self)
+          hash[key].app = app
+          app.create if app.respond_to?(:create) && !old
+          hash
         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) 
+        self
+      end
+      
+      # Removes all the apps defined in this script.
+      def remove_apps
+        @apps.each do |name, app|
+          Camping::Apps.delete(app.app)
+          Object.send :remove_const, name
+        end
+      end
+      
+      # Reloads the file if needed.  No harm is done by calling this multiple
+      # times, so feel free call just to be sure.
+      def reload!
+        return if @mtime >= mtime
+        remove_apps
+        load_apps
+      end
+      
+      # Checks if both scripts watches the same file.
+      def ==(other)
+        @file == other.file
+      end
+      
+      private
+      
+      def mtime
+        (@requires + [@file]).compact.map do |fname|
+          File.mtime(fname)
+        end.reject{|t| t > Time.now }.max
+      end
+      
+      # Figures out the full path of a required file. 
+      def full_path(req)
+        dir = $LOAD_PATH.detect { |l| File.exists?(File.join(l, req)) }
+        if dir 
+          File.join(File.expand_path(dir), req)
         else
-            Camping.run(*a)
+          req
         end
+      end
     end
 
-    # Returns source code for the main script in the application.
-    def view_source
-        File.read(@script)
+    # 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(*scripts)
+      @scripts = []
+      update(*scripts)
     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
+    
+    # Updates the reloader to only use the scripts provided:
+    #
+    #   reloader.update("examples/blog.rb", "examples/wiki.rb")
+    def update(*scripts)
+      old = @scripts.dup
+      clear
+      @scripts = scripts.map do |script|
+        s = Script.new(script)
+        if pos = old.index(s)
+          # We already got a script, so we use the old (which might got a mtime)
+          old[pos]
+        else
+          s.load_apps
         end
+      end
     end
-end
+    
+    # Removes all the scripts from the reloader.
+    def clear
+      @scrips = []
+    end
+    
+    # Simply calls reload! on all the Script objects.
+    def reload!
+      @scripts.each { |script| script.reload! }
+    end
+    
+    # Returns a Hash of all the apps available in the scripts, where the key
+    # would be the name of the app (the one you gave to Camping.goes) and the
+    # value would be the app (wrapped inside App).
+    def apps
+      @scripts.inject({}) do |hash, script|
+        hash.merge(script.apps)
+      end
+    end
+  end
 end