camping 1.5.180 → 2.0.rc0

data/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/lib/camping/webrick.rb

@@ -1,65 +0,0 @@
-# == About camping/webrick.rb
-#
-# For many who have Ruby installed, Camping and WEBrick is a great option.
-# It's definitely the easiest configuration, however some performance is sacrificed.
-# For better speed, check out Mongrel at http://mongrel.rubyforge.org/, which comes
-# with Camping hooks and is supported by the Camping Tool.
-require 'camping'
-require 'webrick/httpservlet/abstract.rb'
-
-module WEBrick
-# WEBrick::CampingHandler is a very simple handle for hosting Camping apps in
-# a WEBrick server.  It's used much like any other WEBrick handler.
-# 
-# == Mounting a Camping App
-#
-# Assuming Camping.goes(:Blog), the Blog application can be mounted alongside
-# other WEBrick mounts.
-#
-#   s = WEBrick::HTTPServer.new(:BindAddress => host, :Port => port)
-#   s.mount "/blog", WEBrick::CampingHandler, Blog
-#   s.mount_proc("/") { ... }
-#
-# == How Does it Compare?
-#
-# Compared to other handlers, WEBrick is well-equipped in terms of features.
-# 
-# * The <tt>X-Sendfile</tt> header is supported, along with etags and 
-#   modification time headers for the file served.  Since this handler
-#   is a subclass of WEBrick::HTTPServlet::DefaultFileHandler, all of its
-#   logic is used.
-# * IO is streaming up and down.  When you upload a file, it is streamed to
-#   the server's filesystem.  When you download a file, it is streamed to
-#   your browser.
-#
-# While WEBrick is a bit slower than Mongrel and FastCGI options, it's 
-# a decent choice, for sure!
-class CampingHandler < WEBrick::HTTPServlet::DefaultFileHandler
-    # Creates a CampingHandler, which answers for the application within +klass+.
-    def initialize(server, klass)
-        super(server, klass)
-        @klass = klass
-    end
-    # Handler for WEBrick requests (also aliased as do_POST).
-    def service(req, resp)
-        controller = @klass.run((req.body and StringIO.new(req.body)), req.meta_vars)
-        resp.status = controller.status
-        @local_path = nil
-        controller.headers.each do |k, v|
-            if k =~ /^X-SENDFILE$/i
-                @local_path = v
-            else
-                [*v].each do |vi|
-                    resp[k] = vi
-                end
-            end
-        end
-
-        if @local_path
-            do_GET(req, resp)
-        else
-            resp.body = controller.body.to_s
-        end
-    end
-end
-end

data/test/test_xhtml_trans.rb

@@ -1,55 +0,0 @@
-require 'mosquito'
-
-Camping.goes :XhtmlTrans
-
-module XhtmlTrans
-  module Controllers
-    class WithLayout < R '/with_layout'
-      def get
-        render :with_layout
-      end
-    end
-
-    class WithoutLayout < R '/without_layout'
-      def get 
-        render :_without_layout
-      end
-    end
-  end
-
-  module Views
-    def layout
-      xhtml_transitional do
-        head do title "title" end
-        body do capture { yield } end
-      end
-    end
-
-    def with_layout
-      h1 "With layout"
-    end
-
-    def _without_layout
-      xhtml_transitional do
-        head do title "title" end
-        body do h1 "Without layout" end
-      end
-    end
-  end
-end
-
-class XhtmlTransTest < Camping::FunctionalTest
-  def test_with_layout
-    get '/with_layout'
-
-    assert(@response.body =~ /DOCTYPE/, "No doctype defined")
-  end
-
-  def test_without_layout
-    get '/without_layout'
-
-    assert(@response.body =~ /DOCTYPE/, "No doctype defined")
-  end
-
-end
-