serve 1.5.1 → 1.5.2

data/lib/serve/handlers/file_type_handler.rb

@@ -9,29 +9,49 @@ module Serve #:nodoc:
         FileTypeHandler.handlers[ext] = self
       end
     end
-    
-    def self.find(path)
-      if ext = File.extname(path)
-        handlers[ext.sub(/\A\./, '')]
-      end
+
+    def self.extensions
+      handlers.keys
     end
-    
-    def initialize(root_path, path)
+
+    def self.handlers_for(path)
+      extensions = File.basename(path).split(".")[1..-1]
+      extensions.collect{|e| [handlers[e], e] if handlers[e]}.compact
+    end
+
+    def self.configure(extension, options)
+      extension_options[extension.to_sym].merge!(options)
+    end
+
+    def self.extension_options
+      @extension_options ||= Hash.new{|h,k| h[k] = {}}
+    end
+
+    def self.options_for(extension)
+      extension_options[extension.to_sym]
+    end
+
+    attr_reader :extension
+    def initialize(root_path, template_path, extension)
       @root_path = root_path
-      @script_filename = File.join(@root_path, path)
+      @template_path = template_path
+      @extension = extension
     end
     
-    def process(request, response)
-      response.headers['content-type'] = content_type
-      response.body = parse(open(@script_filename){|io| io.read })
+    def process(input, context)
+      parse(input, context)
     end
     
     def content_type
       'text/html'
     end
+
+    def layout?
+      true
+    end
     
-    def parse(string)
-      string.dup
+    def parse(input, context)
+      input.dup
     end
   end
-end
+end

data/lib/serve/handlers/less_handler.rb

@@ -7,7 +7,7 @@ module Serve #:nodoc:
   class LessHandler < FileTypeHandler #:nodoc:
     extension 'less'
     
-    def parse(string)
+    def parse(string, context)
       require 'less'
       Less.parse(string)
     end

data/lib/serve/handlers/redirect_handler.rb

@@ -2,13 +2,17 @@ module Serve #:nodoc:
   class RedirectHandler < FileTypeHandler  #:nodoc:
     extension 'redirect'
     
-    def process(request, response)
-      lines = super.strip.split("\n")
+    def process(input, context)
+      lines = input.strip.split("\n")
       url = lines.last.strip
-      unless url =~ %r{^\w[\w\d+.-]*:.*}
-        url = request.protocol + request.host_with_port + url
+      unless url =~ %r{^\w[\w+.-]*:.*}
+        url = context.request.protocol + context.request.host_with_port + url
       end
-      response.redirect(url, '302')
+      context.response.redirect(url, '302')
+    end
+
+    def layout?
+      false
     end
   end
 end

data/lib/serve/handlers/sass_handler.rb

@@ -7,20 +7,18 @@ module Serve #:nodoc:
   class SassHandler < FileTypeHandler #:nodoc:
     extension 'sass', 'scss'
     
-    def parse(string)
+    def parse(string, context)
       require 'sass'
       engine = Sass::Engine.new(string,
-        :load_paths => [@root_path],
+        :load_paths => [@root_path] + Sass::Engine::DEFAULT_OPTIONS[:load_paths],
         :style => :expanded,
-        :filename => @script_filename,
-        :syntax => syntax(@script_filename)
+        :syntax => syntax
       )
       engine.render
     end
     
-    def syntax(filename)
-      ext = File.extname(@script_filename)
-      if ext == '.scss'
+    def syntax
+      if extension == 'scss'
         :scss
       else
         :sass
@@ -31,4 +29,4 @@ module Serve #:nodoc:
       'text/css'
     end
   end
-end
+end

data/lib/serve/pipeline.rb

