RubyGems - camping - Versions diffs - 1.5.180 → 2.0.rc0 - Mend

camping 1.5.180 → 2.0.rc0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (64) hide show

data/CHANGELOG +35 -0
data/README +43 -68
data/Rakefile +155 -86
data/bin/camping +64 -246
data/book/01_introduction +19 -0
data/book/02_getting_started +443 -0
data/book/51_upgrading +93 -0
data/doc/api.html +1953 -0
data/doc/book.html +73 -0
data/doc/book/01_introduction.html +57 -0
data/doc/book/02_getting_started.html +573 -0
data/doc/book/51_upgrading.html +146 -0
data/doc/created.rid +1 -0
data/{extras → doc/images}/Camping.gif +0 -0
data/doc/images/loadingAnimation.gif +0 -0
data/{extras → doc/images}/permalink.gif +0 -0
data/doc/index.html +148 -0
data/doc/js/camping.js +79 -0
data/doc/js/jquery.js +32 -0
data/doc/rdoc.css +117 -0
data/examples/blog.rb +280 -181
data/extras/images/badge.gif +0 -0
data/extras/images/boys-life.png +0 -0
data/extras/images/deerputer.png +0 -0
data/extras/images/diagram.png +0 -0
data/extras/images/hill.png +0 -0
data/extras/images/i-wish.png +0 -0
data/extras/images/latl.png +0 -0
data/extras/images/little-wheels.png +0 -0
data/extras/images/square-badge.png +0 -0
data/extras/images/uniform.png +0 -0
data/extras/images/whale-bounce.png +0 -0
data/extras/rdoc/generator/singledarkfish.rb +205 -0
data/extras/rdoc/generator/template/flipbook/images/Camping.gif +0 -0
data/extras/rdoc/generator/template/flipbook/images/loadingAnimation.gif +0 -0
data/extras/rdoc/generator/template/flipbook/images/permalink.gif +0 -0
data/extras/rdoc/generator/template/flipbook/js/camping.js +79 -0
data/extras/rdoc/generator/template/flipbook/js/jquery.js +32 -0
data/extras/rdoc/generator/template/flipbook/page.rhtml +30 -0
data/extras/rdoc/generator/template/flipbook/rdoc.css +117 -0
data/extras/rdoc/generator/template/flipbook/readme.rhtml +31 -0
data/extras/rdoc/generator/template/flipbook/reference.rhtml +71 -0
data/extras/rdoc/generator/template/flipbook/toc.rhtml +43 -0
data/lib/camping-unabridged.rb +420 -481
data/lib/camping.rb +40 -55
data/lib/camping/{db.rb → ar.rb} +5 -8
data/lib/camping/mab.rb +26 -0
data/lib/camping/reloader.rb +175 -147
data/lib/camping/server.rb +178 -0
data/lib/camping/session.rb +34 -121
data/test/apps/env_debug.rb +65 -0
data/test/apps/forms.rb +95 -0
data/test/apps/forward_to_other_controller.rb +60 -0
data/test/apps/migrations.rb +97 -0
data/test/apps/misc.rb +86 -0
data/test/apps/sessions.rb +38 -0
metadata +120 -80
data/doc/camping.1.gz +0 -0
data/examples/campsh.rb +0 -630
data/examples/tepee.rb +0 -242
data/extras/flipbook_rdoc.rb +0 -491
data/lib/camping/fastcgi.rb +0 -244
data/lib/camping/webrick.rb +0 -65
data/test/test_xhtml_trans.rb +0 -55

data/lib/camping/server.rb ADDED Viewed

