fivepointssolutions-serve 0.9.11

data/lib/serve/rails/controllers/serve_controller.rb

@@ -0,0 +1,43 @@
+class ServeController < ActionController::Base
+  def show
+    response.headers.delete('Cache-Control')
+    cache = Serve::Rails.cache(request)
+    if cache.response_cached?(request.path)
+      cache.update_response(request.path, response, request)
+    else
+      mount = Serve::Rails.configuration.mounts.detect {|m| m.route == params[:serve_route]}
+      if path = mount.resolve_path(params[:path] || '/')
+        handler_class = Serve::FileTypeHandler.find(path)
+        handler = handler_class.new(mount.root_path, path)
+        install_view_helpers(handler, mount.view_helpers) if handler_class == Serve::DynamicHandler
+        handler.process(request, response)
+        cache.cache_response(request.path, response)
+      else
+        render :text => 'not found', :status => 404
+      end
+    end
+    @performed_render = true
+  end
+  
+  private
+    
+    # This is a quick solution: We need to install the view helpers defined by
+    # the Rails application after those of the Serve'd app's view helpers, so
+    # that those of the Rails application override them.
+    #
+    # Ideally, we'll work toward moving some of this Rails stuff further up
+    # into Serve, so that a simple Serve'd directory uses almost all of the
+    # same code, like the Configuration.
+    #
+    def install_view_helpers(handler, view_helpers)
+      controller = self
+      handler.metaclass.module_eval do
+        define_method :install_view_helpers do |context|
+          super(context)
+          # Make available to view helpers
+          context.instance_variable_set('@controller', controller)
+          context.extend view_helpers
+        end
+      end
+    end
+end

data/lib/serve/rails/mount.rb

@@ -0,0 +1,29 @@
+module Serve
+  module Rails
+    class Mount # :nodoc:
+      attr_reader :root_path, :route, :view_helpers
+      
+      def initialize(route, root)
+        @route, @root_path = route, root
+        @view_helpers = Module.new
+      end
+      
+      # Appends to the collection of view helpers that will be made availabe
+      # to the DynamicHandler.
+      #
+      def append_view_helper(m)
+        @view_helpers.module_eval do
+          include m
+        end
+      end
+      
+      def connection
+        @route == '/' ? '*path' : "#{@route}/*path"
+      end
+      
+      def resolve_path(path)
+        Serve.resolve_file(@root_path, path)
+      end
+    end
+  end
+end

data/lib/serve/rails/routing.rb

@@ -0,0 +1,25 @@
+module Serve
+  module Rails
+    module Routing
+      
+      module MapperExtensions
+        def serve
+          serve_mounts = Serve::Rails.configuration.mounts
+          default_site_path = File.join(::Rails.root, 'site')
+          
+          if File.directory?(default_site_path) && !serve_mounts.detect {|m| m.route == '/'}
+            mount('/', default_site_path)
+          end
+          
+          serve_mounts.each do |mount|
+            @set.add_route(mount.connection, {
+              :controller => 'serve', :action => 'show',
+              :serve_route => mount.route
+            })
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/serve/response_cache.rb

