camping 2.1.532 → 3.0.0

data/lib/camping.rb

@@ -1,55 +1,86 @@
-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;O={};Apps=[];
-SK=:camping;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;class Cookies<H;attr_accessor :_p;
-def _n;@n||={}end;alias :_s :[]=;def set k,v,o={};_s(j=k.to_s,v);_n[j]=
-{:value=>v,:path=>_p}.update o;end;def []=(k,v)set(k,v,v.is_a?(Hash)?v:{})end
-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
+require "cam\ping/loads";E||="content-type";Z||="text/html"
+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=[];SK="camping";G=[]
+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;O=H.new;O[:url_prefix]=""
+class Cookies<H;attr_accessor :_p
+def _n;@n||={}end;alias _s []=;def set k,v,o={};_s(j=k.to_s,v);_n[j] =
+{:value=>v,:path=>_p}.update o;end;def []=(k,v)set k,v,v.is_a?(Hash)?v:{} end
+end
+module Helpers;def R c,*g;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&&/^#{x}\/?$/=~(x=g.inject(x){|x,a|x.sub p,U.escape((a.
-to_param rescue a))}.gsub(/\\(.)/){$1})};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
+to_param rescue a))}.gsub(CampTools.descape){$1})};h.any?? u+"?"+U.build_query(h[0]) : u
+end;def /(p) p[0]==?/ ?(@root+@url_prefix.dup.prepend("/").chop+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
+def app_name;"Camping"end end
 module Base;attr_accessor:env,:request,:root,:input,:cookies,:state,:status,
-:headers,:body;T={};L=:layout;def lookup n;T.fetch(n.to_sym){|k|t=Views.
+:headers,:body,:url_prefix;T={};L=:layout
+def lookup n;T.fetch(n.to_sym){|k|t=Views.
 method_defined?(k)||(t=O[:_t].keys.grep(/^#{n}\./)[0]and Template[t].new{
 O[:_t][t]})||(f=Dir[[O[:views]||"views","#{n}.*"]*'/'][0])&&Template.
-new(f,O[f[/\.(\w+)$/,1].to_sym]||{});O[:dynamic_templates]?t:T[k]=t} end
-def render v,*a,&b;if t=lookup(v);r,@_r=@_r,o=Hash===a[-1]?a.pop: {};s=(t==true)?mab{
+new(f,O[f[/\.(\w+)$/,1].to_sym]||{});O[:dynamic_templates]?t: T[k]=t}end
+def render v,*a,&b;if t=lookup(v);r=@_r;@_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;else;raise"no template: #{v}"
-end;end;def mab &b;extend(Mab);mab(&b) 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 serve(p,c)
-(t=Rack::Mime.mime_type p[/\..*$/],"text/html")&&@headers["Content-Type"]=t;c;end;def to_a;@env[
-'rack.session'][SK]=Hash[@state];r=Rack::Response.new(@body,@status,@headers)
-@cookies._n.each{|k,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),Cookies[r.cookies],
-H[r.session[SK]||{}],{'Content-Type'=>'text/html'},m=~/r(\d+)/?$1.to_i: 200,m;@cookies._p=self/"/" 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 *u;r=@r;Class.
-new{meta_def(:urls){u};meta_def(:inherited){|x|r<<x}}end;def D p,m,e;p='/'if
+} if o[L] or o[L].nil?&&lookup(L)&&!r&&v.to_s[0]!=?_;s else raise "no template: #{v}"
+end end
+def mab &b;extend Mab;mab &b;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 serve p,c;t=Rack::Mime.mime_type(p[/\..*$/], Z)and@headers[E]=t;c;end
+def to_a;@env['rack.session'][SK]=Hash[@state];r=Rack::Response.new(@body,
+@status,@headers);@cookies._n.each{|k,v|r.set_cookie k,v};r.to_a end
+def initialize env,m,p
+r=@request=Rack::Request.new(@env=env);@root,@input,@cookies,@state,@headers,
+@status,@method,@url_prefix=r.script_name.sub(/\/$/,''),n(r.params),
+Cookies[r.cookies],H[r.session[SK]||{}],{E=>Z},m=~/r(\d+)/?$1.to_i: 200,m,p
+@cookies._p=self/"/";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 Camper end;class<<self
+def R *u;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} } end
+def v;@r.map(&:urls);end
+def D p,m,e;p='/'if
 !p||!p[0];(a=O[:_t].find{|n,_|n==p}) and return [I,:serve,*a]
 @r.map{|k|k.urls.map{|x|return(k.method_defined? m)?[k,m,*$~[1..-1].map{|x|U.unescape x}]:
-[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,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}end end;I=R()end;X=
-Controllers;class<<self;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||[]];end;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;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;def options;O end;def set k,v;O[k]=v end end
-module Views;include X,Helpers end;module Models;autoload:Base,'camping/ar'
+[I, 'r501',m]if p=~/^#{x}\/?$/}};[I,'r404',p] end;
+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"=>''
+def M p;def M p;end
+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;mu=false;ka=k.ancestors
+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;I=R()end;X=Controllers
+class<<self;def make_camp;X.M prx;Apps.map(&:make_camp) end;def routes;(Apps.map(&:routes)<<X.v).flatten end
+def prx;@_prx||=CampTools.normalize_slashes(O[:url_prefix])end
+def call e;make_camp;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
+def method_missing m,c,*a;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,prx);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
+def pack*a,&b;G<< g=a.shift;include g;g.setup(self,*a,&b)end
+def gear;G end;def options;O;end;def set k,v;O[k]=v end
+def goes m,g=TOPLEVEL_BINDING;sp=caller[0].split('`')[0].split(":");fl,ln,pr=
+sp[0],sp[1].to_i,nil;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||[]]
+a.set :_meta, H[file: fl, line_number: ln, parent: self,
+root: (name != "Cam\ping" ? '/' + CampTools.to_snake(name) : '/')];C.configure(a)end end
+module Views;include X,Helpers end;module Models
 Helpers.send:include,X,self end;autoload:Mab,'camping/mab'
