glamping 0.1.0

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2007-10-06
+
+* 1 major enhancement:
+  * Initial release

data/License.txt

@@ -0,0 +1,18 @@
+Copyright (c) 2007 Magnus Holm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+  
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+   
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,9 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+lib/glamping.rb
+lib/glamping/version.rb
+lib/glamping/db.rb
+lib/glamping/boot.rb
+lib/glamping/session.rb

data/README.txt

@@ -0,0 +1,60 @@
+# == About Glamping
+#
+# Glamping is a fork of Camping[http://code.whytheluckystiff.net/camping],
+# and much of the documentation is identical. Camping is licensed under
+# the MIT-license (included below) and so is Glamping (see
+# License.txt[link:files/License_txt.html]). If you think that I break any
+# of the conditions required by the license, please contact me at
+# mailto:judofyr@gmail.com.
+#
+# An importing thing to remember while using Glamping, is that it's in fact
+# Camping. Most Camping-plugins (even though there isn't so many) will very
+# often work in Glamping. You can use both Mongrel, Rack and Rv together with
+# Glamping by using the Camping-adapters.
+#
+# If you need help, there is a forum located at our
+# developer[http://code.simpleflux.com/projects/show/1] site. There you can
+# also submit bugs and features and browse the source.
+#
+# == Requirements
+#
+# Glamping requires at least Ruby 1.8.2.
+#
+# Glamping depends on the following libraries.  If you install through RubyGems,
+# these will be automatically installed for you.
+#
+# * ActiveRecord, used in your models.
+#   ActiveRecord is an object-to-relational database mapper with adapters
+#   for SQLite3, MySQL, PostgreSQL, SQL Server and more.
+# * Erubis or ERB, used in your views.
+# * MetAid, a few metaprogramming methods which Glamping uses.
+# * Tempfile, for storing file uploads.
+# * MimeTypes, for serving static files with correct Content-Type
+#
+# Glamping also works well with Mongrel[http://rubyforge.org/projects/mongrel],
+# the swift Ruby web server.
+#
+# == Getting Started
+# * (Learn Camping)
+# * Read <i>The Puffy Guide to Glamorous Camping</i>: http://judofyr.net/g
+# * Read my blog: http://blog.judofyr.net
+#
+# == The Camping License
+# Copyright (c) 2006 why the lucky stiff
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#  
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#    
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/glamping.rb