@@ -0,0 +1,178 @@
+require 'irb'
+require 'rack'
+require 'camping/reloader'
+# == The Camping Server (for development)
+#
+# Camping includes a pretty nifty server which is built for development.
+# It follows these rules:
+#
+# * Load all Camping apps in a directory or a file.
+# * Load new apps that appear in that directory or that file.
+# * Mount those apps according to their name. (e.g. Blog is mounted at /blog.)
+# * Run each app's <tt>create</tt> method upon startup.
+# * Reload the app if its modification time changes.
+# * Reload the app if it requires any files under the same directory and one
+#   of their modification times changes.
+# * Support the X-Sendfile header.
+#
+# Run it like this:
+#
+#   camping examples/        # Mounts all apps in that directory
+#   camping blog.rb          # Mounts Blog at /
+#
+# And visit http://localhost:3301/ in your browser.
+class Camping::Server
+  attr_reader :reloader
+  attr_accessor :conf
+  def initialize(conf, paths)
+    @conf = conf
+    @paths = paths
+    @reloader = Camping::Reloader.new
+    connect(@conf.database) if @conf.database
+  end
+  def connect(db)
+    unless Camping.autoload?(:Models)
+      Camping::Models::Base.establish_connection(db)
+    end
+  end
+  def find_scripts
+    scripts = @paths.map do |path|
+      case
+      when File.file?(path)
+        path
+      when File.directory?(path)
+        Dir[File.join(path, '*.rb')]
+      end
+    end.flatten.compact
+    @reloader.update(*scripts)
+  end
+  def index_page(apps)
+    welcome = "You are Camping"
+    header = <<-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>
+    HTML
+    footer = '</body></html>'
+    main = if apps.empty?
+      "<p>Good day.  I'm sorry, but I could not find any Camping apps. "\
+      "You might want to take a look at the console to see if any errors "\
+      "have been raised.</p>"
+    else
+      "<p>Good day.  These are the Camping apps you've mounted.</p><ul>" +
+      apps.map do |mount, app|
+        "<li><h3 style=\"display: inline\"><a href=\"/#{mount}\">#{app}</a></h3><small> / <a href=\"/code/#{mount}\">View source</a></small></li>"
+      end.join("\n") + '</ul>'
+    end
+    header + main + footer
+  end
+  def app
+    reload!
+    all_apps = apps
+    rapp = case all_apps.length
+    when 0
+      proc{|env|[200,{'Content-Type'=>'text/html'},index_page([])]}
+    when 1
+      apps.values.first
+    else
+      hash = {
+        "/" => proc {|env|[200,{'Content-Type'=>'text/html'},index_page(all_apps)]}
+      }
+      all_apps.each do |mount, wrapp|
+        # We're doing @reloader.reload! ourself, so we don't need the wrapper.
+        app = wrapp.app
+        hash["/#{mount}"] = app
+        hash["/code/#{mount}"] = proc do |env|
+          [200,{'Content-Type'=>'text/plain','X-Sendfile'=>wrapp.script.file},'']
+        end
+      end
+      Rack::URLMap.new(hash)
+    end
+    rapp = Rack::ContentLength.new(rapp)
+    rapp = Rack::Lint.new(rapp)
+    rapp = XSendfile.new(rapp)
+    rapp = Rack::ShowExceptions.new(rapp)
+  end
+  def apps
+    @reloader.apps.inject({}) do |h, (mount, wrapp)|
+      h[mount.to_s.downcase] = wrapp
+      h
+    end
+  end
+  def call(env)
+    app.call(env)
+  end
+  def start
+    handler, conf = case @conf.server
+    when "console"
+      puts "** Starting console"
+      reload!
+      this = self; eval("self", TOPLEVEL_BINDING).meta_def(:reload!) { this.reload!; nil }
+      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"
+      puts "** Starting WEBrick on #{@conf.host}:#{@conf.port}"
+      [Rack::Handler::WEBrick, {:Port => @conf.port, :BindAddress => @conf.host}]
+    end
+    reload!
+    handler.run(self, conf)
+  end
+  def reload!
+    find_scripts
+    @reloader.reload!
+  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)
+      headers = Rack::Utils::HeaderHash.new(headers)
+      if header = HEADERS.detect { |header| headers.include?(header) }
+        path = headers[header]
+        body = File.read(path)
+        headers['Content-Length'] = body.length.to_s
+      end
+      [status, headers, body]
+    end
+  end
+end

data/lib/camping/session.rb CHANGED Viewed

@@ -1,123 +1,36 @@
-# == 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'
-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
-    def []=(k, v) # :nodoc:
-        self.ivars[k] = v
-    end
-    def [](k) # :nodoc:
-        self.ivars[k] rescue nil
-    end
-    RAND_CHARS = [*'A'..'Z'] + [*'0'..'9'] + [*'a'..'z']
-    # 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[]
-        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
-        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 do |t|
-                    t.column :id,          :integer, :null => false
-                    t.column :hashid,      :string,  :limit => 32
-                    t.column :created_at,  :datetime
-                    t.column :ivars,       :text
-                end
-            end
-            reset_column_information
-        end
-    end
-end
-end
 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. 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 Session
-    # 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
-        s = super(*a)
-        if session
-            hash_after = Marshal.dump(@state).hash
-            unless hash_before == hash_after
-                session[app] = @state
-                session.save
-            end
-        end
-        s
+  # == Getting Started
+  #
+  # To get sessions working for your application:
+  # 1. <tt>require 'camping/session'</tt>
+  # 2. Mixin the module: <tt>include Camping::Session</tt>
+  # 3. Define a secret (and keep it secret): <tt>secret "SECRET!"</tt>
+  # 4. Throughout your application, use the <tt>@state</tt> var like a hash
+  #    to store your application's data.
+  #
+  #   require 'camping/session'    # 1
+  #
+  #   module Nuts
+  #     include Camping::Session   # 2
+  #     secret "Oh yeah!"          # 3
+  #   end
+  #
+  # == Other backends
+  #
+  # Camping only ships with session-cookies. However, the <tt>@state</tt>
+  # variable is simply a shortcut for <tt>@env['rack.session']</tt>. Therefore
+  # you can also use any middleware which sets this variable:
+  #
+  #   module Nuts
+  #     use Rack::Session::Memcache
+  #   end
+  module Session
+    def self.included(app)
+      key    = "#{app}.state".downcase
+      secret = [__FILE__, File.mtime(__FILE__)].join(":")
+      app.meta_def(:secret) { |val| secret.replace(val) }
+      app.use Rack::Session::Cookie, :key => key, :secret => secret
     end
