zuk-picnic 0.8.0.20090318 → 0.8.0.20090427

data/vendor/camping-2.0.20090212/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
-      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

@@ -1,158 +0,0 @@
-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