@@ -0,0 +1,823 @@
+%w[metaid tempfile uri fileutils mime/types].map { |l| require l }
+begin
+  require 'erubis'
+  ERB = Erubis::Eruby unless Object.const_defined(:ERB)
+rescue
+  require 'erb'
+end
+
+# == Glamping 
+#
+# The glamping module contains three modules for separating your application:
+#
+# * Glamping::Models for your database interaction classes, all derived from ActiveRecord::Base.
+# * Glamping::Controllers for storing controller classes, which map URLs to code.
+# * Glamping::Views for storing methods which generate HTML.
+#
+# Of use to you is also one module for storing helpful additional methods:
+#
+# * Glamping::Helpers which can be used in controllers and views.
+#
+# == The <tt>create</tt> method
+#
+# Many postambles will check for your application's <tt>create</tt> method and will run it
+# when the web server starts up.  This is a good place to check for database tables and create
+# those tables to save users of your application from needing to manually set them up.
+#
+#   def Blog.create
+#     unless Blog::Models::Post.table_exists?
+#       ActiveRecord::Schema.define do
+#         create_table :blog_posts, :force => true do |t|
+#           t.column :user_id,  :integer, :null => false
+#           t.column :title,    :string,  :limit => 255
+#           t.column :body,     :text
+#         end
+#       end
+#     end
+#   end 
+#
+# For more tips, see http://code.whytheluckystiff.net/camping/wiki/GiveUsTheCreateMethod.
+module Glamping
+  G = Object.const_get("Glam\ping")
+  C = self
+  S = IO.read(__FILE__) rescue nil
+  P = "<h1>Glam\ping Problem!</h1><h2>%s</h2>"
+  # An object-like Hash.
+  # All Glamping query string and cookie variables are loaded as this.
+  # 
+  # To access the query string, for instance, use the <tt>@input</tt> variable.
+  #
+  #   module Blog::Controllers
+  #     class Index < R '/'
+  #       def get
+  #         if page = @input.page.to_i > 0
+  #           page -= 1
+  #         end
+  #         @posts = Post.find :all, :offset => page * 20, :limit => 20
+  #         render :index
+  #       end
+  #     end
+  #   end
+  #
+  # In the above example if you visit <tt>/?page=2</tt>, you'll get the second
+  # page of twenty posts.  You can also use <tt>@input[:page]</tt> or <tt>@input['page']</tt>
+  # 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 < Hash
+    # Gets or sets keys in the hash.
+    #
+    #   @cookies.my_favorite = :macadamian
+    #   @cookies.my_favorite
+    #   => :macadamian
+    #
+    def method_missing(m,*a)
+        m.to_s=~/=$/?self[$`]=a[0]:a==[]?self[m.to_s]:super
+    end
+    alias u merge!
+  end
+
+  # Helpers contains methods available in your controllers and views.  You may add
+  # methods of your own to this module, including many helper methods from Rails.
+  # This is analogous to Rails' <tt>ApplicationHelper</tt> module.
+  #
+  # == Using ActionPack Helpers
+  #
+  # If you'd like to include helpers from Rails' modules, you'll need to look up the
+  # helper module in the Rails documentation at http://api.rubyonrails.org/.
+  #
+  # For example, if you look up the <tt>ActionView::Helpers::FormHelper</tt> class,
+  # you'll find that it's loaded from the <tt>action_view/helpers/form_helper.rb</tt>
+  # file.  You'll need to have the ActionPack gem installed for this to work.
+  #
+  #   require 'action_view/helpers/form_helper.rb'
+  #
+  #   # This example is unfinished.. soon..
+  #
+  module Helpers
+    # Page caching is an efficient caching method, but is only useful
+    # under this conditions:
+    # * The page is same for all users
+    # * The page is available to the public
+    #
+    # This implementation is based on Manfred Stienstra's
+    # work[http://operation0.org/2006/10/simple-page-caching-with-hidden-carrots]
+    #
+    # == Setup
+    # (Please read glamping/boot.rb[link:files/lib/glamping/boot_rb.html]
+    # when using <tt>boot.rb</tt>)
+    #
+    # Before we can start using PageCaching we need to set where our
+    # caching-files should go.
+    #
+    #   SampleApp.config.root = "/full/path/to/cache/folder"
+    #
+    # == Usage
+    # Then we can simply use the <tt>cache_page</tt>-method to cache
+    # our controller:
+    #
+    #  class Post < R '/post/(\d+)'
+    #    def get(id)
+    #      cache_page do
+    #        @post = Post.find(id)
+    #        render :post
+    #      end
+    #    end
+    #  end
+    #
+    # There is no expire time for this caches, in stead you should use
+    # <tt>sweep_page</tt> when needed (after a post is created etc.)
+    module PageCaching
+      # Checks if a page is cached by the <b>local</b> path
+      def page_cached?(path)
+        File.exists?(path) && !File.size(path).zero?
+      end
+      
+      # Figures out the full local path to the cache, based on the URL.
+      # Returns an array where the first item is the folder and the second
+      # is the file.
+      #    page_cache_path("/post/1") #=> ["/cache/folder/post",
+      #                                    "/cache/folder/post/1.html"]
+      def page_cache_path(path = env['REQUEST_URI'])
+        p = path.split("/")[1..-1].to_a
+        file = p.pop || "index"
+        file = file[0...file.index("?")] if file.include?("?")
+        file << '.html' unless file.include?(".")
+        [path = File.join(C.config.cache, *p), File.join(path, file)]
+      end
+      
+      # Caches a page based on the URL. The cache-file is sent using the
+      # X-Sendfile header
+      def cache_page # :yields:
+        return yield unless env['REQUEST_URI']
+        path, file = page_cache_path
+        unless page_cached?(file)
+          FileUtils.mkdir_p(path)
+          File.open(file, 'w') { |f| f.write yield.to_s }
+        end
+        serve_static(file)
+      end
+      
+      # Sweeps a page by a controller. If <tt>:all</tt> is given as first
+      # argument it will simply <b>delete the whole cache folder</b>
+      #   sweep_page(Post, 1)
+      #   sweep_page(Index)
+      #   sweep_page(Controller, "argument", 123)
+      #   sweep_page(:all)
+      def sweep_page(*args)
+        return FileUtils.rm_rf(PATH) if args.first == :all
+        path, file = page_cache_path(R(*args))
+        FileUtils.rm_rf Dir[file]
+      end
+    end
+    include PageCaching
+    # From inside your controllers and views, you will often need to figure out
+    # the route used to get to a certain controller +c+.  Pass the controller class
+    # and any arguments into the R method, a string containing the route will be
+    # returned to you.
+    #
+    # Assuming you have a specific route in an edit controller:
+    #
+    #   class Edit < R '/edit/(\d+)'
+    #
+    # A specific route to the Edit controller can be built with:
+    #
+    #   R(Edit, 1)
+    #
+    # Which outputs: <tt>/edit/1</tt>.
+    #
+    # You may also pass in a model object and the ID of the object will be used.
+    #
+    # If a controller has many routes, the route will be selected if it is the
+    # first in the routing list to have the right number of arguments.
+    #
+    # == Using R in the View
+    #
+    # Keep in mind that this route doesn't include the root path.
+    # You will need to use <tt>/</tt> (the slash method above) in your controllers.
+    # Or, go ahead and use the Helpers#URL method to build a complete URL for a route.
+    #
+    # However, in your views, the :href, :src and :action attributes automatically
+    # pass through the slash method, so you are encouraged to use <tt>R</tt> or
+    # <tt>URL</tt> in your views.
+    #
+    #  module Blog::Views
+    #    def menu
+    #      div.menu! do
+    #        a 'Home', :href => URL()
+    #        a 'Profile', :href => "/profile"
+    #        a 'Logout', :href => R(Logout)
+    #        a 'Google', :href => 'http://google.com'
+    #      end
+    #    end
+    #  end
+    #
+    # Let's say the above example takes place inside an application mounted at
+    # <tt>http://localhost:3301/frodo</tt> and that a controller named <tt>Logout</tt>
+    # is assigned to route <tt>/logout</tt>.  The HTML will come out as:
+    #
+    #   <div id="menu">
+    #     <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>
+    #
+    # If you pass wrong number of arguments (or passing nil into some position),
+    # it will return nil
+    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,C.escape((a[a.class.primary_key]rescue a))}) 
+      } 
+      h.any?? u+"?"+h[0].map{|x|x.map{|z|C.escape z}*"="}*"&": u
+    end
+
+    # 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"
+    #   self / R(Edit, 1)   #=> "/blog/edit/1"
+    #
+    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)    #=> #<URL://test.ing/blog/view/12>
+    #
+    # Or you can use the direct path:
+    #
+    #   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:
+    #
+    #   URL("http://google.com")  #=> #<URI:http://google.com>
+    #
+    # Any string which doesn't begin with a slash will pass through
+    # unscathed.
+    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
+    
+    # Builds a link to the previous page, named with +text+. If you need
+    # to customize the link, you should just call this without any arguments.
+    # Then it will only give you the page.
+    #
+    # If it can't find the previous page it will use a JavaScript-solution.
+    #
+    #  back("Go to previous page") #=> A link to the previous page
+    #  back #=> Just the previous page
+    def back(text = nil)
+      return u = @env['HTTP_REFERER'] || "javascript:history.go(-1)" unless text
+      '<a href="%s">%s</a>'%[u,text]
+    end
+    
+    # Serves a static file.
+    def serve_static(path)
+      if s = MIME::Types.type_for(path)[0]
+        @headers['Content-Type'] = s.content_type
+      end
+      @headers['X-Sendfile'] = path
+    end
+  end
+
+  # Glamping::Base is built into each controller by way of the generic routing
+  # class Glamping::R.  In some ways, this class is trying to do too much, but
+  # it saves code for all the glue to stay in one place.
+  #
+  # Forgivable, considering that it's only really a handful of methods and accessors.
+  #
+  # == Treating controller methods like Response objects
+  #
+  # Glamping originally came with a barebones Response object, but it's often much more readable
+  # to just use your controller as the response.
+  #
+  # Go ahead and alter the status, cookies, headers and body instance variables as you
+  # see fit in order to customize the response.
+  #
+  #   module Glamping::Controllers
+  #     class SoftLink
+  #       def get
+  #         redirect "/"
+  #       end
+  #     end
+  #   end
+  #
+  # Is equivalent to:
+  #
+  #   module Glamping::Controllers
+  #     class SoftLink
+  #       def get
+  #         @status = 302
+  #         @headers['Location'] = "/"
+  #       end
+  #     end
+  #   end
+  #
+  module Base
+    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 Glamping::Views, it will be used to wrap the HTML.
+    #
+    #   module Glamping::Controllers
+    #     class Show
+    #       def get
+    #         @posts = Post.find :all
+    #         render :index
+    #       end
+    #     end
+    #   end
+    #
+    def render(m, layout_name = "layout")
+      @content = render_view(m)
+      begin;layout_name ? render_view(layout_name) : @content
+      rescue Errno::ENOENT; @content ;end
+    end
+    
+    def render_view(m)
+      ERB.new(IO.read("#{C.config.views}/#{m}.erb")).result(binding)
+    end
+=begin
+    # Any stray method calls will be passed to Markaby.  This means you can reply
+    # with HTML directly from your controller for quick debugging.
+    #
+    #   module Glamping::Controllers
+    #     class Info
+    #       def get; code @env.inspect end
+    #     end
+    #   end
+    #
+    # If you have a <tt>layout</tt> method in Glamping::Views, it will be used to
+    # wrap the HTML.
+    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
+=end
+    # A quick means of setting this controller's status, body and headers. 
+    # Used internally by Camping, but... by all means... 
+    # 
+    #   r(302, '', 'Location' => self / "/view/12") 
+    # 
+    # Is equivalent to: 
+    # 
+    #   redirect "/view/12" 
+    # 
+    # See also: #r404, #r500 and #r501 
+    def r(s, b, h = {}); @status = s; headers.u(h); @body = b; end
+    
+    # Formulate a redirect response: a 302 status with <tt>Location</tt> header
+    # and a blank body.  Uses Helpers#URL to build the location from a controller
+    # route or path.
+    #
+    # So, given a root of <tt>http://localhost:3301/articles</tt>:
+    #
+    #   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
+    
+    # Called when a controller was not found. It is mainly used internally, but it can 
+    # also be useful for you, if you want to filter some parameters. 
+    # 
+    # module Glamping 
+    #   def r404(p=env.PATH) 
+    #     @status = 404 
+    #     div do 
+    #       h1 'Glamping Problem!' 
+    #       h2 "#{p} not found" 
+    #     end 
+    #   end 
+    # end 
+    # 
+    # See: I 
+    def r404(p=env.PATH)
+      if (a=C.config.public) && Dir[a+"/**/*"].include?(a+p)
+        return serve_static(a+p)
+      end
+      r(404, X.const_defined?(:NotFound) ? C.get(:NotFound, p).body : P % "#{p} not found") 
+    end
+    
+    # If there is a parse error in Glamping or in your application's source code, it will not be caught 
+    # by Glamping.  The controller class +k+ and request method +m+ (GET, POST, etc.) where the error 
+    # took place are passed in, along with the Exception +e+ which can be mined for useful info. 
+    # 
+    # You can overide it, but if you have an error in here, it will be uncaught ! 
+    # 
+    # See: I 
+    def r500(k,m,x) 
+      r(500, X.const_defined?(:ServerError) ? C.get(:ServerError, k, m, x).body : P % "#{k}.#{m}" + "<h3>#{x.class} #{x.message}: <ul>#{x.backtrace.map{|b|"<li>#{b}</li>"}}</ul></h3>") 
+    end 
+    
+    # Called if an undefined method is called on a Controller, along with the request method +m+ (GET, POST, etc.) 
+    # 
+    # See: I 
+    def r501(m=@method) 
+      r(501, X.const_defined?(:NotImplemented) ? C.get(:NotImplemented, m).body : P % "#{m.upcase} not implemented") 
+    end
+
+    # Turn a controller into an array.  This is designed to be used to pipe
+    # controllers into the <tt>r</tt> method.  A great way to forward your
+    # requests!
+    #
+    #   class Read < '/(\d+)'
+    #     def get(id)
+    #       Post.find(id)
+    #     rescue
+    #       r *Blog.get(:NotFound, @env.REQUEST_URI)
+    #     end
+    #   end
+    #
+    def to_a;[status, body, headers] end
+
+    def initialize(r, e, m) #:nodoc:
+      @status, @method, @env, @headers, @root = 200, m, e, 
+          H['Content-Type'=>'text/html'], e.SCRIPT_NAME.sub(/\/$/,'')
+      @k = C.kp(e.HTTP_COOKIE)
+      q = C.qsp(e.QUERY_STRING)
+      @in = r
+      case e.CONTENT_TYPE
+      when %r|\Amultipart/form-.*boundary=\"?([^\";,]+)|n
+        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
+          s=8192 
+          k='' 
+          l=@in.read(s*2) 
+          while l 
+            if (k<<l)=~b 
+              o<<$`.chomp
+              @in.seek(-$'.size,IO::SEEK_CUR)
+              break
+            end
+            o<<k.slice!(0...s) 
+            l=@in.read(s) 
+          end
+          C.qsp(fn,'&;',fh,q) if fn
+          fh.tempfile.rewind if fh.is_a?H
+        end
+      when "application/x-www-form-urlencoded"
+        q.u(C.qsp(@in.read))
+      end
+      @cookies, @input = @k.dup, q.dup
+    end
+
+    # All requests pass through this method before going to the controller.  Some magic
+    # in Glamping can be performed by overriding this method.
+    #
+    # See http://code.whytheluckystiff.net/camping/wiki/BeforeAndAfterOverrides for more
+    # on before and after overrides with Glamping.
+    def service(*a)
+      @body = send(@method, *a)
+      headers['Set-Cookie'] = cookies.map { |k,v| "#{k}=#{C.escape(v)}; path=#{self/"/"}" if v != @k[k] } - [nil]
+      self
+    end
+
+    # Used by the web server to convert the current request to a string.  If you need to
+    # alter the way Glamping builds HTTP headers, consider overriding this method.
+    def to_s
+      "Status: #@status#{Z+(headers.map{|k,v|[*v].map{|x|[k,v]*": "}}*Z).gsub(Z*2,Z)+Z+Z}#@body" 
+    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.
+  #
+  #   module Glamping::Controllers
+  #     class Edit < R '/edit/(\d+)'
+  #       def get; end
+  #       def post; end
+  #     end
+  #   end
+  #
+  # If no route is set, Glamping will guess the route from the class name.
+  # The rule is very simple: the route becomes a slash followed by the lowercased
+  # class name.  See Controllers::D for the complete rules of dispatch.
+  #
+  # == Special classes
+  #
+  # There are two special classes used for handling 404 and 500 errors.  The
+  # NotFound class handles URLs not found.  The ServerError class handles exceptions
+  # uncaught by your application.
+  X = module Controllers
+    Base.send(:include,self)
+    @r = []
+    class << self
+      def r #:nodoc:
+        @r
+      end
+      # Add routes to a controller class by piling them into the R method.
+      #
+      #   module Glamping::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.
+      #
+      # After the route have been created, a method named by the class-name will be created.
+      # It works the same way as R, but each route will be prefixed with the first URI you
+      # passed to R.
+      #
+      #  class Admin < R '/admin'
+      #    # lots of code
+      #  end
+      #  
+      #  class AdminEdit < Admin '/edit'
+      #    # lots of code
+      #  end
+      #
+      # In this example we will now have two routes: /admin (Admin) and /admin/edit (AdminEdit).
+      def R *u
+        RR u
+      end
+      
+      def RR u, p='' # :nodoc:
+        r=@r
+        Class.new {
+          meta_def(:urls){u.map{|y|p+y}}
+          meta_def(:inherited) do |x|
+            r<<x
+            Controllers.meta_def(x.to_s.split("::").last){|*u|RR(u,x.urls.first)}
+          end
+        }
+      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(p, m)
+        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
+
+      # The route maker, this is called by Glamping 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 Glamping server, you'll
+      # definitely need to call this at least once to set things up.
+      def M
+        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.downcase}"]}if !k.respond_to?:urls
+        }
+      end
+    end
+=begin
+    # 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+.
+    #
+    #   module Glamping::Controllers
+    #     class NotFound
+    #       def get(p)
+    #         @status = 404
+    #         div do
+    #           h1 'Glamping Problem!'
+    #           h2 "#{p} not found"
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    class NotFound < R()
+      def get(p)
+        r(404, "<h1>#{P}</h1><h2>#{p} not found</h2>")
+      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 Glamping or in your application's source code, it will not be caught
+    # by Glamping.  The controller class +k+ and request method +m+ (GET, POST, etc.) where the error
+    # took place are passed in, along with the Exception +e+ which can be mined for useful info.
+    #
+    #   module Glamping::Controllers
+    #     class ServerError
+    #       def get(k,m,e)
+    #         @status = 500
+    #         div do
+    #           h1 'Glamping Problem!'
+    #           h2 "in #{k}.#{m}"
+    #           h3 "#{e.class} #{e.message}:"
+    #           ul do
+    #             e.backtrace.each do |bt|
+    #               li bt
+    #             end
+    #           end
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    class ServerError < R()
+      def get(k,m,e)
+        r(500, "<h1>#{P}</h1><h2>#{k}.#{m}</h2><h3>#{e.class} #{e.message}:</h3>
+        <ul><li>#{e.backtrace.join('</li><li>')}</li></ul>")
+      end
+    end
+=end
+    # Internal controller with no route. Used by #D and C.run to show internal messages. 
+    class I < R()
+    end
+    self
+  end
+
+  class << self
+    # When you are running many applications, you may want to create independent
+    # modules for each Glamping application.  Namespaces for each.  Glamping::goes
+    # defines a toplevel constant with the whole MVC rack inside.
+    #
+    #   require 'camping'
+    #   Glamping.goes :Blog
+    #
+    #   module Blog::Controllers; ... end
+    #   module Blog::Models;      ... end
+    #   module Blog::Views;       ... end
+    #
+    def goes(m)
+      eval S.gsub(/Glamping/,m.to_s), TOPLEVEL_BINDING
+    end
+
+    # URL escapes a string.
+    #
+    #   Glamping.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
+
+    # Unescapes a URL-encoded string.
+    #
+    #   Glamping.un("I%27d+go+to+the+museum+straightway%21") 
+    #     #=> "I'd go to the museum straightway!"
+    #
+    def un(s); s.tr('+', ' ').gsub(/%([\da-f]{2})/in){[$1].pack('H*')} end
+
+    # Parses a query string into an Glamping::H object.
+    #
+    #   input = Glamping.qsp("name=Philarp+Tremain&hair=sandy+blonde")
+    #   input.name
+    #     #=> "Philarp Tremaine"
+    #
+    # Also parses out the Hash-like syntax used in PHP and Rails and builds
+    # nested hashes from it.
+    #
+    #   input = Glamping.qsp("post[id]=1&post[user]=_why")
+    #     #=> {'post' => {'id' => '1', 'user' => '_why'}}
+    #
+    # And finally, Array syntax like:
+    #
+    #   input = Glamping.qsp("user[]=_why&user[]=lucky&user[]=stiff")
+    #     #=> {"user" => ["_why", "lucky", "stiff"]}
+    #
+    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
+
+    # Parses a string of cookies from the <tt>Cookie</tt> header.
+    def kp(s); c = qsp(s, ';,'); end
+
+    # Fields a request through Glamping.  For traditional CGI applications, the method can be
+    # executed without arguments.
+    #
+    #   if __FILE__ == $0
+    #     Glamping::Models::Base.establish_connection :adapter => 'sqlite3',
+    #         :database => 'blog3.db'
+    #     Glamping::Models::Base.logger = Logger.new('camping.log')
+    #     puts Glamping.run
+    #   end
+    #
+    # The Glamping controller returned from <tt>run</tt> has a <tt>to_s</tt> method in case you
+    # are running from CGI or want to output the full HTTP output.  In the above example, <tt>puts</tt>
+    # will call <tt>to_s</tt> for you.
+    #
+    # For FastCGI and Webrick-loaded applications, you will need to use a request loop, with <tt>run</tt>
+    # 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.
+    #
+    # See Glamping::FastCGI and Glamping::WEBrick for examples.
+    #
+    def run(r=$stdin,e=ENV)
+      X.M
+      e = H[e.to_hash]
+      k,m,*a=X.D e.PATH_INFO=un("/#{e.PATH_INFO}".gsub(/\/+/,'/')),(e.REQUEST_METHOD||'get').downcase 
+      k.new(r,e,m).Y.service(*a) 
+    rescue => x 
+      X::I.new(r,e,'r500').service(k,m,x)
+    end
+
+    # The Glamping 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[a.pop].each { |e,f| k.send("#{e}=",f) } if Hash === a[-1]
+      k.service(*a)
+    end
+    
+    def config
+      @config ||= H.new
+    end
+  end
+  
+  module Models # :nodoc:
+    def Y;self;end
+  end
+end