camping 1.4.2 → 1.5

data/lib/camping-unabridged.rb

@@ -28,7 +28,7 @@
 # http://rubyforge.org/projects/mongrel  Mongrel comes with examples
 # in its <tt>examples/camping</tt> directory. 
 #
-%w[rubygems active_record markaby metaid tempfile uri].each { |lib| require lib }
+%w[active_support markaby tempfile uri].each { |lib| require lib }
 
 # == Camping 
 #
@@ -42,28 +42,25 @@
 #
 # * Camping::Helpers which can be used in controllers and views.
 #
-# == The postamble
+# == The Camping Server
 #
-# Most Camping applications contain the entire application in a single script.
-# The script begins by requiring Camping, then fills each of the three modules
-# described above with classes and methods.  Finally, a postamble puts the wheels
-# in motion.
+# How do you run Camping apps?  Oh, uh... The Camping Server!
 #
-#   if __FILE__ == $0
-#     Camping::Models::Base.establish_connection :adapter => 'sqlite3',
-#         :database => 'blog3.db'
-#     Camping::Models::Base.logger = Logger.new('camping.log')
-#     Camping.create if Camping.respond_to? :create
-#     puts Camping.run
-#   end
+# The Camping Server is, firstly and thusly, a set of rules.  At the very least, The Camping Server must:
 #
-# In the postamble, your job is to setup Camping::Models::Base (see: ActiveRecord::Base) 
-# and call Camping::run in a request loop.  The above postamble is for a standard
-# CGI setup, where the web server manages the request loop and calls the script once
-# for every request.
+# * Load all Camping apps in a directory.
+# * Load new apps that appear in that directory.
+# * Mount those apps according to their filename. (e.g. blog.rb is mounted at /blog.)
+# * Run each app's <tt>create</tt> method upon startup.
+# * Reload the app if its modification time changes.
+# * Reload the app if it requires any files under the same directory and one of their modification times changes.
+# * Support the X-Sendfile header. 
 #
-# For other configurations, see 
-# http://code.whytheluckystiff.net/camping/wiki/PostAmbles
+# In fact, Camping comes with its own little The Camping Server.
+#
+# At a command prompt, run: <tt>camping examples/</tt> and the entire <tt>examples/</tt> directory will be served.
+#
+# Configurations also exist for Apache and Lighttpd.  See http://code.whytheluckystiff.net/camping/wiki/TheCampingServer.
 #
 # == The <tt>create</tt> method
 #
@@ -86,9 +83,17 @@
 #
 # For more tips, see http://code.whytheluckystiff.net/camping/wiki/GiveUsTheCreateMethod.
 module Camping
+  # Stores an +Array+ of all Camping applications modules.  Modules are added
+  # automatically by +Camping.goes+.
+  #
+  #   Camping.goes :Blog
+  #   Camping.goes :Tepee
+  #   Camping::Apps # => [Blog, Tepee]
+  # 
+  Apps = []
   C = self
-  F = __FILE__
-  S = IO.read(F).gsub(/_+FILE_+/,F.dump)
+  S = IO.read(__FILE__).sub(/^  S = I.+$/,'')
+  P="Cam\ping Problem!"
 
   H = HashWithIndifferentAccess
   # An object-like Hash, based on ActiveSupport's HashWithIndifferentAccess.
@@ -113,15 +118,16 @@ module Camping
   # to get the value for the <tt>page</tt> query variable.
   #
   # Use the <tt>@cookies</tt> variable in the same fashion to access cookie variables.
+  # Also, the <tt>@env</tt> variable is an H containing the HTTP headers and server info.
   class H
+    # Gets or sets keys in the hash.
+    #
+    #   @cookies.my_favorite = :macadamian
+    #   @cookies.my_favorite
+    #   => :macadamian
+    #
     def method_missing(m,*a)
-        if m.to_s =~ /=$/
-            self[$`] = a[0]
-        elsif a.empty?
-            self[m]
-        else
-            raise NoMethodError, "#{m}"
-        end
+        m.to_s=~/=$/?self[$`]=a[0]:a==[]?self[m]:raise(NoMethodError,"#{m}")
     end
     alias_method :u, :regular_update
   end
@@ -190,18 +196,19 @@ module Camping
     # is assigned to route <tt>/logout</tt>.  The HTML will come out as:
     #
     #   <div id="menu">
-    #     <a href="http://localhost:3301/frodo/">Home</a>
+    #     <a href="//localhost:3301/frodo/">Home</a>
     #     <a href="/frodo/profile">Profile</a>
     #     <a href="/frodo/logout">Logout</a>
     #     <a href="http://google.com">Google</a>
     #   </div>
     #
