camping 2.1.467 → 2.1.523

data/book/{51_upgrading → 51_upgrading.md}

@@ -1,36 +1,36 @@
-= Appendix I: Upgrade Notes
+# Appendix I: Upgrade Notes
 
 This document includes everything needed in order to *upgrade* your
 applications. If you're looking for all the new features in a version, please
 have a look at the CHANGELOG in the Camping source.
 
 
-== From 2.0 to 2.1
-=== Options
+##From 2.0 to 2.1
+###Options
 
 In Camping 2.1 there is now a built-in way to store options and settings. If
 you use cookie session, it means that you'll now have to change to:
 
-  module Nuts
-    set :secret, "Very secret text, which no-one else should know!"
-    include Camping::Session
-  end
+    module Nuts
+      set :secret, "Very secret text, which no-one else should know!"
+      include Camping::Session
+    end
 
 
-== From 1.5 to 2.0
-=== Rack
+##From 1.5 to 2.0
+###Rack
 
-The biggest change in 2.0 is that it now uses Rack[http://rack.rubyforge.org/]
+The biggest change in 2.0 is that it now uses [Rack](http://rack.rubyforge.org/)
 internally. This means that you'll now have to deploy Camping differently, but
 hopefully more easily too. Now every Camping application is also a Rack
 application, so simply check out the documentation to the server of your
 choice.
 
-=== require 'camping/db'
+###`require 'camping/db'`
 
 In earlier versions of Camping, you loaded database support by:
 
-  require 'camping/db'
+    require 'camping/db'
   
 Actually, this loaded a very thin layer on top of ActiveRecord, and in the
 future we want to experiment with other libraries. Therefore you should now
@@ -40,48 +40,48 @@ also means you'll have to place your migrations *after* the models.
 We also encourage you to use <tt>Model.table_name</tt> instead of
 <tt>:appname_model</tt>, just to make sure it's named correctly.
 
-  ## Don't require anything:
-  # require 'camping/db'
-  
-  module Nuts::Models
-    ## Just inherit Base:
-    class Page < Base; end
+    ## Don't require anything:
+    # require 'camping/db'
     
-    ## Migrations have to come *after* the models:
-    class CreateTheBasics < V 0.1
-      def self.up
-        create_table Page.table_name do |t|
-          ...
-        end
-      end
+    module Nuts::Models
+      ## Just inherit Base:
+      class Page < Base; end
       
-      def self.down
-        drop_table Page.table_name
+      ## Migrations have to come *after* the models:
+      class CreateTheBasics < V 0.1
+        def self.up
+          create_table Page.table_name do |t|
+            ...
+          end
+        end
+        
+        def self.down
+          drop_table Page.table_name
+        end
       end
     end
-  end
 
-=== Cookie Sessions
+###Cookie Sessions
 
 Camping 2.0 now uses a cookie-based session system, which means you now longer
 need a database in order to use sessions. The disadvantage of this is that
 you are restricted to only around 4k of data. See below for the changes
 required, and see Camping::Session more details.
 
-  module Nuts
-    ## Include Camping::Session as before:
-    include Camping::Session
-    
-    ## But also define a secret:
-    secret "Very secret text, which no-one else should know!"
-  end
-  
-  def Nuts.create
-    ## And remove the following line:
-    # Camping::Models::Session.create_schema
-  end
+    module Nuts
+      ## Include Camping::Session as before:
+      include Camping::Session
+      
+      ## But also define a secret:
+      secret "Very secret text, which no-one else should know!"
+    end
+
+    def Nuts.create
+      ## And remove the following line:
+      # Camping::Models::Session.create_schema
+    end
   
-===  Error handling
+###Error handling
 
 Camping now uses three methods in order to handle errors. These replaces the
 old classes NotFound and ServerError.
@@ -93,18 +93,18 @@ old classes NotFound and ServerError.
 
 You can override these in your application:
 
-  module Nuts
-    def r404(path)
-      "Sorry, but I can't find #{path}."
-    end
-    
-    def r501(method)
-      "Sorry, but I can't respond to #{method}."
-    end
-    
-    def r500(klass, method, ex)
-      "Sorry, but #{klass}##{method} failed with #{ex}."
+    module Nuts
+      def r404(path)
+        "Sorry, but I can't find #{path}."
+      end
+      
+      def r501(method)
+        "Sorry, but I can't respond to #{method}."
+      end
+      
+      def r500(klass, method, ex)
+        "Sorry, but #{klass}##{method} failed with #{ex}."
+      end
     end
-  end
   
 It should be noted that this might change in the future.

data/lib/camping-unabridged.rb

@@ -201,7 +201,7 @@ module Camping
     def R(c,*g)
       p,h=/\(.+?\)/,g.grep(Hash)
       g-=h
-      raise "bad route" unless u = c.urls.find{|x|
+      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})
@@ -242,7 +242,7 @@ 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
   end
@@ -291,7 +291,7 @@ module Camping
     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 = (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
@@ -310,7 +310,8 @@ module Camping
     #
     # You can also pass true to use the :layout HTML wrapping method
     def mab(&b)
-      (@mab ||= Mab.new({},self)).capture(&b)
+      extend Mab
+      mab(&b)
     end
     
     # A quick means of setting this controller's status, body and headers
@@ -567,7 +568,7 @@ module Camping
         @r.map { |k|
           k.urls.map { |x|
             return (k.method_defined?(m)) ?
-              [k, m, *$~[1..-1]] : [I, 'r501', m] if p =~ /^#{x}\/?$/
+              [k, m, *$~[1..-1].map{|x|U.unescape(x)}] : [I, 'r501', m] if p =~ /^#{x}\/?$/
           }
         }
         [I, 'r404', p]
@@ -632,8 +633,7 @@ module Camping
     # See: http://rack.rubyforge.org/doc/SPEC.html
     def call(e)
       X.M
-      p = e['PATH_INFO'] = U.unescape(e['PATH_INFO'])
-      k,m,*a=X.D p,e['REQUEST_METHOD'].downcase,e
+      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

data/lib/camping.rb

@@ -10,7 +10,7 @@ end;module Helpers;def R c,*g;p,h=
 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
+:urls);c=self/c;c=@request.url[/.{8,}?(?=\/|$)/]+c if c[0]==?/;URI c end end
 module Base;attr_accessor:env,:request,:root,:input,:cookies,:state,:status,
 :headers,:body;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{
@@ -19,7 +19,7 @@ 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;(@mab||=Mab.new({},self)).capture(&b) end;def r s,b,h={};b,h=
+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)
@@ -34,7 +34,7 @@ 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
 !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]]:
