camping 2.1.532 → 3.0.0

data/lib/camping-unabridged.rb

@@ -9,10 +9,11 @@
 # nicely with piles of documentation everywhere. This documentation is entirely
 # generated from lib/camping-unabridged.rb using RDoc and our "flipbook" template
 # found in the extras directory of any camping distribution.
-require "uri"
-require "rack"
+require "cam\ping/loads"
 
 $LOADED_FEATURES << "camping.rb"
+E ||= "content-type"
+Z ||= "text/html"
 
 class Object #:nodoc:
   def meta_def(m,&b) #:nodoc:
@@ -22,7 +23,7 @@ end
 
 # If you're new to Camping, you should probably start by reading the first
 # chapters of {The Camping Book}[file:book/01_introduction.html#toc].
-# 
+#
 # Okay. So, the important thing to remember is that <tt>Camping.goes :Nuts</tt>
 # copies the Camping module into Nuts. This means that you should never use
 # any of these methods/classes on the Camping module, but rather on your own
@@ -37,10 +38,10 @@ end
 #
 # Camping also ships with:
 #
-# * Camping::Session adds states to your app. 
+# * Camping::Session adds states to your app.
 # * Camping::Server starts up your app in development.
 # * Camping::Reloader automatically reloads your apps when a file has changed.
-# 
+#
 # More importantly, Camping also installs The Camping Server,
 # please see Camping::Server.
 module Camping
@@ -48,12 +49,13 @@ module Camping
   S = IO.read(__FILE__) rescue nil
   P = "<h1>Cam\ping Problem!</h1><h2>%s</h2>"
   U = Rack::Utils
-  O = {}
-  Apps = []
-  SK = :camping #Key for r.session
+  Apps = [] # Our array of Apps
+  SK = "camping" #Key for r.session
+  G = [] # Our array of Gear
+
   # An object-like Hash.
   # All Camping 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
@@ -84,6 +86,8 @@ module Camping
     undef id, type if ?? == 63
   end
 
+  O=H.new;O[:url_prefix]="" # Our Hash of Options
+
   class Cookies < H
     attr_accessor :_p
     #
@@ -101,7 +105,7 @@ module Camping
       set k, v, v.is_a?(Hash) ? v : {}
     end
   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.
@@ -115,9 +119,9 @@ module Camping
   # class, you'll find that it's loaded from the <tt>action_view/helpers/form_tag_helper.rb</tt>
   # file. You'll need to have the ActionPack gem installed for this to work.
   #
-  # Often the helpers depends on other helpers, so you would have to look up
+  # A helper often depends on other helpers, so you would have to look up
   # the dependencies too. <tt>FormTagHelper</tt> for instance required the
-  # <tt>content_tag</tt> provided by <tt>TagHelper</tt>. 
+  # <tt>content_tag</tt> provided by <tt>TagHelper</tt>.
   #
   #   require 'action_view/helpers/form_tag_helper'
   #
@@ -127,7 +131,7 @@ module Camping
   #   end
   #
   # == Return a response immediately
-  # If you need to return a response inside a helper, you can use <tt>throw :halt</tt>. 
+  # If you need to return a response inside a helper, you can use <tt>throw :halt</tt>.
   #
   #   module Nuts::Helpers
   #     def requires_login!
@@ -137,7 +141,7 @@ module Camping
   #       end
   #     end
   #   end
-  #   
+  #
   #   module Nuts::Controllers
   #     class Admin
   #       def get
@@ -203,9 +207,9 @@ module Camping
       p,h=/\(.+?\)/,g.grep(Hash)
       g-=h
       raise "bad route" if !u = c.urls.find{|x|
-        break x if x.scan(p).size == g.size && 
+        break x if x.scan(p).size == g.size &&
           /^#{x}\/?$/ =~ (x=g.inject(x){|x,a|
-            x.sub p,U.escape((a.to_param rescue a))}.gsub(/\\(.)/){$1})
+            x.sub p,U.escape((a.to_param rescue a))}.gsub(CampTools.descape){$1})
       }
       h.any?? u+"?"+U.build_query(h[0]) : u
     end
