RubyGems - serve - Versions diffs - 1.0.0 → 1.1.0 - Mend

serve 1.0.0 → 1.1.0

Files changed (36) hide show

data/CHANGELOG.rdoc +11 -0
data/Gemfile +17 -14
data/Gemfile.lock +53 -26
data/LICENSE +1 -1
data/QUICKSTART.rdoc +137 -27
data/README.rdoc +115 -23
data/VERSION +1 -1
data/bin/serve +3 -3
data/lib/serve.rb +2 -5
data/lib/serve/application.rb +7 -6
data/lib/serve/handlers/dynamic_handler.rb +40 -42
data/lib/serve/handlers/less_handler.rb +19 -0
data/lib/serve/handlers/sass_handler.rb +5 -0
data/lib/serve/out.rb +19 -1
data/lib/serve/project.rb +2 -2
data/lib/serve/rack.rb +58 -18
data/lib/serve/router.rb +43 -0
data/lib/serve/templates/config.ru +14 -10
data/lib/serve/view_helpers.rb +36 -24
data/spec/fixtures/directory/index.html +1 -0
data/spec/fixtures/hello.html +1 -0
data/spec/fixtures/stylesheets/application.sass +3 -0
data/spec/router_spec.rb +60 -0
data/spec/spec_helper.rb +0 -1
metadata +50 -39
data/lib/serve/file_resolver.rb +0 -48
data/lib/serve/handlers/markdown_handler.rb +0 -10
data/lib/serve/handlers/static_handler.rb +0 -22
data/lib/serve/handlers/textile_handler.rb +0 -10
data/lib/serve/rails.rb +0 -4
data/lib/serve/rails/configuration.rb +0 -69
data/lib/serve/rails/mount.rb +0 -38
data/lib/serve/rails/routing.rb +0 -25
data/lib/serve/rails/serve_controller.rb +0 -52
data/lib/serve/response_cache.rb +0 -170
data/spec/response_cache_spec.rb +0 -248

data/lib/serve/handlers/markdown_handler.rb DELETED Viewed

@@ -1,10 +0,0 @@
-module Serve #:nodoc:
-  class MarkdownHandler < FileTypeHandler #:nodoc:
-    extension 'markdown'
-    def parse(string)
-      require 'bluecloth'
-      "<html><body>#{ BlueCloth.new(string).to_html }</body></html>"
-    end
-  end
-end

data/lib/serve/handlers/static_handler.rb DELETED Viewed

@@ -1,22 +0,0 @@
-module Serve #:nodoc:
-  class StaticHandler < FileTypeHandler #:nodoc:
-    extension 'txt', 'text', 'xml', 'atom', 'rss', 'rdf', 'htm', 'html'
-    def content_type
-      case File.extname(@script_filename)
-        when '.txt', '.text'
-          'text/plain'
-        when '.xml'
-          'text/xml'
-        when '.atom'
-          'application/atom+xml'
-        when '.rss'
-          'application/rss+xml'
-        when '.rdf'
-          'application/rdf+xml'
-        else
-          'text/html'
-      end
-    end
-  end
-end

data/lib/serve/handlers/textile_handler.rb DELETED Viewed

@@ -1,10 +0,0 @@
-module Serve #:nodoc:
-  class TextileHandler < FileTypeHandler #:nodoc:
-    extension 'textile'
-    def parse(string)
-      require 'redcloth'
-      "<html><body>#{ RedCloth.new(string).to_html }</body></html>"
-    end
-  end
-end

data/lib/serve/rails.rb DELETED Viewed

@@ -1,4 +0,0 @@
-require 'serve/rails/configuration'
-require 'serve/rails/mount'
-require 'serve/rails/serve_controller'
-require 'serve/rails/routing'

data/lib/serve/rails/configuration.rb DELETED Viewed

@@ -1,69 +0,0 @@
-module Serve # :nodoc:
-  module Rails
-    class Configuration # :nodoc:
-      attr_reader :mounts, :view_helpers
-      def initialize
-        Serve::ResponseCache.defaults.update(
-          :logger => ActionController::Base.logger,
-          :perform_caching => ActionController::Base.perform_caching
-        )
-        @mounts = []
-        define_find_cache do |request|
-          @default_cache ||= Serve::ResponseCache.new(
-            :directory => File.join(::Rails.root, 'tmp', 'serve_cache')
-          )
-        end
-      end
-      def define_find_cache(&block)
-        singleton_class.module_eval do
-          define_method :find_cache, &block
-        end
-      end
-      def mount(route, root_path)
-        m = Mount.new(route, root_path)
-        @mounts << m
-        yield m if block_given?
-        m
-      end
-    end
-    # Answer the cache for the given request. Delegates to the 'find_cache'
-    # block, which defaults to a single cache.
-    #
-    def self.cache(request)
-      configuration.find_cache(request)
-    end
-    def self.configuration
-      @configuration ||= Configuration.new
-    end
-    # The most powerful way to configure Serve::Rails, the configuration is
-    # yielded to the provided block. Multiple calls are cumulative - there is
-    # only one configuration instance.
-    #
-    def self.configure
-      yield configuration
-    end
-    # Define the strategy for resolving the cache for a request. This allows
-    # applications to provide logic like cache-per-browser. The default is a
-    # single cache.
-    #
-    def self.find_cache(&block)
-      configuration.define_find_cache(&block)
-    end
-    # Mount a route on a directory. This allows an application to have
-    # multiple served directories, each connected to different routes.
-    #
-    def self.mount(route, root_path, &block)
-      configuration.mount(route, root_path, &block)
-    end
-  end
-end

data/lib/serve/rails/mount.rb DELETED Viewed

@@ -1,38 +0,0 @@
-module Serve
-  module Rails
-    class Mount # :nodoc:
-      attr_reader :root_path, :route
-      def initialize(route, root)
-        @route, @root_path = route, root
-        @view_helper_module_names = []
-      end
-      # Appends to the collection of view helpers that will be made availabe
-      # to the DynamicHandler. These should be module names. They will be
-      # constantized in order to allow for re-loading in development mode.
-      #
-      def append_view_helper(module_name)
-        @view_helper_module_names << module_name
-      end
-      def connection
-        @route == '/' ? '*path' : "#{@route}/*path"
-      end
-      def resolve_path(path)
-        Serve.resolve_file(@root_path, path)
-      end
-      def view_helpers
-        helpers = Module.new
-        @view_helper_module_names.each do |module_name|
-          helpers.module_eval do
-            include module_name.constantize
-          end
-        end
-        helpers
-      end
-    end
-  end
-end

data/lib/serve/rails/routing.rb DELETED Viewed

@@ -1,25 +0,0 @@
-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/rails/serve_controller.rb DELETED Viewed

@@ -1,52 +0,0 @@
-module Serve
-  module Rails
-    module ServeController
-      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_not_found
-          end
-        end
-        @performed_render = true
-      end
-      private
-        def render_not_found
-          render :text => 'not found', :status => 404
-        end
-        # 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.singleton_class.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
-  end
-end

data/lib/serve/response_cache.rb DELETED Viewed

@@ -1,170 +0,0 @@
-# This code and it's tests are adapted from the Radiant CMS project.
-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/spec/response_cache_spec.rb DELETED Viewed

@@ -1,248 +0,0 @@
-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 match("expires: 2007-02-08 17:37:09 Z")
-      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