+@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
@@ -44,7 +44,7 @@ Controllers;class<<self;def
 goes m;Apps<<a=eval(S.gsub(/Camping/,m.to_s),TOPLEVEL_BINDING);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
-p=e['PATH_INFO']=U.unescape(e['PATH_INFO']);k,m,*a=X.D p,e['REQUEST_METHOD'].
+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.

data/lib/camping/mab.rb

@@ -1,23 +1,34 @@
 class MissingLibrary < Exception #:nodoc: all
 end
 begin
-    require 'markaby'
+  require 'mab'
 rescue LoadError => e
-    raise MissingLibrary, "Markaby could not be loaded (is it installed?): #{e.message}"
+  raise MissingLibrary, "Mab could not be loaded (is it installed?): #{e.message}"
 end
 
-$MAB_CODE = %{
-  # The Mab class wraps Markaby, allowing it to run methods from Camping::Views
-  # and also to replace :href, :action and :src attributes in tags by prefixing the root
-  # path.
-  class Mab < Markaby::Builder
-    attr_reader :builder
-    
+$MAB_CODE = %q{
+  module Mab
+    include ::Mab::Mixin::HTML5
     include Views
-    def tag!(*g,&b)
-      h=g[-1]
-      [:href,:action,:src].map{|a|(h[a]&&=self/h[a])rescue 0}
-      super
+
+    alias << text!
+
+    def xhtml(*a, &b)
+      warn "xhtml_strict is no longer supported (or an active standard); using HTML5 instead"
+      html(*a, &b)
+    end
+
+    def xhtml_strict(*a, &b) xhtml(*a, &b) end
+    def xhtml_transitional(*a, &b) xhtml(*a, &b) end
+    def xhtml_frameset(*a, &b) xhtml(*a, &b) end
+
+    def helpers() self end
+
+    def html(*) doctype!; super end
+
+    def mab_done(tag)
+      h=tag.attributes
+      [:href,:action,:src].map{|a|h[a]&&=self/h[a]}
     end
   end
 }

data/lib/camping/reloader.rb

@@ -32,157 +32,127 @@ module Camping
   #
   # You can also give Reloader more than one script.
   class Reloader
-    attr_reader :scripts, :apps
+    attr_reader :file
     
-    # This class is doing all the hard work; however, it only works on
-    # single files.  Reloader just wraps up support for multiple scripts
-    # and hides away some methods you normally won't need.
-    class Script # :nodoc:
-      attr_reader :apps, :file, :dir, :extras
-      
-      def initialize(file, callback = nil)
-        @file = File.expand_path(file)
-        @dir = File.dirname(@file)
-        @extras = File.join(@dir, File.basename(@file, ".rb"))
-        @mtime = Time.at(0)
-        @requires = []
-        @apps = {}
-        @callback = callback
+    def initialize(file, &blk)
+      @file = file
+      @mtime = Time.at(0)
+      @requires = []
+      @apps = {}
+      @callback = blk
+    end
+
+    def name
+      @name ||= begin
+        base = @file.dup
+        base = File.dirname(base) if base =~ /\bconfig\.ru$/
+        base.sub!(/\.[^.]+/, '')
+        File.basename(base).to_sym
       end
+    end
+    
+    # Loads the apps availble in this script.  Use <tt>apps</tt> to get
+    # the loaded apps.
+    def load_apps(old_apps)
+      all_requires = $LOADED_FEATURES.dup
+      all_apps = Camping::Apps.dup
+
+      load_file
+    ensure
+      @requires = []
+      dirs = []
+      new_apps = Camping::Apps - all_apps
       
-      # Loads the apps availble in this script.  Use <tt>apps</tt> to get
-      # the loaded apps.
-      def load_apps
-        @requires.each do |path|
-          $LOADED_FEATURES.delete(path)
+      @apps = new_apps.inject({}) do |hash, app|
+        if file = app.options[:__FILE__]
+          full = File.expand_path(file)
+          @requires << [file, full]
+          dirs << full.sub(/\.[^.]+$/, '')
         end
 
-        all_requires = $LOADED_FEATURES.dup
-        all_apps = Camping::Apps.dup
-        
-        begin
-          load(@file)
-        rescue Exception => e
-          puts "!! Error loading #{@file}:"
-          puts "#{e.class}: #{e.message}"
-          puts e.backtrace
-          puts "!! Error loading #{@file}, see backtrace above"
-        end
+        key = app.name.to_sym
+        hash[key] = app
         
-        @requires = ($LOADED_FEATURES - all_requires).map do |req|
-          full = full_path(req)
-          full if full == @file or full.index(@extras) == 0
+        if !old_apps.include?(key)
+          @callback.call(app) if @callback
+          app.create if app.respond_to?(:create)
         end
-        
-        @mtime = mtime
-        
-        new_apps = (Camping::Apps - all_apps)
-        old_apps = @apps.dup
-        
-        @apps = new_apps.inject({}) do |hash, app|
-          key = app.name.to_sym
-          hash[key] = app
-          
-          if !old_apps.include?(key)
-            @callback.call(app) if @callback
-            app.create if app.respond_to?(:create)
-          end
-          hash
-        end
-        
-        self
-      end
-      
-      # Removes all the apps defined in this script.
-      def remove_apps
-        @apps.each do |name, app|
-          Camping::Apps.delete(app)
-          Object.send :remove_const, name
-        end
-      end
-      
-      # Reloads the file if needed.  No harm is done by calling this multiple
-      # times, so feel free call just to be sure.
-      def reload!
-        return if @mtime >= mtime
-        remove_apps
-        load_apps
-      end
-      
-      # Checks if both scripts watches the same file.
-      def ==(other)
-        @file == other.file
+
+        hash
       end
-      
-      private
-      
-      def mtime
-        (@requires + [@file]).compact.map do |fname|
-          File.mtime(fname)
-        end.reject{|t| t > Time.now }.max
+
+      ($LOADED_FEATURES - all_requires).each do |req|
+        full = full_path(req)
+        @requires << [req, full] if dirs.any? { |x| full.index(x) == 0 }
       end
+
+      @mtime = mtime
       
-      # Figures out the full path of a required file. 
-      def full_path(req)
-        dir = $LOAD_PATH.detect { |l| File.exists?(File.join(l, req)) }
-        if dir 
-          File.expand_path(req, File.expand_path(dir))
-        else
-          req
-        end
-      end
+      self
     end
 
-    # Creates the reloader, assigns a +script+ to it and initially loads the
-    # application.  Pass in the full path to the script, otherwise the script
-    # will be loaded relative to the current working directory.
-    def initialize(*scripts)
-      @scripts = []
-      @apps = {}
-      update(*scripts)
+    def load_file
+      if @file =~ /\.ru$/
+        @app,_ = Rack::Builder.parse_file(@file)
+      else
+        load(@file)
+      end
     end
     
-    def on_reload(&blk)
-      @callback = blk
+    # Removes all the apps defined in this script.
+    def remove_apps
+      @requires.each do |(path, full)|
+        $LOADED_FEATURES.delete(path)
+      end
+
+      @apps.each do |name, app|
+        Camping::Apps.delete(app)
+        Object.send :remove_const, name
+      end.dup
+    ensure
+      @apps.clear
     end
     
-    # Updates the reloader to only use the scripts provided:
-    #
-    #   reloader.update("examples/blog.rb", "examples/wiki.rb")
-    def update(*scripts)
-      old_scripts = @scripts.dup
-      clear
-      
-      @scripts = scripts.map do |script|
-        file = File.expand_path(script)
-        old_scripts.detect { |s| s.file == file } or
-        Script.new(script, @callback)
-      end
-      
+    # Reloads the file if needed.  No harm is done by calling this multiple
+    # times, so feel free call just to be sure.
+    def reload
+      return if @mtime >= mtime rescue nil
       reload!
     end
-    
-    # Removes all the scripts from the reloader.
-    def clear
-      @scripts = []
-      @apps = {}
+
+    def reload!
+      load_apps(remove_apps)
     end
     
-    # Returns the script which provided the given app.
-    def script(app)
-      @scripts.each do |script|
-        return script if script.apps.values.include?(app)
+    # Checks if both scripts watches the same file.
+    def ==(other)
+      @file == other.file
+    end
+
+    def apps
+      if @app
+        { name => @app }
+      else
+        @apps
       end
-      
-      false
     end
     
-    # Simply calls reload! on all the Script objects.
-    def reload!
-      @apps = {}
-      @scripts.each do |script|
-        script.reload!
-        @apps.update(script.apps)
+    private
+    
+    def mtime
+      @requires.map do |(path, full)|
+        File.mtime(full)
+      end.reject {|t| t > Time.now }.max || Time.now
+    end
+    
+    # Figures out the full path of a required file. 
+    def full_path(req)
+      return req if File.exists?(req)
+      dir = $LOAD_PATH.detect { |l| File.exists?(File.join(l, req)) }
+      if dir 
+        File.expand_path(req, File.expand_path(dir))
+      else
+        req
       end
     end
   end