@@ -217,8 +221,10 @@ module Camping
     #   self / "styles.css" #=> "styles.css"
     #   self / R(Edit, 1)   #=> "/blog/edit/1"
     #
-    def /(p); p[0] == ?/ ? @root + p : p end
-    
+    def /(p)
+      p[0] == ?/ ? (@root + @url_prefix.dup.prepend("/").chop + 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.
     #
@@ -243,9 +249,14 @@ module Camping
     def URL c='/',*a
       c = R(c, *a) if c.respond_to? :urls
       c = self/c
-      c = @request.url[/.{8,}?(?=\/|$)/]+c if c[0]==?/
+      c = @request.url[/.{8,}?(?=\/|$)/]+c if c[0]==?/ #/
       URI(c)
     end
+
+    # Just a helper to tell you the App Name
+    # During the instantiation of the app, "Camping" is replaced with the Apps namespace.
+    def app_name;"Camping"end
+
   end
 
   # Camping::Base is built into each controller by way of the generic routing
@@ -256,28 +267,44 @@ module Camping
   # Everything in this module is accessible inside your controllers.
   module Base
     attr_accessor :env, :request, :root, :input, :cookies, :state,
-                  :status, :headers, :body
-    
+                  :status, :headers, :body, :url_prefix
+
     T = {}
     L = :layout
-    
+
     # Finds a template, returning either:
-    # 
+    #
     #   false             # => Could not find template
     #   true              # => Found template in Views
     #   instance of Tilt  # => Found template in a file
     def lookup(n)
-      T.fetch(n.to_sym) do |k|
+      T.fetch(n.to_sym) { |k|
+        # Find a view defined in the Views module first
         t = Views.method_defined?(k) ||
+          # Find inline templates (delimited by @@), and then put it in a new Template and return that.
+          # `:_t` is the options key for inline templates. Inline templates are added in `Camping#goes`.
           (t = O[:_t].keys.grep(/^#{n}\./)[0]and Template[t].new{O[:_t][t]}) ||
+
+          # Find templates in a views directory, and return the first view that matches the symbol provided.
+          # Then pipe that template file into Template, which is just Tilt.
           (f = Dir[[O[:views] || "views", "#{n}.*"]*'/'][0]) &&
+
+          # Grab any settings set for the template files, as set by their filename extension
+          # and add that to the options of Template (Tilt), or an empty Hash
+          # What does adding settings for a template look like? :
+          #   module Nuts
+          #     def r404(path)
+          #       @path = path
+          #       render :not_found
+          #     end
+          #   end
           Template.new(f, O[f[/\.(\w+)$/, 1].to_sym] || {})
-        
+
         O[:dynamic_templates] ? t : T[k] = t
-      end
+      }
     end
-    
-    # Display a view, calling it by its method name +v+.  If a <tt>layout</tt>
+
+    # Display a view, calling it by its method name +v+. If a <tt>layout</tt>
     # method is found in Camping::Views, it will be used to wrap the HTML.
     #
     #   module Nuts::Controllers
@@ -291,9 +318,12 @@ module Camping
     #
     def render(v, *a, &b)
       if t = lookup(v)
-        r, @_r = @_r, o = Hash === a[-1] ? a.pop : {}
+        # Has this controller rendered before?
+        r = @_r
+        # Set @_r to truthy value
+        @_r = (o = Hash === a[-1] ? a.pop : {})
         s = (t == true) ? mab { send(v, *a, &b) } : t.render(self, o[:locals] || {}, &b)
-        s = render(L, o.merge(L => false)) { s } if o[L] or o[L].nil? && lookup(L) && (!r && v.to_s[0] != ?_)
+        s = render(L, o.merge(L => false)) { s } if o[L] or o[L].nil? && lookup(L) && !r && v.to_s[0] != ?_
         s
       else
         raise "no template: #{v}"
@@ -302,7 +332,7 @@ module Camping
 
     # You can directly return HTML from your controller for quick debugging
     # by calling this method and passing some Markaby to it.
-    # 
+    #
     #   module Nuts::Controllers
     #     class Info
     #       def get; mab{ code @headers.inspect } end
@@ -314,7 +344,7 @@ module Camping
       extend Mab
       mab(&b)
     end
-    
+
     # A quick means of setting this controller's status, body and headers
     # based on a Rack response:
     #
@@ -364,13 +394,13 @@ module Camping
       P % "#{p} not found"
     end
 
-    # Called when an exception is raised. However,  if there is a parse error
+    # Called when an exception is raised. However, if there is a parse error
     # in Camping or in your application's source code, it will not be caught.
     #
     # +k+ is the controller class, +m+ is the request method (GET, POST, etc.)
     # and +e+ is the Exception which can be mined for useful info.
     #
-    # Be default this simply re-raises the error so a Rack middleware can
+    # By default this simply re-raises the error so a Rack middleware can
     # handle it, but you are free to override it here:
     #
     #   module Nuts
@@ -378,7 +408,7 @@ module Camping
     #       send_email_alert(klass, method, exception)
     #       render :server_error
     #     end
-    #   end  
+    #   end
     def r500(k,m,e)
       raise e
     end
@@ -390,12 +420,12 @@ module Camping
     end
 
     # Serves the string +c+ with the MIME type of the filename +p+.
-    # Default text/html
+    # Defaults to text/html.
     def serve(p, c)
-      t = Rack::Mime.mime_type(p[/\..*$/], "text/html") and @headers['Content-Type'] = t
+      t = Rack::Mime.mime_type(p[/\..*$/], Z) and @headers[E] = t
       c
     end
-    
+
     # Turn a controller into a Rack response. This is designed to be used to
     # pipe controllers into the <tt>r</tt> method. A great way to forward your
     # requests!
@@ -415,23 +445,29 @@ module Camping
       end
       r.to_a
     end
-    
-    def initialize(env, m) #:nodoc: 
+
+    # initialize
+    # Turns a camping controller class into an object and sets up
+    # the environment with input, cookies, state, headers, etc...
+    def initialize(env, m, p) #:nodoc:
       r = @request = Rack::Request.new(@env = env)
       @root, @input, @cookies, @state,
-      @headers, @status, @method =
+      @headers, @status, @method, @url_prefix =
       r.script_name.sub(/\/$/,''), n(r.params),
       Cookies[r.cookies], H[r.session[SK]||{}],
-      {'Content-Type'=>'text/html'}, m =~ /r(\d+)/ ? $1.to_i : 200, m
+      {E=>Z}, m =~ /r(\d+)/ ? $1.to_i : 200, m, p
       @cookies._p = self/"/"
     end
-    
+
+    # n method
+    # accepts parameters and converts them to a hash.
+    # helper method for initialize
     def n(h) # :nodoc:
       if Hash === h
-        h.inject(H[]) do |m, (k, v)|
+        h.inject(H[]) { |m, (k, v)|
           m[k] = n(v)
           m
-        end
+        }
       else
         h
       end
@@ -441,13 +477,12 @@ module Camping
     # Some magic in Camping can be performed by overriding this method.
     def service(*a)
       r = catch(:halt){send(@method, *a)}
-      @body ||= r 
+      @body ||= r
       self
     end
   end
-  
-  
-  # Controllers receive the requests and sends a response back to the client.
+
+  # Controllers receive the requests and send a response back to the client.
   # A controller is simply a class which must implement the HTTP methods it
   # wants to accept:
   #
@@ -457,27 +492,31 @@ module Camping
   #         "Hello World"
   #       end
   #     end
-  #   
+  #
   #     class Posts
   #       def post
-  #         Post.create(@input) 
+  #         Post.create(@input)
   #         redirect Index
   #       end
-  #     end  
+  #     end
   #   end
-  # 
+  #
   # == Defining a controller
-  # 
-  # There are two ways to define controllers: Just defining a class and let
-  # Camping figure out the route, or add the route explicitly using R.
-  # 
+  #
+  # There are two ways to define controllers:
+  #
+  # 1. Define a class and let Camping figure out the route.
+  # 2. Add the route explicitly using R.
+  #
   # If you don't use R, Camping will first split the controller name up by
-  # words (HelloWorld => Hello and World). Then it would do the following:
-  # 
+  # words (HelloWorld => Hello and World).
+  #
+  # After that, it will do the following:
+  #
   # * Replace Index with /
   # * Replace X with ([^/]+)
   # * Replace N with (\\\d+)
-  # * Everything else turns into lowercase
+  # * Turn everything else into lowercase
   # * Join the words with slashes
   #
   #--
@@ -485,28 +524,29 @@ module Camping
   # here in order to work correctly with RDoc.
   #++
   #
-  # Here's a few examples:
-  # 
+  # Here are a few examples:
+  #
   #   Index   # => /
   #   PostN   # => /post/(\d+)
   #   PageX   # => /page/([^/]+)
   #   Pages   # => /pages
-  # 
+  #
   # == The request
-  # 
-  # You have these variables which describes the request:
-  # 
-  # * @env contains the environment as defined in http://rack.rubyforge.org/doc/SPEC.html
+  #
+  # The following variables aid in describing a request:
+  #
+  # * @env contains the environment as defined in https://github.com/rack/rack/blob/main/SPEC.rdoc
   # * @request is Rack::Request.new(@env)
   # * @root is the path where the app is mounted
   # * @cookies is a hash with the cookies sent by the client
   # * @state is a hash with the sessions (see Camping::Session)
   # * @method is the HTTP method in lowercase
+  # * @url_prefix is the set prefix of the route matched by your controller
   #
   # == The response
   #
   # You can change these variables to your needs:
-  # 
+  #
   # * @status is the HTTP status (defaults to 200)
   # * @headers is a hash with the headers
   # * @body is the body (a string or something which responds to #each)
@@ -515,13 +555,13 @@ module Camping
   # If you haven't set @body, it will use the return value of the method:
   #
   #   module Nuts::Controllers
-  #     class Index
+  #     class Index < Camper
   #       def get
   #         "This is the body"
   #       end
   #     end
   #
-  #     class Posts
+  #     class Posts < Camper
   #       def get
   #         @body = "Hello World!"
   #         "This is ignored"
@@ -530,9 +570,15 @@ module Camping
   #   end
   module Controllers
     @r = []
+
+    # An empty controller class that our other Classes inherit from.
+    # Camper is used by the R method internally.
+    class Camper end
+
     class << self
+
       # Add routes to a controller class by piling them into the R method.
-      # 
+      #
       # The route is a regexp which will match the request path. Anything
       # enclosed in parenthesis will be sent to the method as arguments.
       #
@@ -545,18 +591,37 @@ module Camping
       #       end
       #     end
       #   end
+      #
+      # Routes may be inherited using the R command as well. In this case you'll
+      # pass the ancestor Controller as the first argument to R.
+      #
+      #   module Camping::Controllers
+      #     class Post < R Edit, '/edit/(\d+)', '/new'
+      #       def get(id)
+      #         if id   # edit
+      #         else    # new
+      #         end
+      #       end
+      #     end
+      #   end
+      #
       def R *u
-        r=@r
-        Class.new {
+        r,uf=@r,u.first
+        Class.new((uf.is_a?(Class) && (uf.ancestors.include?(Camper))) ? u.shift : Camper) {
           meta_def(:urls){u}
-          meta_def(:inherited){|x|r<<x}
+          meta_def(:inherited){|x|r<< x}
         }
       end
 
+      # A Helper method to map and return the actual routes of our controllers
+      def v
+        @r.map(&:urls)
+      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.
+      # given to Controllers::R. If no routes were given, the dispatcher uses a slash followed
+      # by the lowercased name of the controller.
       #
       # Controllers are searched in this order:
       #
@@ -576,9 +641,20 @@ module Camping
         [I, 'r404', p]
       end
 
+      # A lambda to avoid internal controller route
+      A = -> (c, u, p) {
+        d = p.dup
+        d.chop! if u == ''
+        u.prepend("/"+d) if !["I"].include? c.to_s
+        if c.to_s == "Index"
+          while d[-1] == "/"; d.chop! end
+          u.prepend("/"+d)
+        end
+        u
+      }
+
       N = H.new { |_,x| x.downcase }.merge! "N" => '(\d+)', "X" => '([^/]+)', "Index" => ''
-      # The route maker, this is called by Camping internally, you shouldn't
-      # need to call it. 
+      # The route maker, called by Camping internally.
       #
       # 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
@@ -588,16 +664,24 @@ module Camping
       #
       # Anyway, if you are calling the URI dispatcher from outside of a
       # Camping server, you'll definitely need to call this to set things up.
-      # Don't call it too early though. Any controllers added after this
-      # method is called won't work properly
-      def M
-        def M #:nodoc:
+      # Don't call it too early though - any controllers added after this
+      # method was called won't work properly.
+      def M(p)
+        def M(p) #:nodoc:
         end
-        constants.map { |c|
+        # TODO: Refactor this to make it less convoluted around making urls.
+        constants.filter {|c| c.to_s != 'Camper'}.map { |c|
           k = const_get(c)
           k.send :include,C,X,Base,Helpers,Models
           @r=[k]+@r if @r-[k]==@r
-          k.meta_def(:urls){["/#{c.to_s.scan(/.[^A-Z]*/).map(&N.method(:[]))*'/'}"]}if !k.respond_to?:urls
+          mu = false # Should we make urls?
+          ka = k.ancestors
+          # This complicated code checks the ancestor chain of a controller to see it has it's own urls,
+          # or if it's urls are from one of it's ancestors. ancestor URLs need to be discarded.
+          if (k.respond_to?(:urls) && ka[1].respond_to?(:urls)) && (k.urls == ka[1].urls)
+            mu = true unless ka[1].name == nil
+          end
+          k.meta_def(:urls){[A.(k,"#{c.to_s.scan(/.[^A-Z]*/).map(&N.method(:[]))*'/'}", p)]} if (!k.respond_to?(:urls) || mu == true)
         }
       end
     end
@@ -608,50 +692,41 @@ module Camping
   X = Controllers
 
   class << self
-    # When you are running many applications, you may want to create
-    # independent modules for each Camping application. Camping::goes
-    # defines a toplevel constant with the whole MVC rack inside:
-    #
-    #   require 'camping'
-    #   Camping.goes :Nuts
-    #
-    #   module Nuts::Controllers; ... end
-    #   module Nuts::Models;      ... end
-    #   module Nuts::Views;       ... end
+
+    # Create method to setup routes for Camping upon reload.
+    def make_camp
+      X.M prx
+      Apps.map(&:make_camp)
+    end
+
+    # Helper method for getting routes from the controllers.
+    # helps Camping::Server map routes to multiple apps.
+    # Usage:
     #
-    # Additionally, you can pass a Binding as the second parameter,
-    # which enables you to create a Camping-based application within
-    # another module, for example to namespace your web interface and
-    # code for a worker process together:
-    # 
-    #   module YourApplication
-    #     Camping.goes :Web, binding()
-    #     module Web
-    #       ...
-    #     end
-    #     module Worker
-    #       ...
-    #     end
-    #   end
+    #   Nuts.routes
+    #   Camping.routes
+    #   Nuts.routes
     #
-    # All the applications will be available in Camping::Apps.
-    def goes(m, g=TOPLEVEL_BINDING)
-      Apps << a = eval(S.gsub(/Camping/,m.to_s), g)
-      caller[0]=~/:/
-      IO.read(a.set:__FILE__,$`)=~/^__END__/ &&
-      (b=$'.split(/^@@\s*(.+?)\s*\r?\n/m)).shift rescue nil
-      a.set :_t,H[*b||[]]
+    def routes
+      (Apps.map(&:routes)<<X.v).flatten
+    end
+
+    # An internal method used to return the current app's url_prefix.
+    # the prefix is processed to make sure that it's not all wonky. excessive
+    # trailing and leading slashes are removed. A trailing slash is added.
+    def prx
+      @_prx ||= CampTools.normalize_slashes(O[:url_prefix])
     end
-    
+
     # Ruby web servers use this method to enter the Camping realm. The +e+
     # argument is the environment variables hash as per the Rack specification.
-    # And array with [status, headers, body] is expected at the output.
+    # Array with [status, headers, body] is expected at the output.
     #
-    # See: http://rack.rubyforge.org/doc/SPEC.html
+    # See: https://github.com/rack/rack/blob/main/SPEC.rdoc
     def call(e)
-      X.M
-      k,m,*a=X.D e['PATH_INFO'],e['REQUEST_METHOD'].downcase,e
-      k.new(e,m).service(*a).to_a
+      make_camp # TODO: Find a better, more consistent place for setting everything up.
+      k,m,*a=X.D e["PATH_INFO"],e['REQUEST_METHOD'].downcase,e
+      k.new(e,m,prx).service(*a).to_a
     rescue
       r500(:I, k, m, $!, :env => e).to_a
     end
@@ -675,40 +750,187 @@ module Camping
     #   #=> #<Blog::Controllers::Info @headers={'HTTP_HOST'=>'wagon'} ...>
     #
     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)
+      # puts "method missing failure for controller: #{c}, method: #{m} "
+      k = X.const_get(c).new(e,m.to_s,prx)
       h.each { |i, v| k.send("#{i}=", v) }
       k.service(*a)
     end
-    
+
     # Injects a middleware:
     #
     #   module Blog
     #     use Rack::MethodOverride
     #     use Rack::Session::Memcache, :key => "session"
     #   end
+    #
+    # This piece of code feels a bit confusing, but let's walk through it.
+    # Rack apps all implement a Call method. This is how Rub web servers
+    # pass call the app, or code that you're set up. In our case, our camping
+    # apps.
+    #
+    # The Use method is setting up a new middleware, it first shifts the first
+    # argument supplied to Use, which should be the Middleware name, then
+    # initializes it. That's your new middleware. Rack based middleware accept
+    # a single argument to their initialize methods, which is an app. Optionally
+    # settings and a block are supplied.
+    #
+    # So a new app is made, and its settings are supplied, then immediately
+    # sent to the new middleware we just added. But the cool part is where we
+    # call meta_def. meta_def takes a symbol and a block, and defines a class
+    # method into the current context. Our current context is our camping app.
+    # So when we call it below we're redefining the call method to call the new
+    # middleware that we just added. The `m` variable below represents our
+    # newly created middleware object, that we initialized with our old app. and
+    # because we're defining a new call method with a block, it's captured in
+    # that block.
+    #
+    # This creates a sequence of middleware that isn't recorded anywhere, but
+    # nonetheless is set up in the proper order and called in the proper order.
     def use(*a, &b)
       m = a.shift.new(method(:call), *a, &b)
       meta_def(:call) { |e| m.call(e) }
     end
-    
+
+    # Add gear to your app:
+    #
+    #   module Blog
+    #     pack Camping::Gear::CSRF
+    #   end
+    #
+    # Why have plugins in the first place if we can just include and extend our
+    # modules and classes directly? To perform setup actions!
+    #
+    # Sometimes you might have ClassMethods that you want to modify Camping with,
+    # This gives us a way to do that. In your gear:
+    #
+    #   module MyGear
+    #     module ClassMethods
+    #       # Define Class Methods here
+    #     end
+    #     def self.included(mod)
+    #       mod.extend(ClassMethods)
+    #     end
+    #   end
+    #
+    # Optionally a plugin may have a setup method and a ClassMethods module:
+    #
+    #   module MyGear
+    #     def self.setup(s)
+    #       # Perform setup actions
+    #     end
+    #     module ClassMethods
+    #       # Define Class Methods here
+    #     end
+    #   end
+    #
+    def pack(*a, &b)
+      G << g = a.shift
+      include g
+      g.setup(self, *a, &b) # if g.respond_to?(:setup) # Force all gear to have a setup function
+    end
+
+    # Helper method to list gear
+    def gear
+      G
+    end
+
     # A hash where you can set different settings.
     def options
       O
     end
-    
+
     # Shortcut for setting options:
-    # 
+    #
     #   module Blog
     #     set :secret, "Hello!"
     #   end
     def set(k, v)
       O[k] = v
     end
+
+    # When you are running multiple applications, you may want to create
+    # independent modules for each Camping application. Camping::goes
+    # defines a top level constant with the whole MVC rack inside:
+    #
+    #   require 'camping'
+    #   Camping.goes :Nuts
+    #
+    #   module Nuts::Controllers; ... end
+    #   module Nuts::Models;      ... end
+    #   module Nuts::Views;       ... end
+    #
+    # Additionally, you can pass a Binding as the second parameter,
+    # which enables you to create a Camping-based application within
+    # another module.
+    #
+    # Here's an example of namespacing your web interface and
+    # code for a worker process together:
+    #
+    #   module YourApplication
+    #     Camping.goes :Web, binding()
+    #     module Web
+    #       ...
+    #     end
+    #     module Worker
+    #       ...
+    #     end
+    #   end
+    #
+    # All the applications will be available in Camping::Apps.
+    #
+    # Camping offers a shortcut for adding thin files, and templates to your apps.
+    # Add them at the end of the same ruby file that you call `Camping.goes`:
+    #
+    #   require 'camping'
+    #   Camping.goes :Nuts
+    #
+    #   module Nuts::Controllers; ... end
+    #   module Nuts::Models;      ... end
+    #   module Nuts::Views;       ... end
+    #
+    #   __END__
+    #
+    #   @@ /style.css
+    #   * { margin: 0; padding: 0 }
+    #
+    #   @@ /test.foo
+    #   <H1>Hello friends! Nice to meet you.<H1>
+    #
+    #   @@ index.erb
+    #   Hello <%= @world %>
+    #
+    # Also sets the apps Meta Data. Can be found at O[:_meta]
+    #
+    # @app:         {String} - The app in question
+    # @parent:      {String} -
+    # @root:        {String} -
+    # @line_number: {Int}    - The line number that the app was declared
+    # @file:        {String} - The file location for this
+    #
+    def goes(m, g=TOPLEVEL_BINDING)
+
+      # setup caller data
+      sp = caller[0].split('`')[0].split(":")
+      fl, ln, pr = sp[0], sp[1].to_i, nil
+
+      # Create the app
+      Apps << a = eval(S.gsub(/Camping/,m.to_s), g, fl, ln)
+
+      caller[0]=~/:/
+      IO.read(a.set:__FILE__,$`)=~/^__END__/ &&
+      (b=$'.split(/^@@\s*(.+?)\s*\r?\n/m)).shift rescue nil
+      a.set :_t,H[*b||[]]
+
+      # setup parental data
+      a.set :_meta, H[file: fl, line_number: ln, parent: self, root: (name != "Cam\ping" ? '/' + CampTools.to_snake(name) : '/')]
+
+      # configure the app?
+      C.configure(a)
+    end
   end
-  
+
   # Views is an empty module for storing methods which create HTML. The HTML
   # is described using the Markaby language.
   #
@@ -720,7 +942,7 @@ module Camping
   #     def index
   #       p "Welcome to my blog"
   #     end
-  #   
+  #
   #     def show
   #       h1 @post.title
   #       self << @post.content
@@ -745,7 +967,7 @@ module Camping
   #     end
   #   end
   module Views; include X, Helpers end
-  
+
   # Models is an empty Ruby module for housing model classes derived
   # from ActiveRecord::Base. As a shortcut, you may derive from Base
   # which is an alias for ActiveRecord::Base.
@@ -770,14 +992,19 @@ module Camping
   #     end
   #   end
   #
-  # Models cannot be referred to in Views at this time.
+  # Models cannot be referred from Views at this time.
   module Models
-    autoload :Base,'camping/ar'
     Helpers.send(:include, X, self)
   end
 
   autoload :Mab, 'camping/mab'
   autoload :Template, 'camping/template'
+
+  # Load default Gear
+  pack Gear::Inspection
+  pack Gear::Filters
+  pack Gear::Nancy
+  pack Gear::Kuddly
+
   C
 end
-