@@ -0,0 +1,172 @@
+# This code and it's tests are adapted from the Radiant CMS project.
+#
+# Copyright (c) 2006-2007, John W. Long.
+
+require 'uri'
+
+module Serve
+  class ResponseCache
+    @@defaults = {
+      :expire_time => 5.minutes,
+      :default_extension => '.yml',
+      :perform_caching => true,
+      :use_x_sendfile => false
+    }
+    cattr_accessor :defaults
+
+    attr_accessor :directory, :expire_time, :default_extension, :perform_caching, :logger, :use_x_sendfile
+    alias :page_cache_directory :directory
+    alias :page_cache_extension :default_extension
+    private :page_cache_directory, :page_cache_extension 
+
+    # Creates a ResponseCache object with the specified options.
+    #
+    # Options are as follows:
+    # :directory         :: the path to the temporary cache directory
+    # :expire_time       :: the number of seconds a cached response is considered valid (defaults to 5 min)
+    # :default_extension :: the extension cached files should use (defaults to '.yml')
+    # :perform_caching   :: boolean value that turns caching on or off (defaults to true)
+    # :logger            :: the application logging object
+    # :use_x_sendfile    :: use X-Sendfile headers to speed up transfer of cached pages (not available on all web servers)
+    # 
+    def initialize(options = {})
+      options = options.symbolize_keys.reverse_merge(defaults)
+      self.directory         = options[:directory]
+      self.expire_time       = options[:expire_time]
+      self.default_extension = options[:default_extension]
+      self.perform_caching   = options[:perform_caching]
+      self.logger            = options[:logger]
+      self.use_x_sendfile    = options[:use_x_sendfile]
+    end
+
+    # Caches a response object for path to disk.
+    def cache_response(path, response)
+      if perform_caching
+        path = clean(path)
+        write_response(path, response)
+      end
+      response
+    end
+
+    # If perform_caching is set to true, updates a response object so that it mirrors the
+    # cached version. The request object is required to perform Last-Modified/If-Modified-Since
+    # checks--it is left optional to allow for backwards compatability.
+    def update_response(path, response, request=nil)
+      if perform_caching
+        path = clean(path)
+        read_response(path, response, request)
+      end
+      response
+    end
+
+    # Returns metadata for path.
+    def read_metadata(path)
+      path = clean(path)
+      name = "#{page_cache_path(path)}.yml"
+      if File.exists?(name) and not File.directory?(name)
+        content = File.open(name, "rb") { |f| f.read }
+        metadata = YAML::load(content)
+        metadata if metadata['expires'] >= Time.now
+      end
+    rescue
+      nil
+    end
+
+    # Returns true if a response is cached at the specified path.
+    def response_cached?(path)
+      perform_caching && !!read_metadata(path)
+    end
+  
+    # Expires the cached response for the specified path.
+    def expire_response(path)
+      path = clean(path)
+      expire_page(path)
+    end
+
+    # Expires the entire cache.
+    def clear
+      Dir["#{directory}/*"].each do |f|
+        FileUtils.rm_rf f
+      end
+    end
+
+    private
+      # Ensures that path begins with a slash and remove extra slashes.
+      def clean(path)
+        path = path.gsub(%r{/+}, '/')
+        %r{^/?(.*?)/?$}.match(path)
+        "/#{$1}"
+      end
+
+      # Reads a cached response from disk and updates a response object.
+      def read_response(path, response, request)
+        file_path = page_cache_path(path)
+        if metadata = read_metadata(path)
+          response.headers.merge!(metadata['headers'] || {})
+          if client_has_cache?(metadata, request)
+            response.headers.merge!('Status' => '304 Not Modified')
+          elsif use_x_sendfile
+            response.headers.merge!('X-Sendfile' => "#{file_path}.data")
+          else
+            response.body = File.open("#{file_path}.data", "rb") {|f| f.read}
+          end
+        end
+        response
+      end
+
+      def client_has_cache?(metadata, request)
+          return false unless request
+          request_time = Time.httpdate(request.env["HTTP_IF_MODIFIED_SINCE"]) rescue nil
+          response_time = Time.httpdate(metadata['headers']['Last-Modified']) rescue nil
+          return request_time && response_time && response_time <= request_time
+      end
+
+      # Writes a response to disk.
+      def write_response(path, response)
+        if response.cache_timeout
+          if Time === response.cache_timeout
+            expires = response.cache_timeout
+          else
+            expires = Time.now + response.cache_timeout
+          end
+        else
+          expires = Time.now + self.expire_time
+        end
+        response.headers['Last-Modified'] ||= Time.now.httpdate
+        metadata = {
+          'headers' => response.headers,
+          'expires' => expires
+        }.to_yaml
+        cache_page(metadata, response.body, path)
+      end
+
+      def page_cache_path(path)
+        path = (path.empty? || path == "/") ? "/_site-root" : URI.unescape(path)
+        root_dir = File.expand_path(page_cache_directory)
+        cache_path = File.expand_path(File.join(root_dir, path), root_dir)
+        cache_path if cache_path.index(root_dir) == 0
+      end
+
+      def expire_page(path)
+        return unless perform_caching
+
+        if path = page_cache_path(path)
+          File.delete("#{path}.yml") if File.exists?("#{path}.yml")
+          File.delete("#{path}.data") if File.exists?("#{path}.data")
+        end
+      end
+
+      def cache_page(metadata, content, path)
+        return unless perform_caching
+
+        if path = page_cache_path(path)
+          FileUtils.makedirs(File.dirname(path))
+          #dont want yml without data
+          File.open("#{path}.data", "wb+") { |f| f.write(content) }
+          File.open("#{path}.yml", "wb+") { |f| f.write(metadata) }
+        end
+      end
+  end
+  
+  NULL_CACHE = ResponseCache.new(:perform_caching => false)
+end

data/lib/serve/version.rb

@@ -0,0 +1,13 @@
+module Serve #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 9
+    TINY  = 11
+    
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+  
+  def self.version
+    VERSION::STRING
+  end
+end

data/lib/serve/webrick/extensions.rb