-    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)
+    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
+
     # Shows AR validation errors for the object passed. 
     # There is no output if there are no errors.
     #
@@ -221,8 +228,8 @@ module Camping
     #
     # See AR validation documentation for details on validations.
     def errors_for(o); ul.errors { o.errors.each_full { |er| li er } } if o.errors.any?; end
-    # Simply builds the complete URL from a relative or absolute path +p+.  If your
-    # application is running from <tt>/blog</tt>:
+    # Simply builds a complete path from a path +p+ within the app.  If your application is 
+    # mounted at <tt>/blog</tt>:
     #
     #   self / "/view/1"    #=> "/blog/view/1"
     #   self / "styles.css" #=> "styles.css"
@@ -231,18 +238,23 @@ module Camping
     def /(p); p[/^\//]?@root+p:p end
     # Builds a URL route to a controller or a path, returning a URI object.
     # This way you'll get the hostname and the port number, a complete URL.
+    # No scheme is given (http or https).
     #
     # You can use this to grab URLs for controllers using the R-style syntax.
     # So, if your application is mounted at <tt>http://test.ing/blog/</tt>
     # and you have a View controller which routes as <tt>R '/view/(\d+)'</tt>:
     #
-    #   URL(View, @post.id)    #=> #<URI:http://test.ing/blog/view/12>
+    #   URL(View, @post.id)    #=> #<URL://test.ing/blog/view/12>
     #
     # Or you can use the direct path:
     #
-    #   self.URL               #=> #<URI:http://test.ing/blog/>
-    #   self.URL + "view/12"   #=> #<URI:http://test.ing/blog/view/12>
-    #   URL("/view/12")        #=> #<URI:http://test.ing/blog/view/12>
+    #   self.URL               #=> #<URL://test.ing/blog/>
+    #   self.URL + "view/12"   #=> #<URL://test.ing/blog/view/12>
+    #   URL("/view/12")        #=> #<URL://test.ing/blog/view/12>
+    #
+    # Since no scheme is given, you will need to add the scheme yourself:
+    #
+    #   "http" + URL("/view/12")   #=> "http://test.ing/blog/view/12"
     #
     # It's okay to pass URL strings through this method as well:
     #
@@ -294,6 +306,8 @@ module Camping
   module Base
     include Helpers
     attr_accessor :input, :cookies, :env, :headers, :body, :status, :root
+    Z = "\r\n"
+
     # Display a view, calling it by its method name +m+.  If a <tt>layout</tt>
     # method is found in Camping::Views, it will be used to wrap the HTML.
     #
@@ -319,10 +333,12 @@ module Camping
     #
     # If you have a <tt>layout</tt> method in Camping::Views, it will be used to
     # wrap the HTML.
-    def method_missing(m, *a, &b)
-      str = m==:render ? markaview(*a, &b):eval("markaby.#{m}(*a, &b)")
-      str = markaview(:layout) { str } if Views.method_defined? :layout
-      r(200, str.to_s)
+    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
 
     # Formulate a redirect response: a 302 status with <tt>Location</tt> header
@@ -331,9 +347,12 @@ module Camping
     #
     # So, given a root of <tt>http://localhost:3301/articles</tt>:
     #
-    #   redirect "view/12"    # redirects to "http://localhost:3301/articles/view/12"
-    #   redirect View, 12     # redirects to "http://localhost:3301/articles/view/12"
+    #   redirect "view/12"    # redirects to "//localhost:3301/articles/view/12"
+    #   redirect View, 12     # redirects to "//localhost:3301/articles/view/12"
     #
+    # <b>NOTE:</b> This method doesn't magically exit your methods and redirect.
+    # You'll need to <tt>return redirect(...)</tt> if this isn't the last statement
+    # in your code.
     def redirect(*a)
       r(302,'','Location'=>URL(*a))
     end
@@ -362,7 +381,7 @@ module Camping
           fh=H[]
           for l in @in
             case l
-            when "\r\n": break
+            when Z: break
             when /^Content-Disposition: form-data;/
               fh.u H[*$'.scan(/(?:\s(\w+)="([^"]+)")/).flatten]
             when /^Content-Type: (.+?)(\r$|\Z)/m
@@ -394,27 +413,24 @@ module Camping
       @cookies, @input = @k.dup, qs.dup
     end
 
-    def service(*a) #:nodoc:
+    # All requests pass through this method before going to the controller.  Some magic
+    # in Camping can be performed by overriding this method.
+    #
+    # See http://code.whytheluckystiff.net/camping/wiki/BeforeAndAfterOverrides for more
+    # on before and after overrides with Camping.
+    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
+      @headers['Set-Cookie'] = @cookies.map { |k,v| "#{k}=#{C.escape(v)}; path=#{self/"/"}" if v != @k[k] } - [nil]
       self
     end
-    def to_s #:nodoc:
-      "Status: #{@status}\n#{@headers.map{|k,v|[*v].map{|x|"#{k}: #{x}"}*"\n"}*"\n"}\n\n#{@body}"
-    end
-    def markaby #:nodoc:
-        Mab.new( instance_variables.map { |iv| 
-          [iv[1..-1], instance_variable_get(iv)] } )
-    end
-    def markaview(m, *a, &b) #:nodoc:
-      h=markaby
-      h.send(m, *a, &b)
-      h.to_s
+
+    # Used by the web server to convert the current request to a string.  If you need to
+    # alter the way Camping builds HTTP headers, consider overriding this method.
+    def to_s
+      "Status: #{@status}#{Z+@headers.map{|k,v|[*v].map{|x|"#{k}: #{x}"}}*Z+Z*2+@body}"
     end
-  end
 
-  # The R class is the parent class for all routed controllers.
-  class R; include Base end
+  end
 
   # Controllers is a module for placing classes which handle URLs.  This is done
   # by defining a route to each class using the Controllers::R method.
@@ -436,6 +452,79 @@ module Camping
   # NotFound class handles URLs not found.  The ServerError class handles exceptions
   # uncaught by your application.
   module Controllers
+    @r = []
+    class << self
+      def r #:nodoc:
+        @r
+      end
+      # Add routes to a controller class by piling them into the R method.
+      #
+      #   module Camping::Controllers
+      #     class Edit < R '/edit/(\d+)', '/new'
+      #       def get(id)
+      #         if id   # edit
+      #         else    # new
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      # You will need to use routes in either of these cases:
+      #
+      # * You want to assign multiple routes to a controller.
+      # * You want your controller to receive arguments.
+      #
+      # Most of the time the rules inferred by dispatch method Controllers::D will get you
+      # by just fine.
+      def R *u
+        r=@r
+        Class.new {
+          meta_def(:urls){u}
+          meta_def(:inherited){|x|r<<x}
+        }
+      end
+
+      # Dispatch routes to controller classes.
+      # For each class, routes are checked for a match based on their order in the routing list
+      # given to Controllers::R.  If no routes were given, the dispatcher uses a slash followed
+      # by the name of the controller lowercased.
+      #
+      # Controllers are searched in this order:
+      #
+      # # Classes without routes, since they refer to a very specific URL.
+      # # Classes with routes are searched in order of their creation.
+      #
+      # So, define your catch-all controllers last.
+      def D(path)
+        r.map { |k|
+          k.urls.map { |x|
+            return k, $~[1..-1] if path =~ /^#{x}\/?$/
+          }
+        }
+        [NotFound, [path]]
+      end
+
+      # The route maker, this is called by Camping internally, you shouldn't need to call it.
+      #
+      # Still, it's worth know what this method does.  Since Ruby doesn't keep track of class
+      # creation order, we're keeping an internal list of the controllers which inherit from R().
+      # This method goes through and adds all the remaining routes to the beginning of the list
+      # and ensures all the controllers have the right mixins.
+      #
+      # Anyway, if you are calling the URI dispatcher from outside of a Camping server, you'll
+      # definitely need to call this at least once to set things up.
+      def M
+        def M #:nodoc:
+        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
+    end
+
     # The NotFound class is a special controller class for handling 404 errors, in case you'd
     # like to alter the appearance of the 404.  The path is passed in as +p+.
     #
@@ -451,7 +540,11 @@ module Camping
     #     end
     #   end
     #
-    class NotFound; def get(p); r(404, div{h1("Cam\ping Problem!");h2("#{p} not found")}); end end
+    class NotFound < R()
+      def get(p)
+        r(404, Mab.new{h1(P);h2("#{p} not found")})
+      end
+    end
 
     # The ServerError class is a special controller class for handling many (but not all) 500 errors.
     # If there is a parse error in Camping or in your application's source code, it will not be caught
@@ -476,43 +569,18 @@ module Camping
     #     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
-      # Add routes to a controller class by piling them into the R method.
-      #
-      #   module Camping::Controllers
-      #     class Edit < R '/edit/(\d+)', '/new'
-      #       def get(id)
-      #         if id   # edit
-      #         else    # new
-      #         end
-      #       end
-      #     end
-      #   end
-      #
-      # You will need to use routes in either of these cases:
-      #
-      # * You want to assign multiple routes to a controller.
-      # * You want your controller to receive arguments.
-      #
-      # Most of the time the rules inferred by dispatch method Controllers::D will get you
-      # by just fine.
-      def R(*urls); Class.new(R) { meta_def(:urls) { urls } }; end
-
-      # Dispatch routes to controller classes.  Classes are searched in no particular order.
-      # For each class, routes are checked for a match based on their order in the routing list
-      # given to Controllers::R.  If no routes were given, the dispatcher uses a slash followed
-      # by the name of the controller lowercased.
-      def D(path)
-        constants.inject(nil) do |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}\/?$/ })
-        end||[NotFound, [path]]
+    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
   end
