picnic 0.7.1 → 0.8.0

data/lib/picnic/utils.rb

@@ -1,36 +0,0 @@
-module Picnic
-  # Supporting utility functions used throughout Picnic
-  module Utils
-    # Generates a random string, at most 32 characters in length.
-    def random_string
-      "#{Time.now.to_i}r%X" % rand(10**32)
-    end
-    module_function :random_string
-    
-    # The customized Logger used for logging in Picnic.
-    class Logger < ::Logger
-      def initialize(logdev, shift_age = 0, shift_size = 1048576)
-        begin
-          super
-        rescue Exception
-          puts "WARNING: Couldn't create Logger with output '#{logdev}'. Logger output will be redirected to STDOUT."
-          super(STDOUT, shift_age, shift_size)
-        end
-      end
-    
-      def format_message(severity, datetime, progrname, msg)
-        (@formatter || @default_formatter).call(severity, datetime, progname, msg)
-      end
-    end
-  end
-  
-  # Custom log formatter used by the Picnic Logger.
-  class LogFormatter < ::Logger::Formatter
-    Format = "[%s#%d] %5s -- %s: %s\n"
-    
-    def call(severity, time, progname, msg)
-      Format % [format_datetime(time), $$, severity, progname,
-        msg2str(msg)]
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-%w[active_support markaby tempfile uri].map{|l|require l}
-module Camping;Apps=[];C=self;S=IO.read(__FILE__).sub(/S=I.+$/,'')
-P="Cam\ping Problem!";module Helpers;def R(c,*g);p,h=/\(.+?\)/,g.grep(Hash)
-(g-=h).inject(c.urls.find{|x|x.scan(p).size==g.size}.dup){|s,a|s.sub p,C.
-escape((a[a.class.primary_key]rescue a))}+(h.any?? "?"+h[0].map{|x|x.map{|z|C.
-escape z}*"="}*"&": "")end;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;def/p
-p[/^\//]?@root+p : p end;def errors_for o;ul.errors{o.errors.each_full{|x|li x}
-}if o.errors.any?end end;module Base;include Helpers;attr_accessor:input,
-:cookies,:env,:headers,:body,:status,:root;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;def r s,b,h={};@status=s;@headers.merge!h;@body=b end
-def redirect*a;r 302,'','Location'=>URL(*a)end;Z="\r\n"
-def to_a;[@status,@body,@headers]end
-def initialize r,e,m;e=H[e.to_hash];@status,@method,@env,@headers,@root=200,m.
-downcase,e,{'Content-Type'=>"text/html"},e.SCRIPT_NAME.sub(/\/$/,'')
-@k=C.kp e.HTTP_COOKIE;q=C.qsp e.QUERY_STRING;@in=r
-if%r|\Amultipart/form-.*boundary=\"?([^\";,]+)|n.match e.CONTENT_TYPE
-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;while l=@in.read(16384);if l=~b;o<<$`.chomp;@in.seek(-$'.
-size,IO::SEEK_CUR);break;end;o<<l;end;C.qsp(fn,'&;',fh,q) if fn;fh[:tempfile].rewind if
-fh.is_a?H;end;elsif@method=="post";q.u C.qsp(@in.read)end;@cookies,@input=
-@k.dup,q.dup end;def service*a;@body=send(@method,*a)if respond_to?@method
-@headers["Set-Cookie"]=@cookies.map{|k,v|"#{k}=#{C.escape(v[:value] || v)
-}; path=#{self/'/'}; expires=#{v[:expires] && 
-v[:expires].strftime('%a, %d-%b-%Y %H:%M:%S %Z') || nil}"if v!=@k[k]}-[nil];
-self end;def to_s;a=[];@headers.map{|k,v|[*v].map{|x|a<<
-"#{k}: #{x}"}};"Status: #{@status}#{Z+a*Z+Z*2+@body}"end;end
-X=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 M;def M;end;constants.map{|c|
-k=const_get(c);k.send:include,C,Base,Models;r[0,0]=k if !r.include?k;k.meta_def(
-:urls){["/#{c.downcase}"]}if !k.respond_to?:urls}end;def D p;r.map{|k|k.urls.
-map{|x|return k,$~[1..-1]if p=~/^#{x}\/?$/}};[NotFound,[p]]end end;class 
-NotFound<R();def get p;r(404,Mab.new{h1 P;h2 p+" not found"})end end;class 
-ServerError<R();def get k,m,e;r(500,Mab.new{h1 P;h2"#{k}.#{m}";h3"#{e.class
-} #{e.message}:";ul{e.backtrace.each{|bt|li(bt)}}}.to_s)end end;self;end;class<<
-self;def goes m;eval S.gsub(/Camping/,m.to_s).gsub("A\pps=[]","Cam\ping::Apps<<\
-self"),TOPLEVEL_BINDING;end;def escape s;s.to_s.gsub(/[^ \w.-]+/n){'%'+($&.
-unpack('H2'*$&.size)*'%').upcase}.tr(' ','+')end;def un s;s.tr('+',' ').gsub(
-/%([\da-f]{2})/in){[$1].pack('H*')}end;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;def
-kp s;c=qsp(s,';,')end;def run r=$stdin,e=ENV;X.M;k,a=X.D un("/#{e[
-'PATH_INFO']}".gsub(/\/+/,'/'));k.new(r,e,(m=e['REQUEST_METHOD']||"GET")).Y.
-service *a;rescue Object=>x;X::ServerError.new(r,e,'get').service(k,m,x)end
-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.new(a.pop).each{|e,f|k.send(
-"#{e}=",f)}if Hash===a[-1];k.service *a;end;end;module Views;include X,Helpers
-end;module Models;autoload:Base,'camping/db';def Y;self;end;end;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;H=HashWithIndifferentAccess;class H;def method_missing m,*a
-m.to_s=~/=$/?self[$`]=a[0]:a==[]?self[m]:raise(NoMethodError,"#{m}")end
-alias_method:u,:regular_update;end end