@@ -0,0 +1,98 @@
+# Portions from Rails, Copyright (c) 2004-2008 David Heinemeier Hansson
+require 'active_support/memoizable'
+
+module Serve #:nodoc:
+  module WEBrick #:nodoc:
+    
+    module FileHandlerExtensions #:nodoc:
+      def self.included(base)
+        base.extend(self)
+        base.class_eval do
+          alias :search_file_without_auto_appending :search_file
+          alias :search_file :search_file_with_auto_appending
+        end
+      end
+      
+      def search_file_with_auto_appending(req, res, basename)
+        full_path = File.join(res.filename, basename)
+        return basename if File.file?(full_path)
+        return nil if File.directory?(full_path)
+        Serve.resolve_file(Dir.pwd, req.path)
+      end
+    end
+    
+  end
+end
+
+WEBrick::HTTPRequest.module_eval do
+  extend ActiveSupport::Memoizable
+
+  alias headers header
+
+  # Returns the \host for this request, such as "example.com".
+  def raw_host_with_port
+    @host + ':' + @port.to_s
+  end
+
+  # Returns 'https://' if this is an SSL request and 'http://' otherwise.
+  def protocol
+    ssl? ? 'https://' : 'http://'
+  end
+  memoize :protocol
+
+  # Is this an SSL request?
+  def ssl?
+    meta_vars['HTTPS'] == 'on'
+  end
+
+  def params
+    query.inject({}) {|m, (k,v)| m[k.to_s.to_sym] = v; m}
+  end
+
+  # Returns the host for this request, such as example.com.
+  def host
+    raw_host_with_port.sub(/:\d+$/, '')
+  end
+  memoize :host
+
+  # Returns a \host:\port string for this request, such as "example.com" or
+  # "example.com:8080".
+  def host_with_port
+    "#{host}#{port_string}"
+  end
+  memoize :host_with_port
+
+  # Returns the port number of this request as an integer.
+  def port
+    if raw_host_with_port =~ /:(\d+)$/
+      $1.to_i
+    else
+      standard_port
+    end
+  end
+  memoize :port
+
+  # Returns the standard \port number for this request's protocol.
+  def standard_port
+    case protocol
+      when 'https://' then 443
+      else 80
+    end
+  end
+
+  # Returns a \port suffix like ":8080" if the \port number of this request
+  # is not the default HTTP \port 80 or HTTPS \port 443.
+  def port_string
+    port == standard_port ? '' : ":#{port}"
+  end
+end
+
+WEBrick::HTTPResponse.module_eval do
+  alias headers header
+  
+  def redirect(url, status)
+    set_redirect(::WEBrick::HTTPStatus[status.to_i], url)
+  end
+end
+
+WEBrick::HTTPServlet::FileHandler.class_eval { include Serve::WEBrick::FileHandlerExtensions }

data/lib/serve/webrick/server.rb

@@ -0,0 +1,17 @@
+module Serve #:nodoc:
+  module WEBrick
+    class Server < ::WEBrick::HTTPServer #:nodoc:
+      def self.register_handlers
+        extensions = []
+        Serve::FileTypeHandler.handlers.each do |ext, handler|
+          extensions << ext
+          handler_servlet = Class.new(Serve::WEBrick::Servlet) do
+            define_method(:handler) { handler }
+          end
+          ::WEBrick::HTTPServlet::FileHandler.add_handler(ext, handler_servlet)
+        end
+        extensions
+      end
+    end
+  end
+end

data/lib/serve/webrick/servlet.rb

@@ -0,0 +1,19 @@
+module Serve #:nodoc:
+  module WEBrick
+    class Servlet < ::WEBrick::HTTPServlet::AbstractServlet #:nodoc:
+      def do_GET(req, res)
+        begin
+          path = Serve.resolve_file(Dir.pwd, req.path)
+          handler.new(Dir.pwd, path).process(req, res)
+        rescue StandardError => ex
+          raise
+        rescue Exception => ex
+          @logger.error(ex)
+          raise ::WEBrick::HTTPStatus::InternalServerError, ex.message
+        end
+      end
+      
+      alias do_POST do_GET
+    end
+  end
+end

data/spec/response_cache_spec.rb

