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

serve 0.9.10 → 0.10.0

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 (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