@@ -0,0 +1,119 @@
+require 'serve/view_helpers'
+
+module Serve
+  class Pipeline
+    def self.handles?(path)
+      !FileTypeHandler.handlers_for(path).empty?
+    end
+
+    def self.build(root, path)
+      return nil unless handles?(path)
+      Pipeline.new(root, path, extensions_for(path))
+    end
+    
+    attr_reader :template, :layout
+    def initialize(root_path, path)
+      @root_path = root_path
+      @template = Template.new(File.join(@root_path, path))
+      @layout = find_layout_for(@template.path)
+    end
+
+    def find_layout_for(template_path)
+      return Template::Passthrough.new(@template) unless @template.layout?
+      root = @root_path
+      layout = nil
+      search = File.split(template_path[root.size..-1])
+      until(layout || search.empty?)
+        possible_layouts = FileTypeHandler.extensions.map do |ext|
+          l = "_layout.#{ext}"
+          possible_layout = File.join(File.join(root, *search), l)
+          File.file?(possible_layout) ? possible_layout : false
+        end
+        layout = possible_layouts.detect { |o| o }
+        search.pop
+      end
+      if layout
+        Template.new(layout)
+      else
+        Template::Passthrough.new(@template)
+      end
+    end
+    
+    def process(request, response)
+      response.headers['Content-Type'] = @layout.content_type
+      context = Context.new(@root_path, request, response)
+      @template.process(context)
+      @layout.process(context)
+      response.body = context.content
+    end
+
+    class Template
+      attr_reader :file, :path, :handlers
+      def initialize(file)
+        @file = File.basename(file)
+        @path = File.dirname(file)
+        @raw = File.read(file)
+        @handlers = FileTypeHandler.handlers_for(file).collect{|h, extension| h.new(@root_path, @path, extension)}
+      end
+
+      def content_type
+        @handlers.first.content_type
+      end
+
+      def process(context)
+        context.content = @handlers.reverse.inject(@raw.dup) do |body, handler|
+          handler.process(body, context)
+        end
+      end
+
+      def layout?
+        @handlers.first.layout?
+      end
+
+      def passthrough?
+        false
+      end
+
+      class Passthrough
+        def initialize(template)
+          @template = template
+        end
+
+        def process(context)
+        end
+
+        def layout?
+          false
+        end
+
+        def content_type
+          @template.content_type
+        end
+
+        def passthrough?
+          true
+        end
+      end
+    end
+
+    class Context #:nodoc:
+      attr_accessor :content, :parser
+      attr_reader :request, :response
+      
+      def initialize(root_path, request, response)
+        @root_path, @request, @response = root_path, request, response
+        @content = ''
+        install_view_helpers
+      end
+      
+      def install_view_helpers
+        view_helpers_file_path = @root_path + '/view_helpers.rb'
+        if File.file?(view_helpers_file_path)
+          singleton_class.module_eval(File.read(view_helpers_file_path) + "\ninclude ViewHelpers", view_helpers_file_path)
+        end
+      end
+      
+      include Serve::ViewHelpers
+    end
+  end
+end

data/lib/serve/rack.rb

@@ -61,8 +61,6 @@ module Serve
   # A specialized hash for the environment variables on a request.
   # Borrowed from ActionDispatch in Rails.
   class Headers < Hash
-    extend ActiveSupport::Memoizable
-    
     def initialize(*args)
       if args.size == 1 && args[0].is_a?(Hash)
         super()
@@ -83,9 +81,8 @@ module Serve
     private
       # Converts a HTTP header name to an environment variable name.
       def env_name(header_name)
-        "HTTP_#{header_name.upcase.gsub(/-/, '_')}"
+        @env_name ||= "HTTP_#{header_name.upcase.gsub(/-/, '_')}"
       end
-      memoize :env_name
   end
   
   class RackAdapter
@@ -111,11 +108,9 @@ module Serve
         path = Serve::Router.resolve(@root, request.path_info)
         if path
           # Fetch the file handler for a file with a given extension/
-          ext = File.extname(path)[1..-1]
-          handler = Serve::FileTypeHandler.handlers[ext]
-          if handler
+          if Serve::Pipeline.handles?(path)
             # Handler exists? Process the request and response.
-            handler.new(@root, path).process(request, response)
+            Serve::Pipeline.new(@root, path).process(request, response)
             response
           else
             # Handler doesn't exist? Rewrite the request to use the new path.

data/lib/serve/router.rb

@@ -11,23 +11,23 @@ module Serve
       full_path = File.join(root, path)
       
       case
-      when File.file?(full_path)
+      when File.file?(best_match(full_path))
         # A file exists! Return the matching path.
         path
-      when File.directory?(full_path) 
+      when File.directory?(best_match(full_path))
         # It's a directory? Try a directory index.
         resolve(root, File.join(path, 'index'))
-      when path.ends_with?('.css')
+      when path =~ /\.css\Z/i
         # CSS not found? Try SCSS or Sass.
         alternates = %w{.scss .sass}.map { |ext| path.sub(/\.css\Z/, ext) }
-        sass_path = alternates.find do |p|
-          File.file?(File.join(root, p))
-        end      
+        alternates.find do |p|
+          File.file?(best_match(File.join(root, p)))
+        end
       else
         # Still no luck? Check to see if a file with an extension exists by that name.
         # TODO: Return a path with an extension based on priority, not just the first found.
