zuk-picnic 0.7.999.20090212

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

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

@@ -0,0 +1,74 @@
+# == About camping/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
+#   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.
+#require 'camping'
+require 'base64'
+require 'openssl'
+
+module Camping
+# The Camping::Session 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.
+#
+# == Getting Started
+#
+# 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>
+# 3. Define a secret (and keep it secret): <tt>module YourApp; @@state_secret = "SECRET!"; end</tt>
+# 4. Throughout your application, use the <tt>@state</tt> var like a hash to store your application's data. 
+#
+# == A Few Notes
+#
+# * The session is stored in a cookie. Look in <tt>@cookies.identity</tt>.
+# * Session data is only saved if it has changed. 
+module Session
+    DIGEST = OpenSSL::Digest::SHA1.new
+    # 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 cookie it is created.  The <tt>@state</tt> variable is set and if it changes,
+    # it is saved back into the cookie.
+    def service(*a)
+      @session_blob = @input.camping_blob || @cookies.camping_blob
+      @session_hash = @input.camping_hash || @cookies.camping_hash
+      decoded_blob, data = '', {}
+      begin
+        if @session_blob && @session_hash && secure_blob_hasher(@session_blob) == @session_hash
+          decoded_blob = Base64.decode64(@session_blob)
+          data = Marshal.restore(decoded_blob)
+        end
+
+        app = C.name
+        @state = (data[app] ||= Camping::H[])
+        hash_before = decoded_blob.hash
+        return super(*a)
+      ensure
+        data[app] = @state
+        decoded_blob = Marshal.dump(data)
+        unless hash_before == decoded_blob.hash
+          @session_blob = Base64.encode64(decoded_blob).gsub("\n", '').strip
+          @session_hash = secure_blob_hasher(@session_blob)
+          raise "The session contains to much data" if @session_blob.length > 4096
+          @cookies.camping_blob = @session_blob
+          @cookies.camping_hash = @session_hash
+        end
+      end
+    end
+    
+    def secure_blob_hasher(data)
+      OpenSSL::HMAC.hexdigest(DIGEST, state_secret, "#{@env.REMOTE_ADDR}#{data}")
+    end
+    
+    def state_secret; [__FILE__, File.mtime(__FILE__)].join(":") end
+end
+end