RubyGems - serve - Versions diffs - 0.9.10 → 0.10.0 - Mend

serve 0.9.10 → 0.10.0

Files changed (57) hide show

data/{History.txt → CHANGELOG.rdoc} +9 -0
data/{License.txt → LICENSE} +1 -1
data/{Quickstart.textile → QUICKSTART.rdoc} +61 -80
data/{README.txt → README.rdoc} +10 -13
data/Rakefile +11 -13
data/VERSION +1 -0
data/bin/serve +6 -0
data/lib/serve.rb +2 -8
data/lib/serve/application.rb +13 -6
data/lib/serve/file_resolver.rb +48 -0
data/lib/serve/handlers/dynamic_handler.rb +31 -21
data/lib/serve/handlers/file_type_handler.rb +23 -32
data/lib/serve/handlers/markdown_handler.rb +1 -1
data/lib/serve/handlers/redirect_handler.rb +6 -5
data/lib/serve/handlers/sass_handler.rb +4 -3
data/lib/serve/rack.rb +57 -0
data/lib/serve/rails.rb +4 -0
data/lib/serve/rails/configuration.rb +69 -0
data/lib/serve/rails/mount.rb +38 -0
data/lib/serve/rails/routing.rb +25 -0
data/lib/serve/rails/serve_controller.rb +52 -0
data/lib/serve/response_cache.rb +170 -0
data/lib/serve/version.rb +4 -9
data/lib/serve/webrick/extensions.rb +80 -15
data/lib/serve/webrick/server.rb +17 -0
data/lib/serve/webrick/servlet.rb +19 -0
data/rails/init.rb +6 -0
data/spec/{serve_application_spec.rb → application_spec.rb} +5 -4
data/spec/response_cache_spec.rb +248 -0
data/spec/serve_spec.rb +1 -0
data/spec/spec_helper.rb +10 -9
metadata +51 -69
data.tar.gz.sig +0 -0
data/Manifest.txt +0 -44
data/config/hoe.rb +0 -70
data/config/requirements.rb +0 -17
data/log/debug.log +0 -0
data/script/destroy +0 -14
data/script/generate +0 -14
data/script/txt2html +0 -74
data/setup.rb +0 -1585
data/tasks/deployment.rake +0 -27
data/tasks/environment.rake +0 -7
data/tasks/rspec.rake +0 -21
data/tasks/undefine.rake +0 -5
data/tasks/website.rake +0 -17
data/test_project/_layout.haml +0 -12
data/test_project/erb/_footer.html.erb +0 -2
data/test_project/erb/_layout.html.erb +0 -28
data/test_project/erb/index.html.erb +0 -10
data/test_project/haml/_footer.haml +0 -2
data/test_project/haml/_layout.haml +0 -20
data/test_project/haml/index.haml +0 -9
data/test_project/test.haml +0 -3
data/test_project/test.html.erb +0 -3
data/test_project/view_helpers.rb +0 -5
metadata.gz.sig +0 -0

data/lib/serve/handlers/file_type_handler.rb CHANGED

@@ -1,46 +1,37 @@
 module Serve #:nodoc:
-  class FileTypeHandler < ::WEBrick::HTTPServlet::AbstractServlet #:nodoc:
+  class FileTypeHandler #:nodoc:
+    def self.handlers
+      @handlers ||= {}
+    end
     def self.extension(*extensions)
-      extensions.each do |extensions|
-        ::WEBrick::HTTPServlet::FileHandler.add_handler(extensions, self)
+      extensions.each do |ext|
+        FileTypeHandler.handlers[ext] = self
       end
     end
-    def initialize(server, name)
-      super
-      @script_filename = name
+    def self.find(path)
+      if ext = File.extname(path)
+        handlers[ext.sub(/\A\./, '')]
+      end
     end
-    def process(req, res)
-      data = open(@script_filename){|io| io.read }
-      res['content-type'] = content_type
-      res.body = parse(data)
+    def initialize(root_path, path)
+      @root_path = root_path
+      @script_filename = File.join(@root_path, path)
     end