-        result = Dir.glob(full_path + ".*", File::FNM_CASEFOLD).first
-        result.sub(/^#{root}/, '').sub(/^\//, '') if result && File.file?(result)
+        result = best_match(full_path + ".*")
+        result.sub(/^#{root}/i, '').sub(/^\//, '') if result && File.file?(result)
       end
     end
     
@@ -38,6 +38,10 @@ module Serve
         path = path.sub(%r{/\Z}, '') # remove trailing slash
         path unless path =~ /\.\./   # guard against evil paths
       end
+
+      def self.best_match(path)
+        (Dir.glob(path, File::FNM_CASEFOLD).first || path)
+      end
       
   end
 end

data/lib/serve/templates/default/views/view_helpers.rb

@@ -9,9 +9,9 @@ module ViewHelpers
   def copyright_years(start_year)
     end_year = Date.today.year
     if start_year == end_year
-      "\#{start_year}"
+      "#{start_year}"
     else
-      "\#{start_year}–\#{end_year}"
+      "#{start_year}–#{end_year}"
     end
   end
   

data/lib/serve/view_helpers.rb

@@ -35,8 +35,10 @@ module Serve #:nodoc:
   end
   
   module ContentHelpers
-    def content_for(symbol, &block)
-      set_content_for(symbol, capture(&block))
+    def content_for(symbol, content = nil, &block)
+      content = capture(&block) if block_given?
+      set_content_for(symbol, content) if content
+      get_content_for(symbol) unless content
     end
     
     def content_for?(symbol)
@@ -135,14 +137,14 @@ module Serve #:nodoc:
     end
     
     def render_template(template, options={})
-      path = File.dirname(parser.script_filename)
+      path = parser.template_path
       if template =~ %r{^/}
         template = template[1..-1]
         path = @root_path
       end
-      filename = template_filename(File.join(path, template), :partial => options[:partial])
-      if File.file?(filename)
-        parser.parse_file(filename, options[:locals])
+      filename = template_filename(path, template, :partial => options[:partial])
+      if filename && File.file?(filename)
+        parser.parse(File.read(filename), File.extname(filename).split(".").last, options[:locals])
       else
         raise "File does not exist #{filename.inspect}"
       end
@@ -150,12 +152,12 @@ module Serve #:nodoc:
     
     private
       
-      def template_filename(name, options)
-        path = File.dirname(name)
-        template = File.basename(name)
-        template = "_" + template if options[:partial]
-        template += extname(parser.script_filename) unless name =~ /\.[a-z]+$/
-        File.join(path, template)
+      def template_filename(path, template, options)
+        template_path = File.dirname(template)
+        template_file = File.basename(template)
+        template_file = "_" + template_file if options[:partial]
+        route = Serve::Router.resolve(path, File.join(template_path, template_file))
+        (route && File.join(path, route))
       end
       
       def extname(filename)

data/spec/fixtures/directory/_layout.erb

@@ -0,0 +1,3 @@
+<h1>Awesomesacue</h1>
+
+<%= yield %>

data/spec/fixtures/directory/subdirectory/test.erb

@@ -0,0 +1 @@
+Test

data/spec/fixtures/file.erb

@@ -0,0 +1 @@
+Test

data/spec/pipeline_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'serve/pipeline'
+
+describe Serve::Pipeline do
+  before :each do
+    @root = File.expand_path("../fixtures", __FILE__)
+  end
+  
+  describe "self.handles?" do
+    it "should not handle .html" do
+      Serve::Pipeline.handles?("dir/file.html").should be_false
+    end
+
+    it "should handle .markdown" do
+      Serve::Pipeline.handles?("dir/file.markdown").should be_true
+    end
+
+    it "should handle .html.markdown" do
+      Serve::Pipeline.handles?("dir/file.html.markdown").should be_true
+    end
+
+    it "should handle .coffee" do
+      Serve::Pipeline.handles?("dir/file.coffee").should be_true
+    end
+
+    it "should handle .markdown.erb" do
+      Serve::Pipeline.handles?("dir/file.markdown.erb").should be_true
+    end
+  end
+
+  describe "initialize" do
+    it "should build a pipeline for .markdown" do
+      pipeline = Serve::Pipeline.new(@root, "directory/markdown.markdown")
+      pipeline.template.handlers.collect{|h| h.extension}.should == %w(markdown)
+    end
+
+    it "should build a pipeline for .html.markdown" do
+      pipeline = Serve::Pipeline.new(@root, "directory/markdown.html.markdown")
+      pipeline.template.handlers.collect{|h| h.extension}.should == %w(markdown)
+    end
+
+    it "should build a pipeline for .coffee" do
+      pipeline = Serve::Pipeline.new(@root, "directory/coffee.coffee")
+      pipeline.template.handlers.collect{|h| h.extension}.should == %w(coffee)
+    end
+
+    it "should build a pipeline for .markdown.erb" do
+      pipeline = Serve::Pipeline.new(@root, "directory/markdown_erb.markdown.erb")
+      pipeline.template.handlers.collect{|h| h.extension}.should == %w(markdown erb)
+    end
+  end
+
+  describe "layout search" do
+    it "should return no layout for a file at the root" do
+      pipeline = Serve::Pipeline.new(@root, "file.erb")
+      pipeline.layout.should be_passthrough
+    end
+
+    it "should search up the directory tree for layouts" do
+      root = File.join(@root, "directory")
+      pipeline = Serve::Pipeline.new(root, "subdirectory/test.erb")
+      pipeline.layout.should_not be_passthrough
+      pipeline.layout.path.should == root
+      pipeline.layout.file.should == "_layout.erb"
+    end
+  end
+end