-end
-end
+  end
+end

data/test/apps/env_debug.rb ADDED Viewed

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+begin require "rubygems" rescue LoadError end
+require "camping"
+Camping.goes :EnvDebug
+module EnvDebug
+  module Controllers
+    class ShowEnv < R '/', '/(.*)'
+      def get(extra = nil)
+        @extra = extra
+        render :show_env
+      end
+      alias post get
+    end
+  end
+  module Views
+    def layout
+      html do
+        head{ title C }
+        body do
+          ul do
+            li{ a "show env", :href=>R(ShowEnv)}
+          end
+          p { yield }
+        end
+      end
+    end
+    def _print_hash(hash)
+      hash.keys.sort.each do |key|
+        value = hash[key]
+        pre "%30s: %s" % [key.inspect, value.inspect]
+      end
+    end
+    def show_env
+      b "extra: #{@extra.inspect}"
+      h2 "@status : #{@status.inspect}"
+      h2 "@method : #{@method.inspect}"
+      h2 "@root : #{@root.inspect}"
+      h2 "@env :"
+      _print_hash @env
+      h2 "@input : "
+      _print_hash @input
+      h2 "@headers :"
+      _print_hash @headers
+   end
+  end
+end
+# For CGI
+if $0 == __FILE__
+  EnvDebug.create if EnvDebug.respond_to? :create
+  if ARGV.any?
+    require 'camping/fastcgi'
+    #Dir.chdir('/var/camping/blog/')
+    Camping::FastCGI.start(EnvDebug)
+  else
+    puts EnvDebug.run
+  end
+end

data/test/apps/forms.rb ADDED Viewed

@@ -0,0 +1,95 @@
+require "camping"
+Camping.goes :Forms
+module Forms
+  module Controllers
+    class Index < R '/'
+      def get; render :index end
+    end
+    class GetForm
+      def get; render :get_form; end
+    end
+    class GetFormResult
+      def get; render :form_result; end
+    end
+    class PostForm
+      def get; render :post_form; end
+      def post; render :form_result; end
+    end
+    class FileForm
+      def get; render :file_form; end
+      def post; render :form_result; end
+    end
+  end
+  module Views
+    def layout
+      html do
+        head{ title C }
+        body do
+          ul do
+            li{ a "index", :href=>R(Index)}
+            li{ a "get form", :href=>R(GetForm)}
+            li{ a "post form", :href=>R(PostForm)}
+            li{ a "file form", :href=>R(FileForm)}
+          end
+          p { yield }
+        end
+      end
+    end
+    def form_result
+      p @input.inspect
+    end
+    def index
+      h1 "Welcome on the Camping test app"
+    end
+    def get_form
+      form :action=>R(GetFormResult), :method=>:get do
+        label "Give me your name!", :for=>:name
+        input :type=>:text, :name=>:name; br
+        input :type=>:text, :name=>"arr[]"; br
+        input :type=>:text, :name=>"arr[]"; br
+        input :type=>:text, :name=>"hash[x]"; br
+        input :type=>:text, :name=>"hash[y]"; br
+        input :type=>:submit
+      end
+    end
+    def post_form
+      form :action=>R(PostForm), :method=>:post do
+        label "Give me your name!", :for=>:name
+        input :type=>:text, :name=>:name; br
+        input :type=>:text, :name=>"arr[]"; br
+        input :type=>:text, :name=>"arr[]"; br
+        input :type=>:text, :name=>"hash[x]"; br
+        input :type=>:text, :name=>"hash[y]"; br
+        input :type=>:submit
+      end
+    end
+    def file_form
+      form :action=>R(FileForm), :method=>:post, :enctype=>"multipart/form-data" do
+        input :type=>:text, :name=>"arr"
+        input :type=>:text, :name=>"arr"; br
+        input :type=>:file, :name=>"first_file"; br
+        input :type=>:file, :name=>"files[]"; br
+        input :type=>:file, :name=>"files[]"; br
+        input :type=>:submit
+      end
+    end
+  end
+end
+# For CGI
+if $0 == __FILE__
+  Forms.create
+  Forms.run
+end