+  X = Controllers
 
   class << self
     # When you are running many applications, you may want to create independent
@@ -527,7 +595,7 @@ module Camping
     #   module Blog::Views;       ... end
     #
     def goes(m)
-        eval(S.gsub(/Camping/,m.to_s),TOPLEVEL_BINDING)
+      eval S.gsub(/Camping/,m.to_s).gsub("A\pps = []","Cam\ping::Apps<<self"), TOPLEVEL_BINDING
     end
 
     # URL escapes a string.
@@ -535,14 +603,14 @@ module Camping
     #   Camping.escape("I'd go to the museum straightway!")  
     #     #=> "I%27d+go+to+the+museum+straightway%21"
     #
+    def escape(s); s.to_s.gsub(/[^ \w.-]+/n){'%'+($&.unpack('H2'*$&.size)*'%').upcase}.tr(' ', '+') end
 
-    def escape(s); s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n){'%'+$1.unpack('H2'*$1.size).join('%').upcase}.tr(' ', '+') end
     # Unescapes a URL-encoded string.
     #
     #   Camping.un("I%27d+go+to+the+museum+straightway%21") 
     #     #=> "I'd go to the museum straightway!"
     #
-    def un(s); s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){[$1.delete('%')].pack('H*')} end
+    def un(s); s.tr('+', ' ').gsub(/%([\da-f]{2})/in){[$1].pack('H*')} end
 
     # Parses a query string into an Camping::H object.
     #
