bmarzolf-picnic 0.8.0.20090420

data/vendor/camping-2.0.20090420/examples/tepee.rb

@@ -0,0 +1,242 @@
+#!/usr/bin/ruby
+$:.unshift File.dirname(__FILE__) + "/../lib"
+%w(rubygems redcloth camping camping/ar acts_as_versioned).each { |lib| require lib }
+
+Camping.goes :Tepee
+
+module Tepee::Models
+
+  class Page < Base
+    PAGE_LINK = /\[\[([^\]|]*)[|]?([^\]]*)\]\]/
+    validates_uniqueness_of :title
+    before_save { |r| r.title = r.title.underscore }
+    acts_as_versioned
+  end
+
+  class CreateTepee < V 1.0
+    def self.up
+      create_table :tepee_pages do |t|
+        t.column :title, :string, :limit => 255
+        t.column :body, :text
+      end
+      Page.create_versioned_table
+      Page.reset_column_information
+    end
+    def self.down
+      drop_table :tepee_pages
+      Page.drop_versioned_table
+    end
+  end
+
+end
+
+module Tepee::Controllers
+  class Index < R '/'
+    def get
+      redirect Show, 'home'
+    end
+  end
+
+  class Show < R '/(\w+)', '/(\w+)/(\d+)'
+    def get page_name, version = nil
+      redirect(Edit, page_name, 1) and return unless @page = Page.find_by_title(page_name)
+      @version = (version.nil? or version == @page.version.to_s) ? @page : @page.versions.find_by_version(version)
+      render :show
+    end
+  end
+
+  class Edit < R '/(\w+)/edit', '/(\w+)/(\d+)/edit' 
+    def get page_name, version = nil
+      @page = Page.find_or_create_by_title(page_name)
+      @page = @page.versions.find_by_version(version) unless version.nil? or version == @page.version.to_s
+      render :edit
+    end
+    
+    def post page_name
+      Page.find_or_create_by_title(page_name).update_attributes :body => input.post_body and redirect Show, page_name
+    end
+  end
+
+  class Versions < R '/(\w+)/versions'
+    def get page_name
+      @page = Page.find_or_create_by_title(page_name)
+      @versions = @page.versions
+      render :versions
+    end
+  end
+
+  class List < R '/all/list'
+    def get
+      @pages = Page.find :all, :order => 'title'
+      render :list
+    end
+  end
+
+  class Stylesheet < R '/css/tepee.css'
+    def get
+@headers['Content-Type'] = 'text/css'
+File.read(__FILE__).gsub(/.*__END__/m, '')
+    end
+  end
+end
+
+module Tepee::Views
+  def layout
+    html do
+      head do
+        title 'test'
+        link :href=>R(Stylesheet), :rel=>'stylesheet', :type=>'text/css' 
+      end
+      style <<-END, :type => 'text/css'
+        body {
+          font-family: verdana, arial, sans-serif;
+        }
+        h1, h2, h3, h4, h5 {
+          font-weight: normal;
+        }
+        p.actions a {
+          margin-right: 6px;
+        }
+      END
+      body do
+        p do
+          small do
+            span "welcome to " ; a 'tepee', :href => "http://code.whytheluckystiff.net/svn/camping/trunk/examples/tepee.rb"
+            span '. go ' ;       a 'home',  :href => R(Show, 'home')
+            span '. list all ' ; a 'pages', :href => R(List)
+          end
+        end
+        div.content do
+          self << yield
+        end
+      end
+    end
+  end
+
+  def show
+    h1 @page.title
+    div { _markup @version.body }
+    p.actions do 
+      _button 'edit',      :href => R(Edit, @version.title, @version.version) 
+      _button 'back',      :href => R(Show, @version.title, @version.version-1) unless @version.version == 1 
+      _button 'next',      :href => R(Show, @version.title, @version.version+1) unless @version.version == @page.version 
+      _button 'current',   :href => R(Show, @version.title)                     unless @version.version == @page.version 
+      _button 'versions',  :href => R(Versions, @page.title) 
+    end
+  end
+
+  def edit
+    h1 @page.title 
+    form :method => 'post', :action => R(Edit, @page.title) do
+      p do
+        textarea @page.body, :name => 'post_body', :rows => 50, :cols => 100
+      end
+      input :type => 'submit', :value=>'change' 
+    end
+    _button 'cancel', :href => R(Show, @page.title, @page.version) 
+    a 'syntax', :href => 'http://hobix.com/textile/', :target=>'_blank' 
+  end
+
+  def list
+    h1 'all pages'
+    ul { @pages.each { |p| li { a p.title, :href => R(Show, p.title) } } }
+  end
+
+  def versions
+    h1 @page.title
+    ul do
+      @versions.each do |page|
+        li do
+          span page.version
+          _button 'show',   :href => R(Show, page.title, page.version)
+          _button 'edit',   :href => R(Edit, page.title, page.version)
+        end
+      end
+    end
+  end
+
+  def _button(text, options={})
+    form :method=>:get, :action=>options[:href] do
+      input :type=>'submit', :name=>'submit', :value=>text
+    end
+  end
+
+  def _markup body
+    return '' if body.blank?
+    body.gsub!(Tepee::Models::Page::PAGE_LINK) do
+      page = title = $1
+      title = $2 unless $2.empty?
+      page = page.gsub /\W/, '_'
+      if Tepee::Models::Page.find(:all, :select => 'title').collect { |p| p.title }.include?(page)
+        %Q{<a href="#{self/R(Show, page)}">#{title}</a>}
+      else
+        %Q{<span>#{title}<a href="#{self/R(Edit, page, 1)}">?</a></span>}
+      end
+    end
+    RedCloth.new(body, [ :hard_breaks ]).to_html
+  end
+end
+
+def Tepee.create
+  Tepee::Models.create_schema :assume => (Tepee::Models::Page.table_exists? ? 1.0 : 0.0)
+end
+__END__
+/** focus **/
+/*
+a:hover:active {
+  color: #10bae0;
+}
+
+a:not(:hover):active {
+  color: #0000ff;
+}
+
+*:focus {
+  -moz-outline: 2px solid #10bae0 !important;
+  -moz-outline-offset: 1px !important;
+  -moz-outline-radius: 3px !important;
+}
+
+button:focus,
+input[type="reset"]:focus,
+input[type="button"]:focus,
+input[type="submit"]:focus,
+input[type="file"] > input[type="button"]:focus {
+  -moz-outline-radius: 5px !important;
+}
+
+button:focus::-moz-focus-inner {
+  border-color: transparent !important;
+}
+
+button::-moz-focus-inner,
+input[type="reset"]::-moz-focus-inner,
+input[type="button"]::-moz-focus-inner,
+input[type="submit"]::-moz-focus-inner,
+input[type="file"] > input[type="button"]::-moz-focus-inner {
+  border: 1px dotted transparent !important;
+}
+textarea:focus, button:focus, select:focus, input:focus {
+  -moz-outline-offset: -1px !important;
+}
+input[type="radio"]:focus {
+  -moz-outline-radius: 12px;
+  -moz-outline-offset: 0px !important;
+}
+a:focus {
+  -moz-outline-offset: 0px !important;
+}
+*/
+form { display: inline; }
+
+/** Gradient **/
+small, pre, textarea, textfield, button, input, select {
+   color: #4B4B4C !important;
+   background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAAeCAMAAAAxfD/2AAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAAtUExURfT09PLy8vHx8fv7+/j4+PX19fn5+fr6+vf39/z8/Pb29vPz8/39/f7+/v///0c8Y4oAAAA5SURBVHjaXMZJDgAgCMDAuouA/3+uHPRiMmlKzmhCFRorLOakVnpnDEpBBDHM8ODs/bz372+PAAMAXIQCfD6uIDsAAAAASUVORK5CYII=) !important;
+   background-color: #FFF !important;
+   background-repeat: repeat-x !important;
+   border: 1px solid #CCC !important;
+}
+
+button, input { margin: 3px; }
+

data/vendor/camping-2.0.20090420/lib/camping/ar/session.rb

@@ -0,0 +1,132 @@
+# == 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::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::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
+    def [](k) # :nodoc:
+        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
+        sess = Session.create :ivars => Camping::H[]
+        cookies.camping_sid = sess.hashid
+        sess
+    end
+
+    # 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
+        unless session
+            session = Camping::Models::Session.generate cookies
+        end
+        session
+    end
+
+    # Builds the session table in the database.  To be used in your application's
+    # <tt>create</tt> method.
+    #
+    # Like so:
+    #
+    #   def Blog.create
+    #       Camping::Models::Session.create_schema
+    #       unless Blog::Models::Post.table_exists?
+    #           ActiveRecord::Schema.define(&Blog::Models.schema)
+    #       end
+    #   end
+    #
+    def self.create_schema
+        unless table_exists?
+            ActiveRecord::Schema.define do
+                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::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.
+#
+# == Getting Started
+#
+# To get sessions working for your application:
+#
+# 1. <tt>require 'camping/session'</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. 
+# 
+# If you are unfamiliar with the <tt>create</tt> method, see 
+# http://code.whytheluckystiff.net/camping/wiki/GiveUsTheCreateMethod.
+#
+# == A Few Notes
+#
+# * The session ID is stored in a cookie. Look in <tt>@cookies.camping_sid</tt>.
+# * The session data is stored in the <tt>sessions</tt> table in your database.
+# * 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 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,
+    # it is saved back into the database.
+    def service(*a)
+        session = Camping::Models::Session.persist @cookies
+        app = self.class.name.gsub(/^(\w+)::.+$/, '\1')
+        @state = (session[app] ||= Camping::H[])
+        hash_before = Marshal.dump(@state).hash
+        return super(*a)
+    ensure
+        if session
+            hash_after = Marshal.dump(@state).hash
+            unless hash_before == hash_after
+                session[app] = @state
+                session.save
+            end
+        end
+    end
+end
+end

data/vendor/camping-2.0.20090420/lib/camping/ar.rb

@@ -0,0 +1,78 @@
+class MissingLibrary < Exception #:nodoc: all
+end
+begin
+    require 'active_record'
+rescue LoadError => e
+    raise MissingLibrary, "ActiveRecord could not be loaded (is it installed?): #{e.message}"
+end
+
+$AR_EXTRAS = %{
+  Base = ActiveRecord::Base unless const_defined? :Base
+
+  def Y; ActiveRecord::Base.verify_active_connections!; self; end
+
+  class SchemaInfo < Base
+  end
+
+  def self.V(n)
+    @final = [n, @final.to_i].max
+    m = (@migrations ||= [])
+    Class.new(ActiveRecord::Migration) do
+      meta_def(:version) { n }
+      meta_def(:inherited) { |k| m << k }
+    end
+  end
+
+  def self.create_schema(opts = {})
+    opts[:assume] ||= 0
+    opts[:version] ||= @final
+    if @migrations
+      unless SchemaInfo.table_exists?
+        ActiveRecord::Schema.define do
+          create_table SchemaInfo.table_name do |t|
+            t.column :version, :float
+          end
+        end
+      end
+
+      si = SchemaInfo.find(:first) || SchemaInfo.new(:version => opts[:assume])
+      if si.version < opts[:version]
+        @migrations.each do |k|
+          k.migrate(:up) if si.version < k.version and k.version <= opts[:version]
+          k.migrate(:down) if si.version > k.version and k.version > opts[:version]
+        end
+        si.update_attributes(:version => opts[:version])
+      end
+    end
+  end
+}
+
+module Camping
+  module Models
+    A = ActiveRecord
+    # Base is an alias for ActiveRecord::Base.  The big warning I'm going to give you
+    # about this: *Base overloads table_name_prefix.*  This means that if you have a
+    # model class Blog::Models::Post, it's table name will be <tt>blog_posts</tt>.
+    #
+    # ActiveRecord is not loaded if you never reference this class.  The minute you
+    # use the ActiveRecord or Camping::Models::Base class, then the ActiveRecord library
+    # is loaded.
+    Base = A::Base
+
+    # The default prefix for Camping model classes is the topmost module name lowercase
+    # and followed with an underscore.
+    #
+    #   Tepee::Models::Page.table_name_prefix
+    #     #=> "tepee_pages"
+    #
+    def Base.table_name_prefix
+        "#{name[/\w+/]}_".downcase.sub(/^(#{A}|camping)_/i,'')
+    end
+    module_eval $AR_EXTRAS
+  end
+end
+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-2.0.20090420/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.20090420/lib/camping/reloader.rb

@@ -0,0 +1,184 @@
+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::Server 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'
+  #   reloader = Camping::Reloader.new('/path/to/yourapp.rb')
+  #   blog = reloader.apps[:Blog]
+  #   wiki = reloader.apps[:Wiki]
+  #
+  # The <tt>blog</tt> and <tt>wiki</tt> objects will behave exactly like your
+  # Blog and Wiki, but they will update themselves if yourapp.rb changes.
+  #
+  # You can also give Reloader more than one script.
+  class Reloader
+    attr_reader :scripts
+    
+    # This is a simple wrapper which causes the script to reload (if needed)
+    # on any method call.  Then the method call will be forwarded to the
+    # app.
+    class App # :nodoc:
+      instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+      attr_accessor :app, :script
+      
+      def initialize(script)
+        @script = script
+      end
+      
+      # Reloads if needed, before calling the method on the app.
+      def method_missing(meth, *args, &blk)
+        @script.reload!
+        @app.send(meth, *args, &blk)
+      end
+    end
+    
+    # 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)
+        @file = File.expand_path(file)
+        @dir = File.dirname(@file)
+        @extras = File.join(@dir, File.basename(@file, ".rb"))
+        @mtime = Time.at(0)
+        @requires = []
+        @apps = {}
+      end
+      
+      # Loads the apps availble in this script.  Use <tt>apps</tt> to get
+      # the loaded apps.
+      def load_apps
+        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
+        
+        @requires = ($LOADED_FEATURES - all_requires).map do |req|
+          full = full_path(req)
+          full if full == @file or full.index(@extras) == 0
+        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] = (old = old_apps[key]) || App.new(self)
+          hash[key].app = app
+          app.create if app.respond_to?(:create) && !old
+          hash
+        end
+        self
+      end
+      
+      # Removes all the apps defined in this script.
+      def remove_apps
+        @apps.each do |name, app|
+          Camping::Apps.delete(app.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
+      end
+      
+      private
+      
+      def mtime
+        (@requires + [@file]).compact.map do |fname|
+          File.mtime(fname)
+        end.reject{|t| t > Time.now }.max
+      end
+      
+      # Figures out the full path of a required file. 
+      def full_path(req)
+        dir = File.expand_path($LOAD_PATH.detect { |l| File.exists?(File.join(l, req)) })
+        File.join(dir, req)
+      end
+    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 = []
+      update(*scripts)
+    end
+    
+    # Updates the reloader to only use the scripts provided:
+    #
+    #   reloader.update("examples/blog.rb", "examples/wiki.rb")
+    def update(*scripts)
+      old = @scripts.dup
+      clear
+      @scripts = scripts.map do |script|
+        s = Script.new(script)
+        if pos = old.index(s)
+          # We already got a script, so we use the old (which might got a mtime)
+          old[pos]
+        else
+          s.load_apps
+        end
+      end
+    end
+    
+    # Removes all the scripts from the reloader.
+    def clear
+      @scrips = []
+    end
+    
+    # Simply calls reload! on all the Script objects.
+    def reload!
+      @scripts.each { |script| script.reload! }
+    end
+    
+    # Returns a Hash of all the apps available in the scripts, where the key
+    # would be the name of the app (the one you gave to Camping.goes) and the
+    # value would be the app (wrapped inside App).
+    def apps
+      @scripts.inject({}) do |hash, script|
+        hash.merge(script.apps)
+      end
+    end
+  end
+end