fivepointssolutions-serve 0.9.11

data/lib/serve/file_resolver.rb

@@ -0,0 +1,46 @@
+module Serve
+  mattr_accessor :file_resolver
+  
+  class FileResolver
+    cattr_accessor :alternate_extensions
+    self.alternate_extensions = %w(html txt text haml erb rhtml html.erb html.haml textile markdown email redirect)
+    
+    def resolve(root, path)
+      return nil if path.nil?
+      path = File.join(path) # path may be array
+      return nil if path =~ /\.\./
+      path = path.sub(/\/\A/, '')
+      if path =~ /\.css\Z/ && !File.file?(File.join(root, path))
+        sass_path = path.sub(/\.css\Z/, '.sass')
+        sass_path if File.file?(File.join(root, sass_path))
+      elsif File.directory?(File.join(root, path))
+        resolve(root, File.join(path, 'index'))
+      else
+        resolve_with_extension(root, path)
+      end
+    end
+    
+    def resolve_with_extension(root, path)
+      full_path = File.join(root, path)
+      if File.file?(full_path)
+        path
+      else
+        if extension = find_extension(alternate_extensions, full_path)
+          "#{path}.#{extension}"
+        end
+      end
+    end
+    
+    def find_extension(extensions_to_try, full_path)
+      extensions_to_try.find do |ext|
+        File.file?("#{full_path}.#{ext}")
+      end
+    end
+  end
+  
+  self.file_resolver = FileResolver.new
+  
+  def self.resolve_file(root, path)
+    file_resolver.resolve(root, path)
+  end
+end

data/lib/serve/handlers/dynamic_handler.rb

