serve 0.9.6 → 0.9.7

data/Manifest.txt

@@ -1,15 +1,17 @@
 History.txt
 License.txt
 Manifest.txt
+Quickstart.textile
 README.txt
 Rakefile
 bin/serve
 config/hoe.rb
 config/requirements.rb
 lib/serve.rb
+lib/serve/application.rb
+lib/serve/handlers/dynamic_handler.rb
 lib/serve/handlers/email_handler.rb
 lib/serve/handlers/file_type_handler.rb
-lib/serve/handlers/haml_handler.rb
 lib/serve/handlers/markdown_handler.rb
 lib/serve/handlers/redirect_handler.rb
 lib/serve/handlers/sass_handler.rb
@@ -21,6 +23,7 @@ script/destroy
 script/generate
 script/txt2html
 setup.rb
+spec/serve_application_spec.rb
 spec/serve_spec.rb
 spec/spec.opts
 spec/spec_helper.rb

data/Quickstart.textile

@@ -0,0 +1,148 @@
+h1. Getting Started with Serve
+
+
+Serve is a rapid prototyping framework for Rails applications. It is designed to compliment Rails development and enforce a strict separation of concerns between designer and developer. Using Serve with Rails allows the designer to happily work in his own space creating an HTML prototype of the application, while the developer works on the Rails application and copies over HTML from the prototype as needed. This allows the designer to focus on presentation and flow while the developer can focus on the implementation.
+
+Let's have a look at how it all works.
+
+
+h3. Installation
+
+To get started we need to download and install the Ruby gem for Serve:
+
+<pre>
+% sudo gem install serve
+</pre>
+
+After we've done that it's probably a good idea to install a couple of additional gems so that Serve will play nicely with HAML, Markdown, and Textile:
+
+<pre>
+% sudo gem install haml Bluecloth Redcloth
+</pre>
+
+
+h3. Project Directory Structure
+
+Once we have everything installed the next thing to do is setup the project directory. I like to setup my projects with the following directory structure:
+
+<pre>
+artwork      # Logos and other identity design files go here
+mockups      # Fireworks or Photoshop web app mockups go here
+prototype    # The HTML prototype for the web app goes here
+application  # The actual Rails application is here
+</pre>
+
+Let's go ahead and create the directory for the prototype:
+
+  % mkdir prototype
+
+Rails apps generally store images, javascripts, and stylesheets in the top level directories by the same name. Let's go ahead and mirror those directories for our prototype:
+
+<pre>
+% cd prototype
+% mkdir images
+% mkdir javascripts
+% mkdir stylesheets
+</pre>
+
+
+h3. Creating Our First Screen
+
+Now that we have the prototype directory set up, let's create our first page so that you can get a feel for how Serve works. This will be a simple HTML login page for our application.
+
+Insert the following HTML into an file named "login.html":
+
+<pre><code>
+<form action="/dashboard/" method="put">
+  <p>
+    <label for="username">Username</label>
+    <input type="text" name="username" id="username" />
+  </p>
+  <p>
+    <label for="password">Password</label>
+    <input type="password" name="password" id="password" />
+  </p>
+  <p>
+    <input type="submit" value="Login" />
+  </p>
+</form>
+</code></pre>
+
+
+h3. Starting Serve
+
+To view our login page in a Web browser, we need to start up Serve in the directory where we are building the prototype:
+
+<pre>
+% cd prototype
+% serve
+[2008-02-23 15:19:05] INFO  WEBrick 1.3.1
+[2008-02-23 15:19:05] INFO  ruby 1.8.6 (2007-09-24) [universal-darwin9.0]
+[2008-02-23 15:19:05] INFO  Serve::Server#start: pid=5087 port=4000
+...
+</pre>
+
+Once you execute the `serve` command it will launch a mini Web server for the prototype and will output a noisy log of any activity. (To stop the command at any point simply switch back to the command line and press Ctrl+C.)
+
+By default the `serve` command automatically serves files from the directory that it is started in over port 4000 on your local machine. To access the the prototype in your Web browser go to:
+
+  http://localhost:4000
+
+You should see a simple directory listing. It will look similar to this:
+
+<pre>
+Name                          Last modified         Size
+----------------------------------------------------------
+Parent Directory              2008/02/23 15:35      -
+images/                       2008/02/23 15:35      -
+javascripts/                  2008/02/23 15:35      -
+login.html                    2008/02/23 15:36      346
+stylesheets/                  2008/02/23 15:35      -
+</pre>
+
+Now navigate to the following URL:
+
+  http://localhost:4000/login/
+
+You should see the contents of the login page. Note that Serve allows you to refer to pages without their extension. This allows you to use URLs in your documents that correspond well to the URLs that Rails uses by default.
+
+
+h3. Layouts
+
+One thing to note about the source that I gave you for the login page. I intentionally left out the <html>, <head>, and <body> tags because they belong a layout---not the source file. Let's go ahead and create that layout now.
+
+Insert the following HTML into a file named "_layout.html" in the root directory of your prototype:
+
+<pre><code>
+<html>
+  <head>
+    <title><%= @title %></title>
+  </head>
+  <body>
+    <h1><%= @title %>/h1>
+    <%= yield %>
+  </body>
+</html>
+</code></pre>
+
+This layout includes a small amount of ERB(Embedded Ruby) to indicate the title of the web page and to insert the content of the page at the appropriate point.
+
+Embedded Ruby is delineated with the opening and closing sequence <% and %> respectively. Sequences that begin with an addition equals sign insert their output directly into the HTML. In this case we want to render the @title variable as the title in the head and as the first heading in the document body. The yield keyword is used to insert the content of the page at that point.
+
+We need to make one small change to our login page before continuing. Insert the following line at the top of login.html file:
+
+<pre>
+<% @title = "Login" %>
+</pre>
+
+This will set the @title variable for the login page. Now, switch back to your Web browser and navigate to:
+
+<pre>
+http://localhost:4000/login/
+</pre>
+
+The page should now have a title and heading that both read "Login".
+
+h3. Content For
+
+h3. Partials

