picnic 0.7.1 → 0.8.0

data/vendor/camping-2.0.20090212/lib/camping.rb

@@ -0,0 +1,54 @@
+%w[uri stringio rack].map{|l|require l};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=[];class H<Hash
+def method_missing m,*a;m.to_s=~/=$/?self[$`]=a[0]:a==[]?self[m.to_s]:super end
+undef id,type;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 x.scan(p).size==g.size&&/^#{x}\/?$/=~(x=g.inject(x){|x,a|
+x.sub p,U.escape((a[a.class.primary_key]rescue a))})}
+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;module Base;attr_accessor:input,:cookies,:headers,:body,:status,:root
+def render v,*a,&b;mab(/^_/!~v.to_s){send(v,*a,&b)} end
+def mab l=nil,&b;m=Mab.new({},self);s=m.capture(&b)
+s=m.capture{layout{s}} if l && m.respond_to?(:layout);s 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=env.PATH;r 404,P%"#{p} not found"end;def r500 k,m,x
+r 500,P%"#{k}.#{m}"+"<h3>#{x.class} #{x.message}: <ul>#{x.
+backtrace.map{|b|"<li>#{b}</li>"}}</ul></h3>"end;def r501 m=@method
+r 501,P%"#{m.upcase} not implemented"end;def to_a
+@response.body=@body.respond_to?(:each)?@body:""
+@response.status=@status;@response.headers.merge!(@headers)
+@cookies.each{|k,v|v={:value=>v,:path=>self/"/"} if String===v
+@response.set_cookie(k,v) if @request.cookies[k]!=v}
+@response.to_a;end;def initialize(env)
+@request,@response,@env=Rack::Request.new(env),Rack::Response.new,env
+@root,@input,@cookies,@headers,@status=
+@env.SCRIPT_NAME.sub(/\/$/,''),H[@request.params],
+H[@request.cookies],@response.headers,@response.status
+@input.each{|k,v|if k[-2..-1]=="[]";@input[k[0..-3]]=
+@input.delete(k)elsif k=~/(.*)\[([^\]]+)\]$/
+(@input[$1]||=H[])[$2]=@input.delete(k)end};end;def service *a
+r=catch(:halt){send(@env.REQUEST_METHOD.downcase,*a)};@body||=r
+self;end;end;module Controllers;@r=[];class<<self;def r;@r end;def R *u;r=@r
+Class.new{meta_def(:urls){u};meta_def(:inherited){|x|r<<x}}end
+def D p,m;p='/'if !p||!p[0]
+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
+N=H.new{|_,x|x.downcase}.merge! "N"=>'(\d+)',"X"=>'(\w+)',"Index"=>''
+def M;def M;end;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.scan(/.[^A-Z]*/).map(&N.method(:[]))*'/'}"]
+}if !k.respond_to?:urls}end end;class I<R()
+end; end;X=Controllers;class<<self;def goes m
+Apps<<eval(S.gsub(/Camping/,m.to_s),TOPLEVEL_BINDING) end;def call(
+e)X.M;e=H[e.to_hash];k,m,*a=X.D e.PATH_INFO,(e.REQUEST_METHOD||'get').downcase
+e.REQUEST_METHOD=m;k.new(e).service(*a).to_a;end
+def method_missing m,c,*a;X.M;h=Hash===a[-1]?H[a.pop]:{};e=
+H[h[:env]||{}].merge!({'rack.input'=>StringIO.new,'REQUEST_METHOD'=>m.to_s})
+k=X.const_get(c).new(H[e]);k.send("input=",h[:input])if h[:input]
+k.service(*a);end;end;module Views;include X,Helpers end;module Models
+autoload:Base,'camping/ar';def Y;self;end end;autoload:Mab,'camping/mab';C end

data/vendor/{camping-1.5.180/lib/camping/db.rb → camping-2.0.20090212/lib/camping/ar.rb}

@@ -71,8 +71,8 @@ module Camping
     module_eval $AR_EXTRAS
   end
 end
-Camping::S.sub! "autoload:Base,'camping/db'", ""
-Camping::S.sub! "def Y;self;end", $AR_EXTRAS
-Camping::Apps.each do |app|
-    app::Models.module_eval $AR_EXTRAS
+Camping::S.sub! /autoload\s*:Base\s*,\s*['"]camping\/ar['"]/, ""
+Camping::S.sub! /def\s*Y[;\s]*self[;\s]*end/, $AR_EXTRAS
+Camping::Apps.each do |c|
+  c::Models.module_eval $AR_EXTRAS
 end

data/vendor/{camping-1.5.180/lib/camping → camping-2.0.20090212/lib/camping/ar}/session.rb

@@ -1,22 +1,25 @@
-# == About camping/session.rb
+# == About camping/ar/session.rb
 #
 # This file contains two modules which supply basic sessioning to your Camping app.
 # Again, we're dealing with a pretty little bit of code: approx. 60 lines.
 # 
 # * Camping::Models::Session is a module which adds a single <tt>sessions</tt> table
 #   to your database.
-# * Camping::Session is a module which you will mix into your application (or into
+# * Camping::ARSession is a module which you will mix into your application (or into
 #   specific controllers which require sessions) to supply a <tt>@state</tt> variable
 #   you can use in controllers and views.
 #
-# For a basic tutorial, see the *Getting Started* section of the Camping::Session module.
+# For a basic tutorial, see the *Getting Started* section of the Camping::ARSession module.
 require 'camping'
+require 'camping/ar'
 
 module Camping::Models
 # A database table for storing Camping sessions.  Contains a unique 32-character hashid, a
 # creation timestamp, and a column of serialized data called <tt>ivars</tt>. 
 class Session < Base
     serialize :ivars
+    set_primary_key :hashid
+
     def []=(k, v) # :nodoc:
         self.ivars[k] = v
     end
@@ -24,13 +27,17 @@ class Session < Base
         self.ivars[k] rescue nil
     end
 
+  protected
     RAND_CHARS = [*'A'..'Z'] + [*'0'..'9'] + [*'a'..'z']
+    def before_create
+      rand_max = RAND_CHARS.size
+      sid = (0...32).inject("") { |ret,_| ret << RAND_CHARS[rand(rand_max)] }
+      write_attribute('hashid', sid)
+    end
 
     # Generates a new session ID and creates a row for the new session in the database.
     def self.generate cookies
-        rand_max = RAND_CHARS.size
-        sid = (0...32).inject("") { |ret,_| ret << RAND_CHARS[rand(rand_max)] }
-        sess = Session.create :hashid => sid, :ivars => Camping::H[]
+        sess = Session.create :ivars => Camping::H[]
         cookies.camping_sid = sess.hashid
         sess
     end
@@ -38,6 +45,7 @@ class Session < Base
     # Gets the existing session based on the <tt>camping_sid</tt> available in cookies.
     # If none is found, generates a new session.
     def self.persist cookies
+        session = nil
         if cookies.camping_sid
             session = Camping::Models::Session.find_by_hashid cookies.camping_sid
         end
@@ -62,21 +70,22 @@ class Session < Base
     def self.create_schema
         unless table_exists?
             ActiveRecord::Schema.define do
-                create_table :sessions, :force => true do |t|
-                    #t.column :id,          :integer, :null => false
-                    t.column :hashid,      :string,  :limit => 32
+                create_table :sessions, :force => true, :id => false do |t|
+                    t.column :hashid,      :string,  :limit => 32, :null => false
                     t.column :created_at,  :datetime
                     t.column :ivars,       :text
                 end
+                add_index :sessions, [:hashid], :unique => true
             end
             reset_column_information
         end
     end
 end
+Session.partial_updates = false if Session.respond_to?(:partial_updates=)
 end
 
 module Camping
-# The Camping::Session module is designed to be mixed into your application or into specific
+# The Camping::ARSession module is designed to be mixed into your application or into specific
 # controllers which require sessions.  This module defines a <tt>service</tt> method which
 # intercepts all requests handed to those controllers.
 #
@@ -85,7 +94,7 @@ module Camping
 # To get sessions working for your application:
 #
 # 1. <tt>require 'camping/session'</tt>
-# 2. Mixin the module: <tt>module YourApp; include Camping::Session end</tt>
+# 2. Mixin the module: <tt>module YourApp; include Camping::ARSession end</tt>
 # 3. In your application's <tt>create</tt> method, add a call to <tt>Camping::Models::Session.create_schema</tt>
 # 4. Throughout your application, use the <tt>@state</tt> var like a hash to store your application's data. 
 # 
@@ -99,7 +108,7 @@ module Camping
 # * All mounted Camping apps using this class will use the same database table.
 # * However, your application's data is stored in its own hash.
 # * Session data is only saved if it has changed. 
-module Session
+module ARSession
     # This <tt>service</tt> method, when mixed into controllers, intercepts requests
     # and wraps them with code to start and close the session.  If a session isn't found
     # in the database it is created.  The <tt>@state</tt> variable is set and if it changes,
@@ -109,7 +118,8 @@ module Session
         app = self.class.name.gsub(/^(\w+)::.+$/, '\1')
         @state = (session[app] ||= Camping::H[])
         hash_before = Marshal.dump(@state).hash
-        s = super(*a)
+        return super(*a)
+    ensure
         if session
             hash_after = Marshal.dump(@state).hash
             unless hash_before == hash_after
@@ -117,7 +127,6 @@ module Session
                 session.save
             end
         end
-        s
     end
 end
 end

data/vendor/camping-2.0.20090212/lib/camping/mab.rb

@@ -0,0 +1,26 @@
+class MissingLibrary < Exception #:nodoc: all
+end
+begin
+    require 'markaby'
+rescue LoadError => e
+    raise MissingLibrary, "Markaby 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
+    include Views
+    def tag!(*g,&b)
+      h=g[-1]
+      [:href,:action,:src].map{|a|(h[a]&&=self/h[a])rescue 0}
+      super
+    end
+  end
+}
+
+Camping::S.sub! /autoload\s*:Mab\s*,\s*['"]camping\/mab['"]/, $MAB_CODE
+Camping::Apps.each do |c|
+  c.module_eval $MAB_CODE
+end

data/vendor/camping-2.0.20090212/lib/camping/reloader.rb

@@ -0,0 +1,163 @@
+module Camping
+  # == The Camping Reloader
+  #
+  # Camping apps are generally small and predictable.  Many Camping apps are
+  # contained within a single file.  Larger apps are split into a handful of
+  # other Ruby libraries within the same directory.
+  #
+  # Since Camping apps (and their dependencies) are loaded with Ruby's require
+  # method, there is a record of them in $LOADED_FEATURES.  Which leaves a
+  # perfect space for this class to manage auto-reloading an app if any of its
+  # immediate dependencies changes.
+  #
+  # == Wrapping Your Apps
+  #
+  # Since bin/camping and the Camping::FastCGI class already use the Reloader,
+  # you probably don't need to hack it on your own.  But, if you're rolling your
+  # own situation, here's how.
+  #
+  # Rather than this:
+  #
+  #   require 'yourapp'
+  #
+  # Use this:
+  #
+  #   require 'camping/reloader'
+  #   Camping::Reloader.new('/path/to/yourapp.rb')
+  #
+  # The reloader will take care of requiring the app and monitoring all files
+  # for alterations.
+  class Reloader
+    attr_accessor :klass, :mtime, :mount, :requires
+
+    # 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(script)
+      @script = File.expand_path(script)
+      @mount = File.basename(script, '.rb')
+      @requires = nil
+      load_app
+    end
+
+    # Find the application, based on the script name.
+    def find_app(title)
+      @klass = Object.const_get(Object.constants.grep(/^#{title}$/i)[0]) rescue nil
+    end
+
+    # If the file isn't found, if we need to remove the app from the global
+    # namespace, this will be sure to do so and set @klass to nil.
+    def remove_app
+      if @klass
+        Camping::Apps.delete(@klass)
+        Object.send :remove_const, @klass.name
+        @klass = nil
+      end 
+    end
+
+    # Loads (or reloads) the application.  The reloader will take care of calling
+    # this for you.  You can certainly call it yourself if you feel it's warranted.
+    def load_app
+      title = File.basename(@script)[/^([\w_]+)/,1].gsub /_/,'' 
+      begin
+        all_requires = $LOADED_FEATURES.dup
+        load @script
+        @requires = ($LOADED_FEATURES - all_requires).select do |req|
+          req.index(File.basename(@script) + "/") == 0 || req.index(title + "/") == 0
+        end
+      rescue Exception => e
+        puts "!! trouble loading #{title.inspect}: [#{e.class}] #{e.message}"
+        puts e.backtrace.join("\n")
+        find_app title
+        remove_app
+        return
+      end
+
+      @mtime = mtime
+      find_app title
+      unless @klass and @klass.const_defined? :C
+        puts "!! trouble loading #{title.inspect}: not a Camping app, no #{title.capitalize} module found"
+        remove_app
+        return
+      end
+
+      Reloader.conditional_connect
+      @klass.create if @klass.respond_to? :create
+      puts "** #{title.inspect} app loaded"
+      @klass
+    end
+
+    # The timestamp of the most recently modified app dependency.
+    def mtime
+      ((@requires || []) + [@script]).map do |fname|
+        fname = fname.gsub(/^#{Regexp::quote File.dirname(@script)}\//, '')
+        begin
+          File.mtime(File.join(File.dirname(@script), fname))
+        rescue Errno::ENOENT
+          remove_app
+          @mtime
+        end
+      end.reject{|t| t > Time.now }.max
+    end
+
+    # Conditional reloading of the app.  This gets called on each request and
+    # only reloads if the modification times on any of the files is updated.
+    def reload_app 
+      return if @klass and @mtime and mtime <= @mtime
+
+      if @requires
+        @requires.each { |req| $LOADED_FEATURES.delete(req) }
+      end
+      remove_app
+      load_app
+    end
+
+    # Conditionally reloads (using reload_app.)  Then passes the request through
+    # to the wrapped Camping app.
+    def call(*a) 
+      reload_app
+      if @klass
+        @klass.call(*a) 
+      else
+        Camping.call(*a)
+      end
+    end
+
+    # Returns source code for the main script in the application.
+    def view_source
+      File.read(@script)
+    end
+
+    class << self
+      attr_writer :database, :log
+
+      def conditional_connect
+        # If database models are present, `autoload?` will return nil.
+        unless Camping::Models.autoload? :Base
+          if @database and @database[:adapter] == 'sqlite3'
+            begin
+              require 'sqlite3_api'
+            rescue LoadError
+              puts "!! Your SQLite3 adapter isn't a compiled extension."
+              abort "!! Please check out http://code.whytheluckystiff.net/camping/wiki/BeAlertWhenOnSqlite3 for tips."
+            end
+          end
+
+          case @log
+          when Logger
+            Camping::Models::Base.logger = @log
+          when String
+            require 'logger'
+            Camping::Models::Base.logger = Logger.new(@log == "-" ? STDOUT : @log)
+          end
+
+          Camping::Models::Base.establish_connection @database if @database
+
+          if Camping::Models.const_defined?(:Session)
+            Camping::Models::Session.create_schema
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/camping-2.0.20090212/lib/camping/server.rb

@@ -0,0 +1,158 @@
+require 'irb'
+require 'rack'
+require 'camping/reloader'
+
+module Camping::Server
+class Base < Hash
+  include Enumerable
+  
+  attr_reader :paths
+  attr_accessor :conf
+  
+  def initialize(conf, paths = [])
+    unless conf.database
+      raise "!! No home directory found.  Please specify a database file, see --help."
+    end
+    
+    @conf = conf
+    Camping::Reloader.database = conf.database
+    Camping::Reloader.log = conf.log
+    
+    @paths = []
+    paths.each { |script| add_app script }
+    # TODO exception instead of abort()
+    # abort("** No apps successfully loaded") unless self.detect { |app| app.klass }
+    
+  end
+
+  def add_app(path)
+    @paths << path
+    if File.directory? path
+        Dir[File.join(path, '*.rb')].each { |s| insert_app(s)}
+    else
+        insert_app(path)
+    end
+    # TODO check to see if the application is created or not... exception perhaps?
+  end
+  
+  def find_new_scripts
+      self.values.each { |app| app.reload_app }
+      @paths.each do |path|
+          Dir[File.join(path, '*.rb')].each do |script|
+              smount = File.basename(script, '.rb')
+              next if detect { |x| x.mount == smount }
+  
+              puts "** Discovered new #{script}"
+              # TODO hmm. the next should be handled by the add_app thingy
+              app = insert_app(script)
+              next unless app
+  
+              yield app
+              
+          end
+      end
+      self.values.sort! { |x, y| x.mount <=> y.mount }
+  end
+  def index_page
+      welcome = "You are Camping"
+      apps = self
+      <<-HTML
+<html>
+  <head>
+    <title>#{welcome}</title>
+    <style type="text/css">
+      body { 
+        font-family: verdana, arial, sans-serif; 
+        padding: 10px 40px; 
+        margin: 0; 
+      }
+      h1, h2, h3, h4, h5, h6 {
+        font-family: utopia, georgia, serif;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>#{welcome}</h1>
+    <p>Good day.  These are the Camping apps you've mounted.</p>
+    <ul>
+      #{apps.values.select{|app|app.klass}.map do |app|
+        "<li><h3 style=\"display: inline\"><a href=\"/#{app.mount}\">#{app.klass.name}</a></h3><small> / <a href=\"/code/#{app.mount}\">View source</a></small></li>"
+      end.join("\n")}
+    </ul>
+  </body>
+</html>
+      HTML
+  end
+  
+  def each(&b)
+      self.values.each(&b)
+  end
+
+  # for RSpec tests
+  def apps
+      self.values
+  end
+  
+  def start
+    handler, conf = case @conf.server
+    when "console"
+      ARGV.clear
+      IRB.start
+      exit
+    when "mongrel"
+      puts "** Starting Mongrel on #{@conf.host}:#{@conf.port}"
+      [Rack::Handler::Mongrel, {:Port => @conf.port, :Host => @conf.host}]
+    when "webrick"
+      [Rack::Handler::WEBrick, {:Port => @conf.port, :BindAddress => @conf.host}]
+    end
+    
+    rapp = if apps.length > 1
+      hash = {
+        "/" => proc {|env|[200,{'Content-Type'=>'text/html'},index_page]}
+      }
+      apps.each do |app|
+        hash["/#{app.mount}"] = app
+        hash["/code/#{app.mount}"] = proc do |env|
+          [200,{'Content-Type'=>'text/plain'},app.view_source]
+        end
+      end
+      Rack::URLMap.new(hash)
+    else
+      apps.first
+    end
+    rapp = Rack::Lint.new(rapp)
+    rapp = XSendfile.new(rapp)
+    rapp = Rack::ShowExceptions.new(rapp)
+    handler.run(rapp, conf) 
+  end
+  
+  private
+  
+  def insert_app(script)
+    self[script] = Camping::Reloader.new(script)
+  end
+end
+
+# A Rack middleware for reading X-Sendfile. Should only be used in
+# development.
+class XSendfile
+  
+  HEADERS = [
+    "X-Sendfile",
+    "X-Accel-Redirect",
+    "X-LIGHTTPD-send-file"
+  ]
+  
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    status, headers, body = @app.call(env)
+    if path = headers.values_at(*HEADERS).compact.first
+      body = File.read(path)
+    end
+    [status, headers, body]
+  end
+end
+end