data/vendor/camping-1.5.180/lib/camping/fastcgi.rb

@@ -1,244 +0,0 @@
-# == About camping/fastcgi.rb
-#
-# Camping works very well with FastCGI, since your application is only loaded
-# once -- when FastCGI starts.  In addition, this class lets you mount several
-# Camping apps under a single FastCGI process, to help save memory costs.
-#
-# So where do you use the Camping::FastCGI class?  Use it in your application's
-# postamble and then you can point your web server directly at your application.
-# See Camping::FastCGI docs for more.
-require 'camping'
-require 'fcgi'
-
-module Camping
-# Camping::FastCGI is a small class for hooking one or more Camping apps up to
-# FastCGI.  Generally, you'll use this class in your application's postamble.
-#
-# == The Smallest Example
-#
-#  if __FILE__ == $0
-#    require 'camping/fastcgi'
-#    Camping::FastCGI.start(YourApp)
-#  end
-#
-# This example is stripped down to the basics.  The postamble has no database
-# connection.  It just loads this class and calls Camping::FastCGI.start.
-#
-# Now, in Lighttpd or Apache, you can point to your app's file, which will
-# be executed, only to discover that your app now speaks the FastCGI protocol.
-#
-# Here's a sample lighttpd.conf (tested with Lighttpd 1.4.11) to serve as example:
-#
-#   server.port                 = 3044
-#   server.bind                 = "127.0.0.1"
-#   server.modules              = ( "mod_fastcgi" )
-#   server.document-root        = "/var/www/camping/blog/" 
-#   server.errorlog             = "/var/www/camping/blog/error.log" 
-#   
-#   #### fastcgi module
-#   fastcgi.server = ( "/" => ( 
-#     "localhost" => ( 
-#       "socket" => "/tmp/camping-blog.socket",
-#       "bin-path" => "/var/www/camping/blog/blog.rb",
-#       "check-local" => "disable",
-#       "max-procs" => 1 ) ) )
-#
-# The file <tt>/var/www/camping/blog/blog.rb</tt> is the Camping app with
-# the postamble.
-#
-# == Mounting Many Apps
-#
-#  require 'camping/fastcgi'
-#  fast = Camping::FastCGI.new
-#  fast.mount("/blog", Blog)
-#  fast.mount("/tepee", Tepee)
-#  fast.mount("/", Index)
-#  fast.start
-#
-class FastCGI
-    CHUNK_SIZE=(4 * 1024)
-
-    attr_reader :mounts
-
-    # Creates a Camping::FastCGI class with empty mounts.
-    def initialize
-        @mounts = {}
-    end
-    # Mounts a Camping application.  The +dir+ being the name of the directory
-    # to serve as the application's root.  The +app+ is a Camping class.
-    def mount(dir, app)
-        dir.gsub!(/\/{2,}/, '/')
-        dir.gsub!(/\/+$/, '')
-        @mounts[dir] = app
-    end
-
-    # 
-    # Starts the FastCGI main loop.
-    def start(&blk)
-        FCGI.each do |req|
-            camp_do(req, &blk)
-        end
-    end
-
-    # A simple single-app starter mechanism
-    #
-    #   Camping::FastCGI.start(Blog)
-    #
-    def self.start(app)
-        cf = Camping::FastCGI.new
-        cf.mount("/", app)
-        cf.start
-    end
-
-    # Serve an entire directory of Camping apps. (See 
-    # http://code.whytheluckystiff.net/camping/wiki/TheCampingServer.)
-    #
-    # Use this method inside your FastCGI dispatcher:
-    #
-    #   #!/usr/local/bin/ruby
-    #   require 'rubygems'
-    #   require 'camping/fastcgi'
-    #   Camping::Models::Base.establish_connection :adapter => 'sqlite3', :database => "/path/to/db"
-    #   Camping::FastCGI.serve("/home/why/cvs/camping/examples")
-    # 
-    def self.serve(path, index=nil)
-        require 'camping/reloader'
-        if File.directory? path
-            fast = Camping::FastCGI.new
-            script_load = proc do |script|
-                app = Camping::Reloader.new(script)
-                fast.mount("/#{app.mount}", app)
-                app
-            end
-            Dir[File.join(path, '*.rb')].each &script_load
-            fast.mount("/", index) if index
-
-            fast.start do |dir, app|
-                 Dir[File.join(path, dir, '*.rb')].each do |script|
-                     smount = "/" + File.basename(script, '.rb')
-                     script_load[script] unless fast.mounts.has_key? smount
-                 end
-            end
-        else
-            start(Camping::Reloader.new(path))
-        end
-    end
-
-    private
-
-    def camp_do(req)
-        root, path, dir, app = "/"
-        if ENV['FORCE_ROOT'] and ENV['FORCE_ROOT'].to_i == 1
-            path = req.env['SCRIPT_NAME']
-        else
-            root = req.env['SCRIPT_NAME']
-            path = req.env['PATH_INFO']
-        end
-
-        dir, app = @mounts.max { |a,b| match(path, a[0]) <=> match(path, b[0]) }
-        unless dir and app
-            dir, app = '/', Camping
-        end
-        yield dir, app if block_given?
-
-        req.env['SERVER_SCRIPT_NAME'] = req.env['SCRIPT_NAME']
-        req.env['SERVER_PATH_INFO'] = req.env['PATH_INFO']
-        req.env['SCRIPT_NAME'] = File.join(root, dir)
-        req.env['PATH_INFO'] = path.gsub(/^#{dir}/, '')
-
-        controller = app.run(SeekStream.new(req.in), req.env)
-        sendfile = nil
-        headers = {}
-        controller.headers.each do |k, v|
-            if k =~ /^X-SENDFILE$/i and !ENV['SERVER_X_SENDFILE']
-                sendfile = v
-            else
-                headers[k] = v
-            end
-        end
-
-        body = controller.body
-        controller.body = ""
-        controller.headers = headers
-
-        req.out << controller.to_s
-        if sendfile
-            File.open(sendfile, "rb") do |f|
-                while chunk = f.read(CHUNK_SIZE) and chunk.length > 0
-                    req.out << chunk
-                end
-            end
-        elsif body.respond_to? :read
-            while chunk = body.read(CHUNK_SIZE) and chunk.length > 0
-                req.out << chunk
-            end
-            body.close if body.respond_to? :close
-        else
-            req.out << body.to_s
-        end
-    rescue Exception => e
-        req.out << server_error(root, path, exc, req)
-    ensure
-        req.finish
-    end
-
-    def server_error(root, path, exc, req)
-        "Content-Type: text/html\r\n\r\n" +
-        "<h1>Camping Problem!</h1>" +
-        "<h2><strong>#{root}</strong>#{path}</h2>" + 
-        "<h3>#{exc.class} #{esc exc.message}</h3>" +
-        "<ul>" + exc.backtrace.map { |bt| "<li>#{esc bt}</li>" }.join + "</ul>" +
-        "<hr /><p>#{req.env.inspect}</p>"
-    end
-
-    def match(path, mount)
-        m = path.match(/^#{Regexp::quote mount}(\/|$)/)
-        if m; m.end(0)
-        else  -1
-        end
-    end
-
-    def esc(str)
-        str.gsub(/&/n, '&amp;').gsub(/\"/n, '&quot;').gsub(/>/n, '&gt;').gsub(/</n, '&lt;')
-    end
-
-    class SeekStream
-        def initialize(stream)
-            @last_read = ""
-            @stream = stream
-            @buffer = ""
-        end
-        def eof?
-            @buffer.empty? && @stream.eof?
-        end
-        def each
-            while true
-                pull(1024) until eof? or @buffer.index("\n")
-                return nil if eof?
-                yield @buffer.slice!(0..(@buffer.index("\n") || -1))
-            end
-        end
-        def pull(len)
-            @buffer += @stream.read(len).to_s
-        end
-        def read(len = 16384)
-            pull(len)
-            @last_read =
-                if eof?
-                    nil
-                else
-                    @buffer.slice!(0...len)
-                end
-        end
-        def seek(len, typ)
-            raise NotImplementedError, "only IO::SEEK_CUR is supported with SeekStream" if typ != IO::SEEK_CUR
-            raise NotImplementedError, "only rewinding is supported with SeekStream" if len > 0
-            raise NotImplementedError, "rewinding #{-len} past the buffer #{@last_read.size} start not supported with SeekStream" if -len > @last_read.size
-            @buffer = @last_read[len..-1] + @buffer
-            @last_read = ""
-            self
-        end
-    end
-
-end
-end

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

@@ -1,163 +0,0 @@
-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
-        Object.send :remove_const, @klass.name if @klass
-        @klass = nil
-    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}: [#{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}: not a Camping app, no #{title.capitalize} module found"
-            remove_app
-            return
-        end
-        
-        Reloader.conditional_connect
-        @klass.create if @klass.respond_to? :create
-        @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.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
-        k = @klass
-        Object.send :remove_const, k.name if k
-        load_app
-    end
-
-    # Conditionally reloads (using reload_app.)  Then passes the request through
-    # to the wrapped Camping app.
-    def run(*a)
-        reload_app
-        if @klass
-            @klass.run(*a) 
-        else
-            Camping.run(*a)
-        end
-    end
-
-    # Returns source code for the main script in the application.
-    def view_source
-        File.read(@script)
-    end
-
-    class << self
-        def database=(db)
-            @database = db
-        end
-        def log=(log)
-            @log = log
-        end
-        def conditional_connect
-            # If database models are present, `autoload?` will return nil.
-            unless Camping::Models.autoload? :Base
-                require 'logger'
-                require 'camping/session'
-                Camping::Models::Base.establish_connection @database if @database
-
-                case @log
-                when Logger
-                    Camping::Models::Base.logger = @log
-                when String
-                    Camping::Models::Base.logger = Logger.new(@log == "-" ? STDOUT : @log)
-                end
-
-                Camping::Models::Session.create_schema
-
-                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
-            end
-        end
-    end
-end
-end