-autoload:Template,'camping/template';C end
+autoload:Template,'camping/template';pack Gear::Inspection;pack Gear::Filters
+pack Gear::Nancy;pack Gear::Kuddly;C end

data/lib/campingtrip.md

@@ -0,0 +1,341 @@
+# How does Camping work?
+This is an academic document written to help people, but mostly me, understand what Camping is doing and in what sequence. Why? Because I want to make camping better, but how do you make it better unless you understand what you've got?
+
+# Start
+Camping starts off with some simple code you type: `camping nuts.rb` into your terminal and the camping gem is loaded and executed. This assumes that you've installed camping via ruby gems: `gem install camping`. Gems are then given a binary command you can use on the command line, in our case **camping**. The camping command accepts a file as an argument and maybe some options. This command calls a *binary* that's found the camping gem, this is what it looks like:
+```ruby
+#!/usr/bin/env ruby
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'camping'
+require 'camping/server'
+
+begin
+  Camping::Server.start
+rescue OptionParser::ParseError => ex
+  STDERR.puts "!! #{ex.message}"
+  puts "** use `#{File.basename($0)} --help` for more details..."
+  exit 1
+end
+```
+
+First wee see `$:.unshift File.dirname(__FILE__) + "/../lib"`, `$:`, is a global variable, that contains the loadpath for scripts. Every ruby file is a script, you may be more familiar with `$LOAD_PATH` which is an alias for the `$:` global. Next `unshift` is an array method that prepends an item to the beginning of an array. `File` is a builtin ruby class that lets you work with files. `File.dirname(file)` returns a string of the complete file path of the file given, except for the file's name. In our case we're using `__FILE__` to return the current file name, which is the binary file in the camping gem. the last portion: `+ "/../lib"` appends the string to the directory path that we just got. All of this is done to ensure that the `lib` folder where all of camping's code resides is added to the script load path.
+
+Next we require camping:
+```ruby
+require 'camping'
+require 'camping/server'
+```
+
+Which loads camping and it's server code in to the current script context.
+
+```ruby
+  Camping::Server.start
+```
+
+The above code finally Starts the camping server. So let's take a look at the server:
+
+```ruby
+require 'irb'
+require 'erb'
+require 'rack'
+require 'camping/reloader'
+require 'camping/commands'
+
+# == The Camping Server (for development)
+#
+# Camping includes a pretty nifty server which is built for development.
+# It follows these rules:
+#
+# * Load all Camping apps in a file.
+# * Mount those apps according to their name. (e.g. Blog 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.
+#
+# Run it like this:
+#
+#   camping blog.rb          # Mounts Blog at /
+#
+# And visit http://localhost:3301/ in your browser.
+module Camping
+  class Server < Rack::Server
+    class Options
+      if home = ENV['HOME'] # POSIX
+        DB = File.join(home, '.camping.db')
+        RC = File.join(home, '.campingrc')
+      elsif home = ENV['APPDATA'] # MSWIN
+        DB = File.join(home, 'Camping.db')
+        RC = File.join(home, 'Campingrc')
+      else
+        DB = nil
+        RC = nil
+      end
+
+      HOME = File.expand_path(home) + '/'
+
+      def parse!(args)
+        args = args.dup
+
+        options = {}
+
+        opt_parser = OptionParser.new("", 24, '  ') do |opts|
+          opts.banner = "Usage: camping my-camping-app.rb"
+          opts.define_head "#{File.basename($0)}, the microframework ON-button for ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
+          opts.separator ""
+          opts.separator "Specific options:"
+
+          opts.on("-h", "--host HOSTNAME",
+          "Host for web server to bind to (default is all IPs)") { |v| options[:Host] = v }
+
+          opts.on("-p", "--port NUM",
+          "Port for web server (defaults to 3301)") { |v| options[:Port] = v }
+
+          db = DB.sub(HOME, '~/') if DB
+          opts.on("-d", "--database FILE",
+          "SQLite3 database path (defaults to #{db ? db : '<none>'})") { |db_path| options[:database] = db_path }
+
+          opts.on("-C", "--console",
+          "Run in console mode with IRB") { options[:server] = "console" }
+
+          server_list = ["thin", "webrick", "console"]
+          opts.on("-s", "--server NAME",
+          "Server to force (#{server_list.join(', ')})") { |v| options[:server] = v }
+
+          opts.separator ""
+          opts.separator "Common options:"
+
+          # No argument, shows at tail.  This will print an options summary.
+          # Try it and see!
+          opts.on("-?", "--help", "Show this message") do
+            puts opts
+            exit
+          end
+
+          # Another typical switch to print the version.
+          opts.on("-m", "--mounting", "Shows Mounting Guide") do
+            puts "Mounting Guide"
+            puts ""
+            puts "To mount your horse, hop up on the side and put it."
+            exit
+          end
+
+          # Another typical switch to print the version.
+          opts.on("-v", "--version", "Show version") do
+            puts Gem.loaded_specs['camping'].version
+            exit
+          end
+
+        end
+
+        opt_parser.parse!(args)
+
+        # If no Arguments were called.
+        if args.empty?
+          args << "cabin.rb" # adds cabin.rb as a default camping entrance file
+        end
+
+        # Parses the first argument as the script to load into the server.
+        options[:script] = args.shift
+        options
+      end
+    end
+
+    def initialize(*)
+      super
+      @reloader = Camping::Reloader.new(options[:script]) do |app|
+        if !app.options.has_key?(:dynamic_templates)
+          app.options[:dynamic_templates] = true
+        end
+
+        if !Camping::Models.autoload?(:Base) && options[:database]
+          Camping::Models::Base.establish_connection(
+            :adapter => 'sqlite3',
+            :database => options[:database]
+          )
+        end
+      end
+    end
+
+    def opt_parser
+      Options.new
+    end
+
+    def default_options
+      super.merge({
+        :Port => 3301,
+        :database => Options::DB
+      })
+    end
+
+    def middleware
+      h = super
+      h["development"] << [XSendfile]
+      h
+    end
+
+    def start
+      if options[:server] == "console"
+        puts "** Starting console"
+        @reloader.reload!
+        r = @reloader
+        eval("self", TOPLEVEL_BINDING).meta_def(:reload!) { r.reload!; nil }
+        ARGV.clear
+        IRB.start
+        exit
+      else
+        name = server.name[/\w+$/]
+        puts "** Starting #{name} on #{options[:Host]}:#{options[:Port]}"
+        super
+      end
+    end
+
+    # defines the public directory to be /public
+    def public_dir
+      File.expand_path('../public', @reloader.file)
+    end
+
+    # add the public directory as a Rack app serving files first, then the
+    # current value of self, which is our camping apps, as an app.
+    def app
+      Rack::Cascade.new([Rack::Files.new(public_dir), self], [405, 404, 403])
+    end
+
+    # path_matches?
+    # accepts a regular expression string
+    # in our case our apps and controllers
+    def path_matches?(path, *reg)
+      reg.each do |r|
+        return true if Regexp.new(r).match? path
+      end
+      false
+    end
+
+    # call(env) res
+    # == How routing works
+    #
+    # The first app added using Camping.goes is set at the root, we walk through
+    # the defined routes of the first app to see if there is a match.
+    # With no match we then walk through every other defined app.
+    # Each subsequent app defined is loaded at a directory named after them:
+    #
+    #   camping.goes :Nuts          # Mounts Nuts at /
+    #   camping.goes :Auth          # Mounts Auth at /auth/
+    #   camping.goes :Blog          # Mounts Blog at /blog/
+    #
+    def call(env)
+      @reloader.reload
+      apps = @reloader.apps
+
+      # our switch statement iterates through possible app outcomes, no apps
+      # loaded, one app loaded, or multiple apps loaded.
+      case apps.length
+      when 0
+        [200, {'Content-Type' => 'text/html'}, ["I'm sorry but no apps were found."]]
+      when 1
+        apps.values.first.call(env) # When we have one
+      else
+        # 2 and up get special treatment
+        count = 0
+        apps.each do |name, app|
+          if count == 0
+            app.routes.each do |r|
+              if (path_matches?(env['PATH_INFO'], r))
+                next
+              end
+              return app.call(env) unless !(path_matches?(env['PATH_INFO'], r))
+            end
+          else
+            mount = name.to_s.downcase
+            case env["PATH_INFO"]
+            when %r{^/#{mount}}
+              env["SCRIPT_NAME"] = env["SCRIPT_NAME"] + $&
+              env["PATH_INFO"] = $'
+              return app.call(env)
+            when %r{^/code/#{mount}}
+              return [200, {'Content-Type' => 'text/plain', 'X-Sendfile' => @reloader.file}, []]
+            end
+          end
+          count += 1
+        end
+
+        # Just return the first app if we didn't find a match.
+        return apps.values.first.call(env)
+      end
+    end
+
+    class XSendfile
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        status, headers, body = @app.call(env)
+
+        if key = headers.keys.grep(/c-sendfile/i).first
+          filename = headers[key]
+          content = open(filename,'rb') { | io | io.read}
+          headers['content-length'] = size(content).to_s
+          body = [content]
+        end
+
+        return status, headers, body
+      end
+
+      if "".respond_to?(:bytesize)
+        def size(str)
+          str.bytesize
+        end
+      else
+        def size(str)
+          str.size
+        end
+      end
+    end
+  end
+end
+```
+
+The beginning of Server loads the required code to get Camping started, and then opens the `Camping` module:
+
+```ruby
+module Camping
+  class Server < Rack::Server
+  end
+end
+```
+
+`Server` inherits from `Rack::Server`. Camping is Rack based to give ourselves a predictable interface for our web server code. Consequentally a lot of utilities useful for webservers are just baked into Rack, It gives Camping the chance to do what it does best, magic!
+
+The first class declared in `Server` is called `Options`. It's in charge of parsing the command line options supplied to camping, and then supplying those options as a hash for the program further down the line. This class is declared inside of the `Server` class so that we can encapsulate the behaviour of options within the server. Which is pretty nice. Next is initialize:
+
+```ruby
+def initialize(*)
+  super
+  @reloader = Camping::Reloader.new(options[:script]) do |app|
+    if !app.options.has_key?(:dynamic_templates)
+      app.options[:dynamic_templates] = true
+    end
+
+    if !Camping::Models.autoload?(:Base) && options[:database]
+      Camping::Models::Base.establish_connection(
+        :adapter => 'sqlite3',
+        :database => options[:database]
+      )
+    end
+  end
+end
+```
+
+`initialize` is the method called whenever you instantiate a new object of a class. You'll notice that the line of code in the method is a call to `super`. Because `Camping::Server` is a subclass of `Rack::Server`, and to get things rolling we first call `Rack::Server`'s initialize. Afterwards we setup the reloader, and optionally include the database.
+
+When you call super naked like that it passes along whatever arguments were sent to the method that called super. In our case It's a splat: `initialize(*)`, so everything is sent along.
+
+
+
+
+
+Remember earlier from the Camping binary where we start the server? : `Camping::Server.start`, You may notice that this is a call to a class method `start`, but we don't declare any class methods in `Camping::Server` only instance methods.

data/test/app_camping_gear.rb

@@ -0,0 +1,121 @@
+require 'test_helper'
+require 'camping'
+
+Camping.goes :Packing
+
+module Camping
+  module Gear
+
+    # Basically copied from Cuba, will probably modify later.
+    module CSRF
+
+      # Package Class Methods
+      module ClassMethods
+        # define class methods
+        def secret_token
+          @_secret_token ||= SecureRandom.base64(64)
+        end
+
+        def erase_token
+          @_secret_token = nil
+        end
+
+        def set_secret(secret)
+          @_secret_token = secret
+        end
+      end
+
+      # Run a setup routine with this Gear.
+      def self.setup(app, *a, &block)
+        @app = app
+        @app.set :secret_token, "top_secret_code"
+      end
+
+      def self.included(mod)
+        mod.extend(ClassMethods)
+      end
+
+      # Adds an instance method csrf
+      def csrf
+        @csrf ||= Camping::Gear::CSRF::Helper.new(@state, @request)
+      end
+
+      class Helper
+        attr_accessor :req
+        attr_accessor :state
+
+        def initialize(state, request)
+          @state = state
+          @req = request
+        end
+      end
+    end
+  end
+end
+
+module Packing
+  pack Camping::Gear::CSRF
+
+  before :Home do
+    @great = "This is great"
+  end
+
+  after :Work do
+    @body = "This is nice"
+  end
+
+  module Controllers
+    class Home < R '/'
+      def get
+        (@great == "This is great").to_s
+      end
+    end
+
+    class Work < R '/work'
+      def get
+        (@nice == "This is great").to_s
+      end
+    end
+  end
+end
+
+class Packing::Test < TestCase
+
+  def test_gear_packed
+    list = Packing::G
+    assert (list.length == 5), "Proper number of Gear was not packed! Gear: #{list.length}"
+  end
+
+  def test_right_gear_packed
+    csrf_gear = "Camping::Gear::CSRF"
+    assert Packing::G.map(&:to_s).include?(csrf_gear), "The correct Gear was not packed! Gear: #{csrf_gear}"
+  end
+
+  def test_instance_methods_packed
+    im = Packing.instance_methods.map(&:to_s)
+    assert (im.include? "csrf"), "Gear instance methods were not included: #{im}"
+  end
+
+  def test_class_methods_packed
+    [:secret_token, :erase_token, :set_secret].each { |sym|
+      assert (Packing.methods.include? sym), "Gear class methods were not packed, missing #{sym.to_s}."
+    }
+  end
+
+  def test_setup_callback
+    secret = Packing.options[:secret_token]
+    assert (secret == "top_secret_code"), "Gear setup callback failed: \"#{secret}\" should be \"top_secret_code\"."
+  end
+
+  # Maybe move the Camping Filters tests somewhere else later.
+  def test_before_filter
+    get '/'
+    assert_body "true", "Before filter did not work."
+  end
+
+  def test_after_filter
+    get '/work'
+    assert (body() == "This is nice"), "After filter did not work."
+  end
+
+end

data/test/app_camping_tools.rb

@@ -0,0 +1 @@
+# Test Camping tools here.

data/test/app_config.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+require 'camping'
+
+module Config end
+
+class Config::Test < TestCase
+
+  def setup
+    write_config()
+    Camping.goes :Config
+    @options = Camping::Apps.select{|a| a.name == "Config" }.first.options
+    super
+  end
+
+  def teardown
+    trash_config()
+    super
+  end
+
+  def test_config
+    assert @options.has_key? :hostname
+    assert @options.has_key? :friends
+    assert_equal @options[:friends].first, "_why", "_why isn't here?"
+    assert_equal @options[:friends].length, 3, "Where are all our friends?"
+    assert_equal @options.has_key?(:database), true, "By Golly the Database settings are missing."
+    assert_equal @options[:database].length, 4, "We're missing some database settings."
+    assert_equal @options[:database][:adapter], "sqlite3", "sqlite is missing. Not good."
+  end
+
+end

data/test/app_cookies.rb

@@ -55,7 +55,7 @@ class Cookies::Test < TestCase
   def test_path
     get '/one', {}, 'SCRIPT_NAME' => '/mnt'
     assert_body '["42", "43", "past"]'
-    assert_equal 3, last_response.headers["Set-Cookie"].scan('path=/mnt/').size
+    assert_equal 3, last_response.headers["set-cookie"].map{|d|d.include?('path=/mnt/')}.size, "We were expecting a different number of 'path=/mnt/' declarations in the array. #{last_response.headers['set-cookie']}"
   end
 end
 

data/test/app_file.rb

@@ -20,15 +20,15 @@ class FileSource::Test < TestCase
   def test_file
     get '/style.css'
     assert_body "* { margin: 0; padding: 0 }"
-    assert_equal "text/css", last_response.headers['Content-Type']
+    assert_equal "text/css", last_response.headers['content-type']
 
     get '/test.foo'
     assert_body "Hello"
-    assert_equal "text/html", last_response.headers['Content-Type']
+    assert_equal "text/html", last_response.headers['content-type']
 
     get '/test'
     assert_body "No extension"
-    assert_equal "text/html", last_response.headers['Content-Type']
+    assert_equal "text/html", last_response.headers['content-type']
   end
 end