-    def do_GET(req, res)
-      begin
-        process(req, res)
-      rescue StandardError => ex
-        raise
-      rescue Exception => ex
-        @logger.error(ex)
-        raise ::WEBrick::HTTPStatus::InternalServerError, ex.message
-      end
+    def process(request, response)
+      response.headers['content-type'] = content_type
+      response.body = parse(open(@script_filename){|io| io.read })
     end
-    alias do_POST do_GET
-    protected
-      def content_type
-        'text/html'
-      end
-      def parse(string)
-        string.dup
-      end
+    def content_type
+      'text/html'
+    end
+    def parse(string)
+      string.dup
+    end
   end
 end

data/lib/serve/handlers/markdown_handler.rb CHANGED

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

data/lib/serve/handlers/redirect_handler.rb CHANGED

@@ -2,11 +2,12 @@ module Serve #:nodoc:
   class RedirectHandler < FileTypeHandler  #:nodoc:
     extension 'redirect'
-    def process(req, res)
-      data = super
-      res['location'] = data.strip
-      res.body = ''
-      raise ::WEBrick::HTTPStatus::Found
+    def process(request, response)
+      url = super.strip
+      unless url =~ %r{^\w[\w\d+.-]*:.*}
+        url = request.protocol + request.host_with_port + url
+      end
+      response.redirect(url, '302')
     end
   end
 end

data/lib/serve/handlers/sass_handler.rb CHANGED

@@ -1,16 +1,17 @@
 module Serve #:nodoc:
   class SassHandler < FileTypeHandler #:nodoc:
     extension 'sass'
     def parse(string)
       require 'sass'
       engine = Sass::Engine.new(string,
+        :load_paths => [@root_path],
         :style => :expanded,
         :filename => @script_filename
       )
-      engine.render
+      engine.render
     end
     def content_type
       'text/css'
     end

data/lib/serve/rack.rb ADDED

@@ -0,0 +1,57 @@
+require 'active_support'
+require 'serve'
+require 'rack'
+module Serve
+  class Rack
+    def call(env)
+      path = Serve.resolve_file(Dir.pwd, env["PATH_INFO"])
+      return not_found unless path
+      ext = File.extname(path)[1..-1]
+      handler = Serve::FileTypeHandler.handlers[ext]
+      return no_handler(ext) unless handler
+      res = Response.new
+      handler.new(Dir.pwd, path).process(nil, res)
+      [200, res.headers, res.body]
+    rescue Exception => e
+      return html_response(500, %(
+<h1>Error!</h1>
+<h2>#{h(e.message)}</h2>
+<pre>
+#{h(e.backtrace.join("\n"))}
+</pre>))
+    end
+    def no_handler(ext)
+      html_response(501, %(
+<h1>No handler</h1>
+<p>Don't know how to handle resources of type "#{h(ext)}".</p>))
+    end
+    def not_found
+      html_response(404, %(
+<h1>Not Found</h1>
+<p>The requested resource was not found.</p>))
+    end
+    def html_response(code, body)
+      [code, {"Content-Type" => "text/html"}, %(<html><head></head><body>#{body}</body></html>)]
+    end
+    def h(input)
+      CGI.escapeHTML(input)
+    end
+    class Response
+      attr_reader :headers
+      attr_accessor :body
+      def initialize
+        @headers = {}
+      end
+    end
+  end
+end

data/lib/serve/rails.rb ADDED

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

data/lib/serve/rails/configuration.rb ADDED

@@ -0,0 +1,69 @@
+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)
+        metaclass.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 ADDED

@@ -0,0 +1,38 @@
+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 ADDED

@@ -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/rails/serve_controller.rb ADDED

@@ -0,0 +1,52 @@
+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.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
+  end
+end

data/lib/serve/response_cache.rb ADDED

@@ -0,0 +1,170 @@
+# 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