@@ -0,0 +1,248 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Serve::ResponseCache do
+  class SilentLogger
+    def method_missing(*args); end
+  end
+  
+  class TestRequest < Struct.new(:body, :env)
+  end
+  
+  class TestResponse < Struct.new(:body, :headers, :cache_timeout)
+    def initialize(body = '', headers = {})
+      self.body = body
+      self.headers = headers
+    end
+  end
+  
+  before :all do
+    @dir = File.expand_path("#{File.expand_path(File.dirname(__FILE__))}/tmp/cache")
+    @baddir = File.expand_path("#{File.expand_path(File.dirname(__FILE__))}/tmp/badcache")
+  end
+  
+  before :each do
+    FileUtils.rm_rf @baddir
+    @cache = Serve::ResponseCache.new(
+      :directory => @dir,
+      :perform_caching => true
+    )
+    @cache.clear
+  end
+  
+  after :each do
+    FileUtils.rm_rf @dir if File.exists? @dir
+  end
+  
+  it 'should initialize with defaults' do
+    @cache = Serve::ResponseCache.new
+    @cache.expire_time.should == 5.minutes
+    @cache.default_extension.should == '.yml'
+  end
+  
+  it 'should initialize with options' do
+    @cache = Serve::ResponseCache.new(
+      :directory         => "test",
+      :expire_time       => 5,
+      :default_extension => ".xhtml",
+      :perform_caching   => false,
+      :logger            => SilentLogger.new
+    )
+    @cache.directory.should == "test"
+    @cache.expire_time.should == 5
+    @cache.default_extension.should == ".xhtml"
+    @cache.perform_caching.should == false
+    @cache.logger.should be_kind_of(SilentLogger)
+  end
+  
+  it 'should cache response' do
+    ['test/me', '/test/me', 'test/me/', '/test/me/', 'test//me'].each do |url|
+      @cache.clear
+      response = response('content', 'Last-Modified' => 'Tue, 27 Feb 2007 06:13:43 GMT')
+      response.cache_timeout = Time.gm(2007, 2, 8, 17, 37, 9)
+      @cache.cache_response(url, response)
+      name = "#{@dir}/test/me.yml"
+      File.exists?(name).should == true
+      file(name).should == "--- \nexpires: 2007-02-08 17:37:09 Z\nheaders: \n  Last-Modified: Tue, 27 Feb 2007 06:13:43 GMT\n" 
+      data_name = "#{@dir}/test/me.data"
+      file(data_name).should == "content" 
+    end
+  end
+  
+  it 'cache response with extension' do
+    @cache.cache_response("styles.css", response('content'))
+    File.exists?("#{@dir}/styles.css.yml").should == true
+  end
+  
+  it 'cache response without caching' do
+    @cache.perform_caching = false
+    @cache.cache_response('test', response('content'))
+    File.exists?("#{@dir}/test.yml").should == false
+  end
+  
+  it 'update response' do
+    @cache.cache_response('/test/me', response('content'))
+    ['test/me', '/test/me', 'test/me/', '/test/me/', 'test//me'].each do |url|
+      @cache.update_response(url, response, TestRequest).body.should == 'content'
+    end
+  end
+
+  it 'update response nonexistant' do
+    @cache.update_response('nothing/here', response, TestRequest).body.should == ''
+  end
+  
+  it 'update response without caching' do
+    @cache.cache_response('/test/me', response('content'))
+    @cache.perform_caching = false
+     @cache.update_response('/test/me', response, TestRequest).body.should == ''
+  end
+  
+  it 'cache' do
+    result = @cache.cache_response('test', response('content', 'Content-Type' => 'text/plain'))
+    cached = @cache.update_response('test', response, TestRequest)
+    cached.body.should == 'content'
+    cached.headers['Content-Type'].should == 'text/plain'
+    result.should be_kind_of(TestResponse)
+  end
+  
+  it 'expire response' do
+    @cache.cache_response('test', response('content'))
+    @cache.expire_response('test')
+    @cache.update_response('test', response, TestRequest).body.should == ''
+  end
+  
+  it 'clear' do
+    @cache.cache_response('test1', response('content'))
+    @cache.cache_response('test2', response('content'))
+    Dir["#{@dir}/*"].size.should == 4
+    
+    @cache.clear
+    Dir["#{@dir}/*"].size.should == 0
+  end
+  
+  it 'response_cached?' do
+    @cache.response_cached?('test').should == false
+    result = @cache.cache_response('test', response('content'))
+    @cache.response_cached?('test').should == true
+  end
+  
+  it 'response_cached? should not answer true when response is cached but preform_caching option is false' do
+    @cache.cache_response('test', response('content'))
+    @cache.perform_caching = false
+    @cache.response_cached?('test').should == false
+  end
+  
+  it 'response_cached? with timeout' do
+    @cache.expire_time = 1
+    result = @cache.cache_response('test', response('content'))
+    sleep 1.5
+    @cache.response_cached?('test').should == false
+  end
+  
+  it 'response_cached? timeout with response setting' do
+    @cache.expire_time = 1
+    response = response('content')
+    response.cache_timeout = 3.seconds
+    result = @cache.cache_response('test', response)
+    sleep 1.5
+    @cache.response_cached?('test').should == true
+    sleep 2
+    @cache.response_cached?('test').should == false
+  end
+  
+  it 'send using x_sendfile header' do
+    @cache.use_x_sendfile = true
+    result = @cache.cache_response('test', response('content', 'Content-Type' => 'text/plain'))
+    cached = @cache.update_response('test', response, TestRequest)
+    cached.body.should == ''
+    cached.headers['X-Sendfile'].should == "#{@dir}/test.data"
+    cached.headers['Content-Type'].should == 'text/plain'
+    result.should be_kind_of(TestResponse) 
+  end
+  
+  it 'send cached page with last modified' do
+    last_modified = Time.now.httpdate
+    result = @cache.cache_response('test', response('content', 'Last-Modified' => last_modified))
+    request = TestRequest.new
+    request.env = { 'HTTP_IF_MODIFIED_SINCE' => last_modified }
+    second_call = @cache.update_response('test', response, request)
+    second_call.headers['Status'].should match(/^304/)
+    second_call.body.should == ''
+    result.should be_kind_of(TestResponse)
+  end
+  
+  it 'send cached page with old last modified' do
+    last_modified = Time.now.httpdate
+    result = @cache.cache_response('test', response('content', 'Last-Modified' => last_modified))
+    request = TestRequest.new
+    request.env = { 'HTTP_IF_MODIFIED_SINCE' => 5.minutes.ago.httpdate }
+    second_call = @cache.update_response('test', response, request)
+    second_call.body.should == 'content'
+    result.should be_kind_of(TestResponse) 
+  end
+  
+  it 'not cached if metadata empty' do
+    FileUtils.makedirs(@dir)
+    File.open("#{@dir}/test_me.yml", 'w') { }
+    @cache.response_cached?('/test_me').should == false
+  end
+
+  it 'not cached if metadata broken' do
+    FileUtils.makedirs(@dir)
+    File.open("#{@dir}/test_me.yml", 'w') {|f| f.puts '::: bad yaml file:::' }
+    @cache.response_cached?('/test_me').should == false
+  end
+  
+  it 'not cached if metadata not hash' do
+    FileUtils.makedirs(@dir)
+    File.open("#{@dir}/test_me.yml", 'w') {|f| f.puts ':symbol' }
+    @cache.response_cached?('/test_me').should == false
+  end
+  
+  it 'not cached if metadata has no expire' do
+    FileUtils.makedirs(@dir)
+    File.open("#{@dir}/test_me.yml", 'w') { |f| f.puts "--- \nheaders: \n  Last-Modified: Tue, 27 Feb 2007 06:13:43 GMT\n" }
+    @cache.response_cached?('/test_me').should == false
+  end  
+  
+  it 'cache cant write outside dir' do
+    @cache.cache_response('../badcache/cache_cant_write_outside_dir', response('content'))
+    File.exist?("#{@baddir}/cache_cant_write_outside_dir.yml").should == false
+  end
+  
+  it 'cache cannot read outside dir' do
+    FileUtils.makedirs(@baddir)
+    @cache.cache_response('/test_me', response('content'))
+    File.rename "#{@dir}/test_me.yml", "#{@baddir}/test_me.yml"
+    File.rename "#{@dir}/test_me.data", "#{@baddir}/test_me.data"
+    @cache.response_cached?('/../badcache/test_me').should == false
+  end
+  
+  it 'cache cannot expire outside dir' do
+    FileUtils.makedirs(@baddir)
+    @cache.cache_response('/test_me', response('content'))
+    File.rename "#{@dir}/test_me.yml", "#{@baddir}/test_me.yml"
+    File.rename "#{@dir}/test_me.data", "#{@baddir}/test_me.data"
+    @cache.expire_response('/../badcache/test_me')
+    File.exist?("#{@baddir}/test_me.yml").should == true
+    File.exist?("#{@baddir}/test_me.data").should == true
+  end  
+
+  it 'should store indexes correctly' do
+    @cache.cache_response('/', response('content')) 
+    @cache.response_cached?('_site-root').should == true
+    @cache.response_cached?('/') .should == true
+    File.exist?("#{@dir}/../cache.yml").should == false
+    File.exist?("#{@dir}/../cache.data").should == false
+  end 
+
+  private
+
+    def file(filename)
+      open(filename) { |f| f.read } rescue ''
+    end
+
+    def response(*args)
+      TestResponse.new(*args)
+    end
+
+end