@@ -587,24 +655,40 @@ module Camping
     # at the center, passing in the read +r+ and write +w+ streams.  You will also need to mimick or
     # pass in the <tt>ENV</tt> replacement as part of your wrapper.
     #
-    #   if __FILE__ == $0
-    #     require 'fcgi'
-    #       Camping::Models::Base.establish_connection :adapter => 'sqlite3',
-    #           :database => 'blog3.db'
-    #       Camping::Models::Base.logger = Logger.new('camping.log')
-    #       FCGI.each do |req|
-    #         req.out << Camping.run req.in, req.env
-    #         req.finish
-    #       end
-    #     end
-    #   end
+    # See Camping::FastCGI and Camping::WEBrick for examples.
     #
     def run(r=$stdin,e=ENV)
-      k, a = Controllers.D un("/#{e['PATH_INFO']}".gsub(%r!/+!,'/'))
-      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)
+      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
+
+    # The Camping scriptable dispatcher.  Any unhandled method call to the app module will
+    # be sent to a controller class, specified as an argument.
+    #
+    #   Blog.get(:Index)
+    #   #=> #<Blog::Controllers::Index ... >
+    #
+    # The controller object contains all the @cookies, @body, @headers, etc. formulated by
+    # the response.
+    #
+    # You can also feed environment variables and query variables as a hash, the final
+    # argument.
+    #
+    #   Blog.post(:Login, :input => {'username' => 'admin', 'password' => 'camping'})
+    #   #=> #<Blog::Controllers::Login @user=... >
+    #
+    #   Blog.get(:Info, :env => {:HTTP_HOST => 'wagon'})
+    #   #=> #<Blog::Controllers::Info @env={'HTTP_HOST'=>'wagon'} ...>
+    #
+    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
 
@@ -634,21 +718,8 @@ module Camping
   #
   # Models cannot be referred to in Views at this time.
   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>.
-      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+)/,1]}_".downcase.sub(/^(#{A}|camping)_/i,'')
-      end
+      autoload:Base,'camping/db'
+      def Y;self;end
   end
 
   # Views is an empty module for storing methods which create HTML.  The HTML is described
@@ -672,3 +743,4 @@ module Camping
       end
   end
 end
+