data/README.txt

@@ -70,11 +70,11 @@ It is recommended that you install serve via RubyGems:
 For more information, be sure to look through the documentation over at
 RubyForge:
 
-http://serve.rubyforge.org/
+* http://serve.rubyforge.org
 
 Or visit the project page here:
 
-http://rubyforge.org/projects/serve/
+* http://rubyforge.org/projects/serve
 
 
 === License

data/bin/serve

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
-
 lib = File.dirname(__FILE__) + '/../lib'
 require 'rubygems'
 if File.file?(lib + '/serve/version.rb')
@@ -8,69 +7,4 @@ else
   gem 'serve'
 end
 require 'serve'
-
-args = ARGV.join(' ')
-args.gsub!(%r{http://}, '')
-args = args.split(/[ :]/).compact
-
-help = args.delete('--help') || args.delete('-h') || false
-version = args.delete('--version') || args.delete('-v') || false
-environment = args.delete('production') || args.delete('test') || args.delete('test') || 'development'
-port = args.pop
-address = args.pop || '0.0.0.0'
-script = Dir.pwd + '/script/server'
-
-if args.size > 0
-  puts "invalid arguments"
-  puts ""
-  help = true
-end
-
-case
-when version
-  puts "Serve #{Serve.version}"
-when help
-  program = File.basename($0)
-  puts "Usage:"
-  puts "  #{program} [port] [environment]"
-  puts "  #{program} [address:port] [environment]"
-  puts "  #{program} [options]"
-  puts "  "
-  puts "Description:"
-  puts "  Starts a WEBrick server on the specified address and port with its document "
-  puts "  root set to the current working directory. By default the command uses "
-  puts "  0.0.0.0 for the address and 4000 for the port. This means that once the "
-  puts "  command has been started you can access the documents in the current "
-  puts "  directory with any Web browser at:"
-  puts "  "
-  puts "    http://localhost:4000/"
-  puts "  "
-  puts "  If the haml, redcloth, or bluecloth gems are installed the command can serve "
-  puts "  Haml, Sass, Textile, and Markdown for documents with haml, sass, textile, "
-  puts "  and markdown file extensions."
-  puts "  "
-  puts "  If the Rails command script/server exists in the current directory the "
-  puts "  script will start that instead with the specified environment or the "
-  puts "  development environment if none is specified. Rails apps are started by "
-  puts "  default on port 3000."
-  puts "  "
-  puts "Options:"
-  puts "  -h, --help      Show this message and quit."
-  puts "  -v, --version   Show the program version number and quit."
-else
-  unless File.file?(script) and File.executable?(script)
-    port ||= 4000
-    server = Serve::Server.new(
-      :Port => port,
-      :BindAddress => address,
-      :DocumentRoot => Dir.pwd,
-      :DirectoryIndex => %w(index.html index.txt index.text index.haml index.textile index.markdown index.email index.redirect),
-      :AppendExtensions => %w(html txt text haml textile markdown email redirect)
-    )
-    trap("INT") { server.shutdown }
-    server.start
-  else
-    port ||= 3000
-    system "#{script} -p #{port} -b #{address} -e #{environment}"
-  end
-end
+Serve::Application.run

data/lib/serve/application.rb

@@ -0,0 +1,145 @@
+module Serve
+  class Application
+    class InvalidArgumentsError < StandardError; end
+    
+    attr_accessor :options
+    
+    def self.run(args = ARGV)
+      Application.new.run(args)
+    end
+    
+    def initialize
+      self.options = {}
+    end
+    
+    def run(args = ARGV)
+      @options = parse(args)
+      case
+      when options[:version]
+        puts version
+      when options[:help]
+        puts help
+      else
+        Dir.chdir(options[:root])
+        if rails_app?
+          run_rails_app
+        else
+          run_server
+        end
+      end
+    rescue InvalidArgumentsError
+      puts "invalid arguments"
+      puts
+      puts help
+    end
+    
+    def parse(args)
+      args = normalize_args(args)
+      options[:help]        = extract_boolean(args, '-h', '--help')
+      options[:version]     = extract_boolean(args, '-v', '--version')
+      options[:environment] = extract_environment(args)
+      options[:root]        = extract_root(args)
+      options[:address]     = extract_address(args)
+      options[:port]        = extract_port(args)
+      raise InvalidArgumentsError if args.size > 0
+      options
+    end
+    
+    def version
+      "Serve #{Serve.version}"
+    end
+    
+    def help
+      program = File.basename($0)
+      [
+        "Usage:",
+        "  #{program} [port] [environment] [port]",
+        "  #{program} [address:port] [environment] [port]",
+        "  #{program} [options]",
+        "  ",
+        "Description:",
+        "  Starts a WEBrick server on the specified address and port with its document ",
+        "  root set to the current working directory. (Optionally, you can specify the ",
+        "  directory as the last parameter.) By default the command uses 0.0.0.0 for ",
+        "  the address and 4000 for the port. This means that once the command has ",
+        "  been started you can access the documents in the current directory with any ",
+        "  Web browser at:",
+        "  ",
+        "    http://localhost:4000/",
+        "  ",
+        "  If the haml, redcloth, or bluecloth gems are installed the command can serve ",
+        "  Haml, Sass, Textile, and Markdown for documents with haml, sass, textile, ",
+        "  and markdown file extensions.",
+        "  ",
+        "  If the Rails command script/server exists in the current directory the ",
+        "  script will start that instead with the specified environment or the ",
+        "  development environment if none is specified. Rails apps are started by ",
+        "  default on port 3000.",
+        "  ",
+        "Options:",
+        "  -h, --help      Show this message and quit.",
+        "  -v, --version   Show the program version number and quit."
+      ].join("\n")
+    end
+    
+    private
+      def normalize_args(args)
+        args = args.join(' ')
+        args.gsub!(%r{http://}, '')
+        args.split(/[ :]/).compact
+      end
+      
+      def extract_boolean(args, *opts)
+        opts.each do |opt|
+          return true if args.delete(opt)
+        end
+        false
+      end
+      
+      def extract_environment(args)
+        args.delete('production') || args.delete('test') || args.delete('development') || 'development'
+      end
+      
+      def extract_port(args)
+        args.delete(args.find {|a| /^\d\d\d+$/.match(a) }) || (rails_app? ? 3000 : 4000)
+      end
+      
+      def extract_address(args)
+        args.delete(args.find {|a| /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.match(a) }) || '0.0.0.0'
+      end
+      
+      def extract_root(args)
+        args.reverse.each do |dir|
+          if File.directory?(dir)
+            args.delete(dir)
+            return File.expand_path(dir)
+          end
+        end
+        Dir.pwd
+      end
+      
+      def rails_script_server
+        @rails_server_script ||= options[:root] + '/script/server'
+      end
+      
+      def rails_app?
+        File.file?(rails_script_server) and File.executable?(rails_script_server)
+      end
+      
+      def run_rails_app
+        system "#{rails_script_server} -p #{options[:port]} -b #{options[:address]} -e #{options[:environment]}"
+      end
+      
+      def run_server
+        server = Serve::Server.new(
+          :Port => options[:port],
+          :BindAddress => options[:address],
+          :DocumentRoot => options[:root],
+          :DirectoryIndex => %w(index.html index.erb index.html.erb index.rhtml index.haml index.html.haml index.txt index.text index.textile index.markdown index.email index.redirect),
+          :AppendExtensions => %w(html txt text haml erb rhtml html.erb html.haml textile markdown email redirect)
+        )
+        trap("INT") { server.shutdown }
+        server.start
+      end
+  end
+end

data/lib/serve/handlers/dynamic_handler.rb

@@ -0,0 +1,167 @@
+module Serve #:nodoc:
+  class Handler < FileTypeHandler #:nodoc:
+    extension 'erb', 'html.erb', 'rhtml', 'haml', 'html.haml'
+    
+    def process(req, res)
+      class << req
+        alias headers header
+      end
+      res['content-type'] = content_type
+      res.body = parse(req, res)
+    end
+    
+    def parse(req, res)
+      context = Context.new(req, res)
+      view_helpers_file_path = Dir.pwd + '/view_helpers.rb'
+      if File.file?(view_helpers_file_path)
+        (class << context; self end).module_eval(File.read(view_helpers_file_path))
+        class << context
+          include ViewHelpers
+        end
+      end
+      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 = Dir.pwd
+      path = filename[root.size..-1]
+      layout = nil
+      begin
+        path = File.dirname(path)
+        l = File.join(root, path, '_layout.haml')
+        layout = l if File.file?(l)
+      end until layout or path == "/"
+      layout
+    end
+    
+    module ERB #:nodoc:
+      class Engine #:nodoc:
+        def initialize(string, options = {})
+          @erb = ::ERB.new(string, nil, '-')
+          @erb.filename = options[:filename]
+        end
+        
+        def render(context, &block)
+          @erb.result(context.instance_eval { binding })
+        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'
+            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(req, res)
+        @request, @response = req, res
+        @content = ''
+      end
+      
+      # Content_for methods
+      
+      def content_for(symbol, &block)
+        set_content_for(symbol, capture_haml(&block))
+      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
+    
+      def set_content_for(symbol, value)
+        instance_variable_set("@content_for_#{symbol}", value)
+      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 = Dir.pwd
+        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/file_type_handler.rb

@@ -1,21 +1,24 @@
 module Serve #:nodoc:
   class FileTypeHandler < ::WEBrick::HTTPServlet::AbstractServlet #:nodoc:
   
-    def self.extension(extension)
-      ::WEBrick::HTTPServlet::FileHandler.add_handler(extension, self)
+    def self.extension(*extensions)
+      extensions.each do |extensions|
+        ::WEBrick::HTTPServlet::FileHandler.add_handler(extensions, self)
+      end
     end
-  
+    
+    
     def initialize(server, name)
       super
       @script_filename = name
     end
-  
+    
     def process(req, res)
       data = open(@script_filename){|io| io.read }
       res['content-type'] = content_type
       res.body = parse(data)
     end
-  
+    
     def do_GET(req, res)
       begin
         process(req, res)
@@ -26,15 +29,15 @@ module Serve #:nodoc:
         raise ::WEBrick::HTTPStatus::InternalServerError, ex.message
       end
     end
-  
+    
     alias do_POST do_GET
-  
+    
     protected
-  
+    
       def content_type
         'text/html'
       end
-    
+      
       def parse(string)
         string.dup
       end

data/lib/serve/version.rb

@@ -2,8 +2,8 @@ module Serve #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 9
-    TINY  = 6
-
+    TINY  = 7
+    
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
   

data/lib/serve.rb

@@ -1,10 +1,11 @@
 require 'webrick'
 require 'serve/version'
+require 'serve/application'
 require 'serve/webrick/extensions'
 require 'serve/handlers/file_type_handler'
 require 'serve/handlers/textile_handler'
 require 'serve/handlers/markdown_handler'
-require 'serve/handlers/haml_handler'
+require 'serve/handlers/dynamic_handler'
 require 'serve/handlers/sass_handler'
 require 'serve/handlers/email_handler'
 require 'serve/handlers/redirect_handler'

data/spec/serve_application_spec.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Serve::Application do
+  
+  before :each do
+    @app = Serve::Application.new
+    @defopts = {
+      :help => false,
+      :help => false,
+      :version => false,
+      :environment => 'development',
+      :port => 4000,
+      :address => '0.0.0.0',
+      :root => Dir.pwd
+    }
+  end
+  
+  describe "parsing" do
+    it "should parse no arguments" do
+      @app.parse([]).should == @defopts
+    end
+    
+    it "should parse with only the port" do
+      @app.parse(["2000"])[:port].should == "2000"
+    end
+    
+    it "should parse with the port and address" do
+      @app.parse(["1.1.1.1", "2000"]).should ==
+        @defopts.update(:address => "1.1.1.1", :port=>"2000")
+      @app.parse(["1.1.1.1:2000"]).should ==
+        @defopts.update(:address => "1.1.1.1", :port=>"2000")
+    end
+    
+    it "should parse with the port, address, and protocol" do
+      @app.parse(["http://1.1.1.1:2000"]).should ==
+        @defopts.update(:address => "1.1.1.1", :port=>"2000")
+    end
+    
+    it "should parse help" do
+      @app.parse([])[:help].should be_false
+      @app.parse(["-h"])[:help].should be_true
+      @app.parse(["--help"])[:help].should be_true
+    end
+    
+    it "should parse version" do
+      @app.parse([])[:version].should be_false
+      @app.parse(["-v"])[:version].should be_true
+      @app.parse(["--version"])[:version].should be_true
+    end
+    
+    it "should parse environment" do
+      @app.parse([])[:environment].should == "development"
+      @app.parse(["production"])[:environment].should == "production"
+      @app.parse(["test"])[:environment].should == "test"
+      @app.parse(["development"])[:environment].should == "development"
+    end
+    
+    it "should parse working directory" do
+      @app.parse([])[:root].should == Dir.pwd
+      dir = File.dirname(__FILE__)
+      @app.parse([dir])[:root].should == File.expand_path(dir)
+    end
+    
+    it "should detect invalid arguments" do
+      lambda { @app.parse(["--invalid"]) }.should raise_error(Serve::Application::InvalidArgumentsError)
+      lambda { @app.parse(["invalid"]) }.should raise_error(Serve::Application::InvalidArgumentsError)
+    end
+  end
+  
+  describe "running" do
+    
+  end
+  
+end

data/spec/serve_spec.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/spec_helper.rb'
 describe "Serve" do
   
   it "should register all of the file type handlers" do
-    handlers = ["cgi", "email", "haml", "markdown", "redirect", "rhtml", "sass", "textile"]
+    handlers = ["cgi", "email", "erb", "haml", "html.erb", "html.haml", "markdown", "redirect", "rhtml", "sass", "textile"]
     table = WEBrick::HTTPServlet::FileHandler::HandlerTable
     table.keys.sort.should == handlers
   end

data.tar.gz.sig

@@ -1 +1 @@
-�8�\���:L�20[6N����g�~Ya�d5 �V����t#h$dpQ/�����n��L�
+B4RqPy�l�W�CF��)U��79M����+p�1��;%����+u�@

metadata

@@ -1,29 +1,12 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: serve
 version: !ruby/object:Gem::Version 
-  version: 0.9.6
-date: 2008-02-20 00:00:00 -05:00
-summary: Serve is a small Ruby script that makes it easy to start up a WEBrick server in any directory. Serve is ideal for HTML prototyping and simple file sharing. If the haml, redcloth, and bluecloth gems are installed serve can handle Haml, Sass, Textile, and Markdown (in addition to HTML).
-require_paths: 
-- lib
-email: me@johnwlong.com
-homepage: http://serve.rubyforge.org
-rubyforge_project: serve
-description: Serve is a small Ruby script that makes it easy to start up a WEBrick server in any directory. Serve is ideal for HTML prototyping and simple file sharing. If the haml, redcloth, and bluecloth gems are installed serve can handle Haml, Sass, Textile, and Markdown (in addition to HTML).
+  version: 0.9.7
+platform: ruby
+authors: 
+- John W. Long
 autorequire: 
-default_executable: 
 bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
-platform: ruby
-signing_key: 
 cert_chain: 
 - |
   -----BEGIN CERTIFICATE-----
@@ -47,22 +30,36 @@ cert_chain:
   qXI=
   -----END CERTIFICATE-----
 
-post_install_message: 
-authors: 
-- John W. Long
+date: 2008-07-17 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Serve is a small Ruby script that makes it easy to start up a WEBrick server in any directory. Serve is ideal for HTML prototyping and simple file sharing. If the haml, redcloth, and bluecloth gems are installed serve can handle Haml, Sass, Textile, and Markdown (in addition to HTML).
+email: me@johnwlong.com
+executables: 
+- serve
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- README.txt
 files: 
 - History.txt
 - License.txt
 - Manifest.txt
+- Quickstart.textile
 - README.txt
 - Rakefile
 - bin/serve
 - config/hoe.rb
 - config/requirements.rb
 - lib/serve.rb
+- lib/serve/application.rb
+- lib/serve/handlers/dynamic_handler.rb
 - lib/serve/handlers/email_handler.rb
 - lib/serve/handlers/file_type_handler.rb
-- lib/serve/handlers/haml_handler.rb
 - lib/serve/handlers/markdown_handler.rb
 - lib/serve/handlers/redirect_handler.rb
 - lib/serve/handlers/sass_handler.rb
@@ -74,6 +71,7 @@ files:
 - script/generate
 - script/txt2html
 - setup.rb
+- spec/serve_application_spec.rb
 - spec/serve_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -82,21 +80,32 @@ files:
 - tasks/rspec.rake
 - tasks/undefine.rake
 - tasks/website.rake
-test_files: []
-
+has_rdoc: true
+homepage: http://serve.rubyforge.org
+post_install_message: 
 rdoc_options: 
 - --main
 - README.txt
-extra_rdoc_files: 
-- History.txt
-- License.txt
-- Manifest.txt
-- README.txt
-executables: 
-- serve
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
+rubyforge_project: serve
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Serve is a small Ruby script that makes it easy to start up a WEBrick server in any directory. Serve is ideal for HTML prototyping and simple file sharing. If the haml, redcloth, and bluecloth gems are installed serve can handle Haml, Sass, Textile, and Markdown (in addition to HTML).
+test_files: []
 

data/lib/serve/handlers/haml_handler.rb

@@ -1,114 +0,0 @@
-module Serve #:nodoc:
-  class HamlHandler < FileTypeHandler #:nodoc:
-    extension 'haml'
-  
-    def parse(string)
-      require 'haml'
-      engine = Haml::Engine.new(string,
-        :attr_wrapper => '"',
-        :filename => @script_filename
-      )
-      layout = find_layout(@script_filename)
-      if layout
-        lines = IO.read(layout)
-        context = Context.new(Dir.pwd, @script_filename, engine.options.dup)
-        context.content = engine.render(context) do |*args|
-          context.get_content_for(*args)
-        end
-        layout_engine = Haml::Engine.new(lines, engine.options.dup)
-        layout_engine.render(context) do |*args|
-          context.get_content_for(*args)
-        end
-      else
-        engine.render
-      end
-    end
-  
-    def find_layout(filename)
-      root = Dir.pwd
-      path = filename[root.size..-1]
-      layout = nil
-      begin
-        path = File.dirname(path)
-        l = File.join(root, path, '_layout.haml')
-        layout = l if File.file?(l)
-      end until layout or path == "/"
-      layout
-    end
-  
-    class Context #:nodoc:
-      attr_accessor :content
-    
-      def initialize(root, script_filename, engine_options)
-        @root, @script_filename, @engine_options = root, script_filename, engine_options
-      end
-    
-      # Content_for methods
-    
-      def content_for(symbol, &block)
-        set_content_for(symbol, capture_haml(&block))
-      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}") || instance_variable_get("@#{symbol}")
-        end
-      end
-    
-      def set_content_for(symbol, value)
-        instance_variable_set("@content_for_#{symbol}", value)
-      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(@script_filename)
-        if template =~ %r{^/}
-          template = template[1..-1]
-          path = @root
-        end
-        filename = template_filename(File.join(path, template), :partial => options.delete(:partial))
-        if File.file?(filename)
-          lines = IO.read(filename)
-          engine = Haml::Engine.new(lines, @engine_options)
-          engine.render(self) do |*args|
-            get_content_for(*args)
-          end
-        else
-          raise "File does not exist #{filename.inspect}"
-        end
-      end
-    
-      def template_filename(name, options)
-        path = File.dirname(name)
-        template = File.basename(name)
-        template = "_" + template if options.delete(:partial)
-        template += ".haml" unless name =~ /\.haml$/
-        File.join(path, template)
-      end
-    end
-  end
-end