@@ -0,0 +1,210 @@
+module Serve #:nodoc:
+  class DynamicHandler < FileTypeHandler #:nodoc:
+    extension 'erb', 'html.erb', 'rhtml', 'haml', 'html.haml'
+    
+    def process(request, response)
+      response.headers['content-type'] = content_type
+      response.body = parse(request, response)
+    end
+    
+    def parse(request, response)
+      context = Context.new(@root_path, request, response)
+      install_view_helpers(context)
+      parser = Parser.new(context)
+      context.content << parser.parse_file(@script_filename)
+      layout = find_layout_for(@script_filename)
+      if layout
+        parser.parse_file(layout)
+      else
+        context.content
+      end
+    end
+    
+    def find_layout_for(filename)
+      root = @root_path
+      path = filename[root.size..-1]
+      layout = nil
+      until layout or path == "/"
+        path = File.dirname(path)
+        possible_layouts = ['_layout.haml', '_layout.html.haml', '_layout.erb', '_layout.html.erb'].map do |l|
+          possible_layout = File.join(root, path, l)
+          File.file?(possible_layout) ? possible_layout : false
+        end
+        layout = possible_layouts.detect { |o| o }
+      end
+      layout
+    end
+    
+    def install_view_helpers(context)
+      view_helpers_file_path = @root_path + '/view_helpers.rb'
+      if File.file?(view_helpers_file_path)
+        context.metaclass.module_eval(File.read(view_helpers_file_path) + "\ninclude ViewHelpers")
+      end
+    end
+    
+    module ERB #:nodoc:
+      class Engine #:nodoc:
+        def initialize(string, options = {})
+          @erb = ::ERB.new(string, nil, '-', '@erbout')
+          @erb.filename = options[:filename]
+        end
+        
+        def render(context, &block)
+          # we have to keep track of the old erbout variable for nested renders
+          # because ERB#result will set it to an empty string before it renders
+          old_erbout = context.instance_variable_get('@erbout')
+          result = @erb.result(context.instance_eval { binding })
+          context.instance_variable_set('@erbout', old_erbout)
+          result
+        end
+      end
+    end
+    
+    class Parser #:nodoc:
+      attr_accessor :context, :script_filename
+      
+      def initialize(context)
+        @context = context
+        @context.parser = self
+      end
+      
+      def parse_file(filename)
+        old_script_filename = @script_filename
+        @script_filename = filename
+        lines = IO.read(filename)
+        engine = case File.extname(filename).sub(/^./, '').downcase
+          when 'haml'
+            require 'haml'
+            require 'sass'
+            require 'sass/plugin'
+            Haml::Engine.new(lines, :attr_wrapper => '"', :filename => filename)
+          when 'erb'
+            require 'erb'
+            ERB::Engine.new(lines, :filename => filename)
+          else
+            raise 'extension not supported'
+        end
+        result = engine.render(context) do |*args|
+          context.get_content_for(*args)
+        end
+        @script_filename = old_script_filename
+        result
+      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 = ''
+      end
+      
+      def _erbout
+        @erbout
+      end
+      
+      # This is extracted from Rails
+      def capture_erb(&block)
+        buffer = _erbout
+        pos = buffer.length
+        block.call
+        
+        # extract the block 
+        data = buffer[pos..-1]
+        
+        # replace it in the original with empty string
+        buffer[pos..-1] = ''
+        
+        data
+      end
+      
+      # Content_for methods
+      
+      def content_for(symbol, &block)
+        if @haml_buffer
+          set_content_for(symbol, capture_haml(&block))
+        else
+          set_content_for(symbol, capture_erb(&block))
+        end
+      end
+      
+      def content_for?(symbol)
+        !(get_content_for(symbol)).nil?
+      end
+      
+      def get_content_for(symbol = :content)
+        if symbol.to_s.intern == :content
+          @content
+        else
+          instance_variable_get("@content_for_#{symbol}")
+        end
+      end
+      
+      # View helper methods
+      
+      HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;' }
+      def html_escape(s)
+        s.to_s.gsub(/[&"><]/) { |special| HTML_ESCAPE[special] }
+      end
+      alias h html_escape
+      
+      def set_content_for(symbol, value)
+        instance_variable_set("@content_for_#{symbol}", value)
+      end
+      
+      def params
+        request.params
+      end
+      
+      # Render methods
+      
+      def render(options)
+        partial = options.delete(:partial)
+        template = options.delete(:template)
+        case
+        when partial
+          render_partial(partial)
+        when template
+          render_template(template)
+        else
+          raise "render options not supported #{options.inspect}"
+        end
+      end
+      
+      def render_partial(partial)
+        render_template(partial, :partial => true)
+      end
+      
+      def render_template(template, options={})
+        path = File.dirname(parser.script_filename)
+        if template =~ %r{^/}
+          template = template[1..-1]
+          path = @root_path
+        end
+        filename = template_filename(File.join(path, template), :partial => options.delete(:partial))
+        if File.file?(filename)
+          parser.parse_file(filename)
+        else
+          raise "File does not exist #{filename.inspect}"
+        end
+      end
+      
+      private
+      
+        def template_filename(name, options)
+          path = File.dirname(name)
+          template = File.basename(name)
+          template = "_" + template if options.delete(:partial)
+          template += extname(parser.script_filename) unless name =~ /\.[a-z]{3,4}$/
+          File.join(path, template)
+        end
+        
+        def extname(filename)
+          /(\.[a-z]{3,4}\.[a-z]{3,4})$/.match(filename)
+          $1 || File.extname(filename) || ''
+        end
+    end
+  end
+end

data/lib/serve/handlers/email_handler.rb

@@ -0,0 +1,23 @@
+module Serve #:nodoc:
+  class EmailHandler < FileTypeHandler #:nodoc:
+    extension 'email'
+    
+    def parse(string)
+      title = "E-mail"
+      title = $1 + " #{title}" if string =~ /^Subject:\s*(\S.*?)$/im
+      head, body = string.split("\n\n", 2)
+      output = []
+      output << "<html><head><title>#{title}</title></head>"
+      output << '<body style="font-family: Arial; line-height: 1.2em; font-size: 90%; margin: 0; padding: 0">'
+      output << '<div id="head" style="background-color: #E9F2FA; padding: 1em">'
+      head.each do |line|
+        key, value = line.split(":", 2).map { |a| a.strip }
+        output << "<div><strong>#{key}:</strong> #{value}</div>"
+      end
+      output << '</div><pre id="body" style="font-size: 110%; padding: 1em">'
+      output << body
+      output << '</pre></body></html>'
+      output.join("\n")
+    end
+  end
+end

data/lib/serve/handlers/file_type_handler.rb

@@ -0,0 +1,37 @@
+module Serve #:nodoc:
+  class FileTypeHandler #:nodoc:
+    def self.handlers
+      @handlers ||= {}
+    end
+    
+    def self.extension(*extensions)
+      extensions.each do |ext|
+        FileTypeHandler.handlers[ext] = self
+      end
+    end
+    
+    def self.find(path)
+      if ext = File.extname(path)
+        handlers[ext.sub(/\A\./, '')]
+      end
+    end
+    
+    def initialize(root_path, path)
+      @root_path = root_path
+      @script_filename = File.join(@root_path, path)
+    end
+    
+    def process(request, response)
+      response.headers['content-type'] = content_type
+      response.body = parse(open(@script_filename){|io| io.read })
+    end
+    
+    def content_type
+      'text/html'
+    end
+    
+    def parse(string)
+      string.dup
+    end
+  end
+end

data/lib/serve/handlers/markdown_handler.rb

@@ -0,0 +1,10 @@
+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/redirect_handler.rb

@@ -0,0 +1,13 @@
+module Serve #:nodoc:
+  class RedirectHandler < FileTypeHandler  #:nodoc:
+    extension 'redirect'
+    
+    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

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

data/lib/serve/handlers/textile_handler.rb

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

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

data/lib/serve/rails/configuration.rb

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