codebutler 0.0.3

data/LICENCE

@@ -0,0 +1,23 @@
+Copyright (c) 2008 Markus Prinz
+Sinatra is Copyright (c) 2007 Blake Mizerany
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/Manifest

@@ -0,0 +1,6 @@
+bin/codebutler
+lib/codebutler/sinatra.rb
+lib/codebutler.rb
+LICENCE
+Manifest
+README

data/README

@@ -0,0 +1,47 @@
+= CodeButler
+
+* http://rubyforge.org/projects/codebutler/
+* http://github.com/cypher/codebutler/tree/master
+
+== DESCRIPTION:
+
+CodeButler scans a given directory for supported sourcecode, and then serves them highlighted by Coderay on a local webserver.
+
+== REQUIREMENTS:
+
+* Coderay >= 0.7.4
+* mongrel >= 1.0.1
+* rack >= 0.2.0
+
+Since a version of Sinatra is required that is not yet available as a gem, it is included with CodeButler for now
+
+== INSTALL:
+
+gem install codebutler
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Markus Prinz
+
+Sinatra is Copyright (c) 2007 Blake Mizerany
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/bin/codebutler

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+#
+# Created by Markus Prinz on 2008-4-3.
+# Copyright (c) 2008. All rights reserved.
+#
+# Available options:
+#   -p port
+#   -h
+
+require 'rubygems'
+require 'codebutler'
+
+CodeButler.serve

data/codebutler.gemspec

@@ -0,0 +1,49 @@
+
+# Gem::Specification for Codebutler-0.0.3
+# Originally generated by Echoe
+
+Gem::Specification.new do |s|
+  s.name = %q{codebutler}
+  s.version = "0.0.3"
+
+  s.specification_version = 2 if s.respond_to? :specification_version=
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Markus Prinz"]
+  s.date = %q{2008-04-04}
+  s.default_executable = %q{codebutler}
+  s.description = %q{Simply run codebutler in a directory of your choice, and it will serve all the code files it supports on a local webserver, hilighted.}
+  s.email = %q{markus.prinz@qsig.org}
+  s.executables = ["codebutler"]
+  s.extra_rdoc_files = ["bin/codebutler", "lib/codebutler/sinatra.rb", "lib/codebutler.rb", "README"]
+  s.files = ["bin/codebutler", "lib/codebutler/sinatra.rb", "lib/codebutler.rb", "LICENCE", "Manifest", "README", "codebutler.gemspec"]
+  s.has_rdoc = true
+  s.homepage = %q{http://codebutler.rubyforge.org}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Codebutler", "--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{codebutler}
+  s.rubygems_version = %q{1.1.0}
+  s.summary = %q{Easily serve your highlighted codefiles from a local webserver}
+
+  s.add_dependency(%q<coderay>, [">= 0.7.4"])
+  s.add_dependency(%q<mongrel>, [">= 1.0.1"])
+  s.add_dependency(%q<rack>, [">= 0.2.0"])
+end
+
+
+# # Original Rakefile source (requires the Echoe gem):
+# 
+# require 'rubygems'
+# require 'rake'
+# require 'echoe'
+# 
+# Echoe.new("codebutler") do |p|
+#   p.author = "Markus Prinz"
+#   p.email = "markus.prinz@qsig.org"
+#   p.summary = "Easily serve your highlighted codefiles from a local webserver"
+#   p.description = "Simply run codebutler in a directory of your choice, and it will serve all the code files it supports on a local webserver, hilighted."
+#   p.url = "http://codebutler.rubyforge.org"
+#   p.version = '0.0.3'
+#   p.dependencies = ["coderay >=0.7.4", "mongrel >=1.0.1", "rack >=0.2.0"]
+# end
+# 

data/lib/codebutler.rb

@@ -0,0 +1,71 @@
+require 'find'
+require 'coderay'
+require 'uri'
+
+# We bring our own version of sinatra since it's not available as a gem yet
+require 'codebutler/sinatra'
+
+module CodeButler
+  
+  SUPPORTED_LANGUAGES = {
+    '.rb'     => :ruby,
+    '.c'      => :c,
+    '.cc'     => :c,
+    '.h'      => :c,
+    '.html'   => :html,
+    '.rhtml'  => :rhtml,    
+  }
+  
+  # Ignore all command line arguments except -p
+  #
+  # Also clears ARGV to prevent sinatra from parsing
+  def self.clean_argv
+    if ARGV.include? "-h"
+      puts <<-HELP
+      Supported Arguments:
+        -h        Print help (You're looking at it)
+        -p port   Start the webserver on the specified port
+      HELP
+      exit
+    elsif ARGV.include?("-p") && ARGV[ARGV.index("-p") + 1] =~ /^[0-9]+$/
+      port = ARGV[ARGV.index("-p") + 1]
+      ARGV.clear
+      ARGV.unshift ['-p', port.to_s]
+    else
+      ARGV.clear
+    end        
+  end
+  
+  # Scan the current working directory for files, and serve them on localhost
+  def self.serve
+    clean_argv
+    
+    # Create a regex that matches all supported file endings
+    regex = Regexp.new("(#{SUPPORTED_LANGUAGES.keys.map{|key| Regexp.escape(key)}.join('|')})$")
+    
+    working_dir = Dir.getwd
+    file_list = []
+
+    Find.find(working_dir) do |path|
+      if match = path.match(regex)
+        relative_path = path.slice( working_dir.length..-1 )
+        
+        file_list << relative_path
+        
+        # use Sinatra for easy hosting
+        # We need to escape the path to catch names like "c++test.rb" and spaces
+        get(Regexp.escape(URI.escape(relative_path))) do
+          CodeRay.scan(File.readlines(path).join, SUPPORTED_LANGUAGES[match[1]]).div
+        end
+      end
+    end
+    
+    # index:
+    get('/') do
+      file_list.sort.map { |file|
+        %Q(<a href="#{file}">#{file}</a>)
+      }.join("<br/>")      
+    end
+    
+  end
+end

data/lib/codebutler/sinatra.rb

@@ -0,0 +1,1060 @@
+require 'rubygems'
+require 'metaid'
+require 'uri'
+require 'thread'
+require 'time'
+
+if ENV['SWIFT']
+ require 'swiftcore/swiftiplied_mongrel'
+ puts "Using Swiftiplied Mongrel"
+elsif ENV['EVENT']
+  require 'swiftcore/evented_mongrel' 
+  puts "Using Evented Mongrel"
+end
+
+require 'rack'
+require 'ostruct'
+
+class Class
+  def dslify_writter(*syms)
+    syms.each do |sym|
+      class_eval <<-end_eval
+        def #{sym}(v=nil)
+          self.send "#{sym}=", v if v
+          v
+        end
+      end_eval
+    end
+  end
+end
+
+module Rack #:nodoc:
+  
+  class Request #:nodoc:
+
+    # Set of request method names allowed via the _method parameter hack. By default,
+    # all request methods defined in RFC2616 are included, with the exception of
+    # TRACE and CONNECT.
+    POST_TUNNEL_METHODS_ALLOWED = %w( PUT DELETE OPTIONS HEAD )
+
+    # Return the HTTP request method with support for method tunneling using the POST
+    # _method parameter hack.  If the real request method is POST and a _method param is
+    # given and the value is one defined in +POST_TUNNEL_METHODS_ALLOWED+, return the value
+    # of the _method param instead.
+    def request_method
+      if post_tunnel_method_hack?
+        params['_method'].upcase
+      else
+        @env['REQUEST_METHOD']
+      end
+    end
+
+    def user_agent
+      env['HTTP_USER_AGENT']
+    end
+
+    private
+
+      # Return truthfully if and only if the following conditions are met: 1.) the
+      # *actual* request method is POST, 2.) the request content-type is one of
+      # 'application/x-www-form-urlencoded' or 'multipart/form-data', 3.) there is a 
+      # "_method" parameter in the POST body (not in the query string), and 4.) the 
+      # method parameter is one of the verbs listed in the POST_TUNNEL_METHODS_ALLOWED
+      # list.
+      def post_tunnel_method_hack?
+        @env['REQUEST_METHOD'] == 'POST' &&
+          POST_TUNNEL_METHODS_ALLOWED.include?(self.POST.fetch('_method', '').upcase)
+      end
+
+  end
+  
+  module Utils
+    extend self
+  end
+
+end
+
+module Sinatra
+  extend self
+
+  module Version
+    MAJOR = '0'
+    MINOR = '2'
+    REVISION = '0'
+    def self.combined
+      [MAJOR, MINOR, REVISION].join('.')
+    end
+  end
+
+  class NotFound < RuntimeError; end
+  class ServerError < RuntimeError; end
+
+  Result = Struct.new(:block, :params, :status) unless defined?(Result)
+
+  def options
+    application.options
+  end
+  
+  def application
+    unless @app 
+      @app = Application.new
+      Sinatra::Environment.setup!
+    end
+    @app
+  end
+  
+  def application=(app)
+    @app = app
+  end
+  
+  def port
+    application.options.port
+  end
+  
+  def env
+    application.options.env
+  end
+  
+  def build_application
+    Rack::CommonLogger.new(application)
+  end
+  
+  def run
+    
+    begin
+      puts "== Sinatra has taken the stage on port #{port} for #{env}"
+      require 'pp'
+      Rack::Handler::Mongrel.run(build_application, :Port => port) do |server|
+        trap(:INT) do
+          server.stop
+          puts "\n== Sinatra has ended his set (crowd applauds)"
+        end
+      end
+    rescue Errno::EADDRINUSE => e
+      puts "== Someone is already performing on port #{port}!"
+    end
+    
+  end
+      
+  class Event
+
+    URI_CHAR = '[^/?:,&#\.]'.freeze unless defined?(URI_CHAR)
+    PARAM = /:(#{URI_CHAR}+)/.freeze unless defined?(PARAM)
+    SPLAT = /(.*?)/
+    attr_reader :path, :block, :param_keys, :pattern, :options
+    
+    def initialize(path, options = {}, &b)
+      @path = path
+      @block = b
+      @param_keys = []
+      @options = options
+      regex = @path.to_s.gsub(PARAM) do
+        @param_keys << $1
+        "(#{URI_CHAR}+)"
+      end
+      
+      regex.gsub!('*', SPLAT.to_s)
+      
+      @pattern = /^#{regex}$/
+    end
+        
+    def invoke(request)
+      params = {}
+      if agent = options[:agent] 
+        return unless request.user_agent =~ agent
+        params[:agent] = $~[1..-1]
+      end
+      if host = options[:host] 
+        return unless host === request.host
+      end
+      return unless pattern =~ request.path_info.squeeze('/')
+      params.merge!(param_keys.zip($~.captures.map(&:from_param)).to_hash)
+      Result.new(block, params, 200)
+    end
+    
+  end
+  
+  class Error
+    
+    attr_reader :code, :block
+    
+    def initialize(code, &b)
+      @code, @block = code, b
+    end
+    
+    def invoke(request)
+      Result.new(block, {}, 404)
+    end
+    
+  end
+  
+  class Static
+            
+    def invoke(request)
+      return unless File.file?(
+        Sinatra.application.options.public + request.path_info
+      )
+      Result.new(block, {}, 200)
+    end
+    
+    def block
+      Proc.new do
+        send_file Sinatra.application.options.public + request.path_info,
+          :disposition => nil
+      end
+    end
+    
+  end
+  
+  # Adapted from actionpack
+  # Methods for sending files and streams to the browser instead of rendering.
+  module Streaming
+    DEFAULT_SEND_FILE_OPTIONS = {
+      :type         => 'application/octet-stream'.freeze,
+      :disposition  => 'attachment'.freeze,
+      :stream       => true, 
+      :buffer_size  => 4096
+    }.freeze
+
+    class MissingFile < RuntimeError; end
+
+    class FileStreamer
+      
+      attr_reader :path, :options
+      
+      def initialize(path, options)
+        @path, @options = path, options
+      end
+      
+      def to_result(cx, *args)
+        self
+      end
+      
+      def each
+        File.open(path, 'rb') do |file|
+          while buf = file.read(options[:buffer_size])
+            yield buf
+          end
+        end
+      end
+      
+    end
+
+    protected
+      # Sends the file by streaming it 4096 bytes at a time. This way the
+      # whole file doesn't need to be read into memory at once.  This makes
+      # it feasible to send even large files.
+      #
+      # Be careful to sanitize the path parameter if it coming from a web
+      # page.  send_file(params[:path]) allows a malicious user to
+      # download any file on your server.
+      #
+      # Options:
+      # * <tt>:filename</tt> - suggests a filename for the browser to use.
+      #   Defaults to File.basename(path).
+      # * <tt>:type</tt> - specifies an HTTP content type.
+      #   Defaults to 'application/octet-stream'.
+      # * <tt>:disposition</tt> - specifies whether the file will be shown inline or downloaded.  
+      #   Valid values are 'inline' and 'attachment' (default). When set to nil, the
+      #   Content-Disposition and Content-Transfer-Encoding headers are omitted entirely.
+      # * <tt>:stream</tt> - whether to send the file to the user agent as it is read (true)
+      #   or to read the entire file before sending (false). Defaults to true.
+      # * <tt>:buffer_size</tt> - specifies size (in bytes) of the buffer used to stream the file.
+      #   Defaults to 4096.
+      # * <tt>:status</tt> - specifies the status code to send with the response. Defaults to '200 OK'.
+      # * <tt>:last_modified</tt> - an optional RFC 2616 formatted date value (See Time#httpdate)
+      #   indicating the last modified time of the file. If the request includes an
+      #   If-Modified-Since header that matches this value exactly, a 304 Not Modified response
+      #   is sent instead of the file. Defaults to the file's last modified
+      #   time.
+      #
+      # The default Content-Type and Content-Disposition headers are
+      # set to download arbitrary binary files in as many browsers as
+      # possible.  IE versions 4, 5, 5.5, and 6 are all known to have
+      # a variety of quirks (especially when downloading over SSL).
+      #
+      # Simple download:
+      #   send_file '/path/to.zip'
+      #
+      # Show a JPEG in the browser:
+      #   send_file '/path/to.jpeg', :type => 'image/jpeg', :disposition => 'inline'
+      #
+      # Show a 404 page in the browser:
+      #   send_file '/path/to/404.html, :type => 'text/html; charset=utf-8', :status => 404
+      #
+      # Read about the other Content-* HTTP headers if you'd like to
+      # provide the user with more information (such as Content-Description).
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.11
+      #
+      # Also be aware that the document may be cached by proxies and browsers.
+      # The Pragma and Cache-Control headers declare how the file may be cached
+      # by intermediaries.  They default to require clients to validate with
+      # the server before releasing cached responses.  See
+      # http://www.mnot.net/cache_docs/ for an overview of web caching and
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9
+      # for the Cache-Control header spec.
+      def send_file(path, options = {}) #:doc:
+        raise MissingFile, "Cannot read file #{path}" unless File.file?(path) and File.readable?(path)
+
+        options[:length]   ||= File.size(path)
+        options[:filename] ||= File.basename(path)
+        options[:type] ||= Rack::File::MIME_TYPES[File.extname(options[:filename])[1..-1]] || 'text/plain'
+        options[:last_modified] ||= File.mtime(path).httpdate
+        send_file_headers! options
+
+        if options[:stream]
+          throw :halt, [options[:status] || 200, FileStreamer.new(path, options)]
+        else
+          File.open(path, 'rb') { |file| throw :halt, [options[:status] || 200, file.read] }
+        end
+      end
+
+      # Send binary data to the user as a file download.  May set content type, apparent file name,
+      # and specify whether to show data inline or download as an attachment.
+      #
+      # Options:
+      # * <tt>:filename</tt> - Suggests a filename for the browser to use.
+      # * <tt>:type</tt> - specifies an HTTP content type.
+      #   Defaults to 'application/octet-stream'.
+      # * <tt>:disposition</tt> - specifies whether the file will be shown inline or downloaded.  
+      #   Valid values are 'inline' and 'attachment' (default).
+      # * <tt>:status</tt> - specifies the status code to send with the response. Defaults to '200 OK'.
+      # * <tt>:last_modified</tt> - an optional RFC 2616 formatted date value (See Time#httpdate)
+      #   indicating the last modified time of the response entity. If the request includes an
+      #   If-Modified-Since header that matches this value exactly, a 304 Not Modified response
+      #   is sent instead of the data.
+      #
+      # Generic data download:
+      #   send_data buffer
+      #
+      # Download a dynamically-generated tarball:
+      #   send_data generate_tgz('dir'), :filename => 'dir.tgz'
+      #
+      # Display an image Active Record in the browser:
+      #   send_data image.data, :type => image.content_type, :disposition => 'inline'
+      #
+      # See +send_file+ for more information on HTTP Content-* headers and caching.
+      def send_data(data, options = {}) #:doc:
+        send_file_headers! options.merge(:length => data.size)
+        throw :halt, [options[:status] || 200, data]
+      end
+
+    private
+      def send_file_headers!(options)
+        options = DEFAULT_SEND_FILE_OPTIONS.merge(options)
+        [:length, :type, :disposition].each do |arg|
+          raise ArgumentError, ":#{arg} option required" unless options.key?(arg)
+        end
+
+        # Send a "304 Not Modified" if the last_modified option is provided and matches
+        # the If-Modified-Since request header value.
+        if last_modified = options[:last_modified]
+          header 'Last-Modified' => last_modified
+          throw :halt, [ 304, '' ] if last_modified == request.env['HTTP_IF_MODIFIED_SINCE']
+        end
+
+        headers(
+          'Content-Length'            => options[:length].to_s,
+          'Content-Type'              => options[:type].strip  # fixes a problem with extra '\r' with some browsers
+        )
+
+        # Omit Content-Disposition and Content-Transfer-Encoding headers if
+        # the :disposition option set to nil.
+        if !options[:disposition].nil?
+          disposition = options[:disposition].dup || 'attachment'
+          disposition <<= %(; filename="#{options[:filename]}") if options[:filename]
+          headers 'Content-Disposition' => disposition, 'Content-Transfer-Encoding' => 'binary'
+        end
+
+        # Fix a problem with IE 6.0 on opening downloaded files:
+        # If Cache-Control: no-cache is set (which Rails does by default), 
+        # IE removes the file it just downloaded from its cache immediately 
+        # after it displays the "open/save" dialog, which means that if you 
+        # hit "open" the file isn't there anymore when the application that 
+        # is called for handling the download is run, so let's workaround that
+        header('Cache-Control' => 'private') if headers['Cache-Control'] == 'no-cache'
+      end
+  end
+  
+  module ResponseHelpers
+
+    def redirect(path, *args)
+      status(302)
+      headers 'Location' => path
+      throw :halt, *args
+    end
+    
+    def headers(header = nil)
+      @response.headers.merge!(header) if header
+      @response.headers
+    end
+    alias :header :headers
+
+  end
+  
+  module RenderingHelpers
+
+    def render(renderer, template, options={})
+      m = method("render_#{renderer}")
+      result = m.call(resolve_template(renderer, template, options), options)
+      if layout = determine_layout(renderer, template, options)
+        result = m.call(resolve_template(renderer, layout, options), options) { result }
+      end
+      result
+    end
+    
+    def determine_layout(renderer, template, options)
+      return if options[:layout] == false
+      layout_from_options = options[:layout] || :layout
+      resolve_template(renderer, layout_from_options, options, false)
+    end
+
+    private
+        
+      def resolve_template(renderer, template, options, scream = true)
+        case template
+        when String
+          template
+        when Proc
+          template.call
+        when Symbol
+          if proc = templates[template]
+            resolve_template(renderer, proc, options, scream)
+          else
+            read_template_file(renderer, template, options, scream)
+          end
+        else
+          nil
+        end
+      end
+      
+      def read_template_file(renderer, template, options, scream = true)
+        path = File.join(
+          options[:views_directory] || Sinatra.application.options.views,
+          "#{template}.#{renderer}"
+        )
+        unless File.exists?(path)
+          raise Errno::ENOENT.new(path) if scream
+          nil
+        else  
+          File.read(path)
+        end
+      end
+      
+      def templates
+        Sinatra.application.templates
+      end
+    
+  end
+
+  module Erb
+    
+    def erb(content, options={})
+      require 'erb'
+      render(:erb, content, options)
+    end
+    
+    private 
+    
+      def render_erb(content, options = {})
+        ::ERB.new(content).result(binding)
+      end
+      
+  end
+
+  module Haml
+    
+    def haml(content, options={})
+      require 'haml'
+      render(:haml, content, options)
+    end
+    
+    private
+    
+      def render_haml(content, options = {}, &b)
+        ::Haml::Engine.new(content).render(options[:scope] || self, options[:locals] || {}, &b)
+      end
+        
+  end
+
+  # Generating conservative XML content using Builder templates.
+  #
+  # Builder templates can be inline by passing a block to the builder method, or in
+  # external files with +.builder+ extension by passing the name of the template
+  # to the +builder+ method as a Symbol.
+  #
+  # === Inline Rendering
+  #
+  # If the builder method is given a block, the block is called directly with an 
+  # +XmlMarkup+ instance and the result is returned as String:
+  #   get '/who.xml' do
+  #     builder do |xml|
+  #       xml.instruct!
+  #       xml.person do
+  #         xml.name "Francis Albert Sinatra", 
+  #           :aka => "Frank Sinatra"
+  #         xml.email 'frank@capitolrecords.com'
+  #       end
+  #     end
+  #   end
+  #
+  # Yields the following XML:
+  #   <?xml version='1.0' encoding='UTF-8'?>
+  #   <person>
+  #     <name aka='Frank Sinatra'>Francis Albert Sinatra</name>
+  #     <email>Frank Sinatra</email>
+  #   </person>
+  #
+  # === Builder Template Files
+  #
+  # Builder templates can be stored in separate files with a +.builder+ 
+  # extension under the view path. An +XmlMarkup+ object named +xml+ is automatically
+  # made available to template.
+  #
+  # Example:
+  #   get '/bio.xml' do
+  #     builder :bio
+  #   end
+  #
+  # The "views/bio.builder" file might contain the following:
+  #   xml.instruct! :xml, :version => '1.1'
+  #   xml.person do
+  #     xml.name "Francis Albert Sinatra"
+  #     xml.aka "Frank Sinatra"
+  #     xml.aka "Ol' Blue Eyes"
+  #     xml.aka "The Chairman of the Board"
+  #     xml.born 'date' => '1915-12-12' do
+  #       xml.text! "Hoboken, New Jersey, U.S.A."
+  #     end
+  #     xml.died 'age' => 82
+  #   end
+  #
+  # And yields the following output:
+  #   <?xml version='1.1' encoding='UTF-8'?>
+  #   <person>
+  #     <name>Francis Albert Sinatra</name>
+  #     <aka>Frank Sinatra</aka>
+  #     <aka>Ol&apos; Blue Eyes</aka>
+  #     <aka>The Chairman of the Board</aka>
+  #     <born date='1915-12-12'>Hoboken, New Jersey, U.S.A.</born>
+  #     <died age='82' />
+  #   </person>
+  #
+  # NOTE: Builder must be installed or a LoadError will be raised the first time an
+  # attempt is made to render a builder template.
+  #
+  # See http://builder.rubyforge.org/ for comprehensive documentation on Builder.
+  module Builder
+
+    def builder(content=nil, options={}, &block)
+      options, content = content, nil if content.is_a?(Hash)
+      content = Proc.new { block } if content.nil?
+      render(:builder, content, options)
+    end
+
+    private
+
+      def render_builder(content, options = {}, &b)
+        require 'builder'
+        xml = ::Builder::XmlMarkup.new(:indent => 2)
+        case content
+        when String
+          eval(content, binding, '<BUILDER>', 1)
+        when Proc
+          content.call(xml)
+        end
+        xml.target!
+      end
+
+  end
+
+  class EventContext
+    
+    include ResponseHelpers
+    include Streaming
+    include RenderingHelpers
+    include Erb
+    include Haml
+    include Builder
+    
+    attr_accessor :request, :response
+    
+    dslify_writter :status, :body
+    
+    def initialize(request, response, route_params)
+      @request = request
+      @response = response
+      @route_params = route_params
+      @response.body = nil
+    end
+    
+    def params
+      @params = @route_params.merge(@request.params)
+    end
+        
+    def stop(*args)
+      throw :halt, args
+    end
+    
+    def complete(returned)
+      @response.body || returned
+    end
+    
+    private
+
+      def method_missing(name, *args, &b)
+        @response.send(name, *args, &b)
+      end
+    
+  end
+  
+  class Application
+    
+    attr_reader :events, :errors, :templates, :filters
+    attr_reader :clearables, :reloading
+    
+    attr_writer :options
+    
+    def self.default_options
+      @@default_options ||= {
+        :run => true,
+        :port => 4567,
+        :env => :development,
+        :root => Dir.pwd,
+        :views => Dir.pwd + '/views',
+        :public => Dir.pwd + '/public'
+      }
+    end
+    
+    def default_options
+      self.class.default_options
+    end
+
+    
+    ##
+    # Load all options given on the command line
+    # NOTE:  Ignores --name so unit/spec tests can run individually
+    def load_options!
+      require 'optparse'
+      OptionParser.new do |op|
+        op.on('-p port') { |port| default_options[:port] = port }
+        op.on('-e env') { |env| default_options[:env] = env }
+        op.on('-x') { |env| default_options[:mutex] = true }
+      end.parse!(ARGV.dup.select { |o| o !~ /--name/ })
+    end
+
+    # Called immediately after the application is initialized or reloaded to
+    # register default events. Events added here have dibs on requests since
+    # they appear first in the list.
+    def load_default_events!
+      events[:get] << Static.new
+    end
+
+    def initialize
+      @clearables = [
+        @events = Hash.new { |hash, key| hash[key] = [] },
+        @errors = Hash.new,
+        @filters = Hash.new { |hash, key| hash[key] = [] },
+        @templates = Hash.new
+      ]
+      load_options!
+      load_default_events!
+    end
+
+    def define_event(method, path, options = {}, &b)
+      events[method] << event = Event.new(path, options, &b)
+      event
+    end
+    
+    def define_template(name=:layout, &b)
+      templates[name] = b
+    end
+    
+    def define_error(code, options = {}, &b)
+      errors[code] = Error.new(code, &b)
+    end
+    
+    def define_filter(type, &b)
+      filters[:before] << b
+    end
+
+    # Visits and invokes each handler registered for the +request_method+ in
+    # definition order until a Result response is produced. If no handler
+    # responds with a Result, the NotFound error handler is invoked.
+    #
+    # When the request_method is "HEAD" and no valid Result is produced by
+    # the set of handlers registered for HEAD requests, an attempt is made to
+    # invoke the GET handlers to generate the response before resorting to the
+    # default error handler.
+    def lookup(request)
+      method = request.request_method.downcase.to_sym
+      events[method].eject(&[:invoke, request]) ||
+        (events[:get].eject(&[:invoke, request]) if method == :head) ||
+        errors[NotFound].invoke(request)
+    end
+
+    def options
+      @options ||= OpenStruct.new(default_options)
+    end
+    
+    def development?
+      options.env == :development
+    end
+
+    def reload!
+      @reloading = true
+      clearables.each(&:clear)
+      load_default_events!
+      Kernel.load $0
+      @reloading = false
+      Environment.setup!
+    end
+    
+    def mutex
+      @@mutex ||= Mutex.new
+    end
+    
+    def run_safely
+      if options.mutex
+        mutex.synchronize { yield }
+      else
+        yield
+      end
+    end
+    
+    def call(env)
+      reload! if development?
+      request = Rack::Request.new(env)
+      result = lookup(request)
+      context = EventContext.new(
+        request, 
+        Rack::Response.new,
+        result.params
+      )
+      context.status(result.status)
+      begin
+        returned = run_safely do
+          catch(:halt) do
+            filters[:before].each { |f| context.instance_eval(&f) }
+            [:complete, context.instance_eval(&result.block)]
+          end
+        end
+        body = returned.to_result(context)
+      rescue => e
+        request.env['sinatra.error'] = e
+        context.status(500)
+        result = (errors[e.class] || errors[ServerError]).invoke(request)
+        returned = run_safely do
+          catch(:halt) do
+            [:complete, context.instance_eval(&result.block)]
+          end
+        end
+        body = returned.to_result(context)
+      end
+      body = '' unless body.respond_to?(:each)
+      body = '' if request.request_method.upcase == 'HEAD'
+      context.body = body.kind_of?(String) ? [*body] : body
+      context.finish
+    end
+    
+  end
+  
+  
+  module Environment
+    extend self
+    
+    def setup!
+      configure do
+        error do
+          raise request.env['sinatra.error'] if Sinatra.options.raise_errors
+          '<h1>Internal Server Error</h1>'
+        end
+        not_found { '<h1>Not Found</h1>'}
+      end
+      
+      configures :development do
+
+        get '/sinatra_custom_images/:image.png' do
+          File.read(File.dirname(__FILE__) + "/../images/#{params[:image]}.png")
+        end
+
+        not_found do
+          %Q(
+          <style>
+          body {
+            text-align: center; 
+            color: #888;
+            font-family: Arial; 
+            font-size: 22px; 
+            margin: 20px;
+          }
+          #content {
+            margin: 0 auto;
+            width: 500px;
+            text-align: left;
+          }
+          </style>
+          <html>
+            <body>
+              <h2>Sinatra doesn't know this diddy.</h2>
+              <img src='/sinatra_custom_images/404.png'></img>
+              <div id="content">
+                Try this:
+<pre>#{request.request_method.downcase} "#{request.path_info}" do
+  .. do something ..
+end<pre>
+              </div>
+            </body>
+          </html>
+          )
+        end
+
+        error do
+          @error = request.env['sinatra.error']
+          %Q(
+          <html>
+          	<body>
+          		<style type="text/css" media="screen">
+          			body {
+          				font-family: Verdana;
+          				color: #333;
+          			}
+
+          			#content {
+          				width: 700px;
+          				margin-left: 20px;
+          			}
+
+          			#content h1 {
+          				width: 99%;
+          				color: #1D6B8D;
+          				font-weight: bold;
+          			}
+
+          			#stacktrace {
+          			  margin-top: -20px;
+          			}
+
+          			#stacktrace pre {
+          				font-size: 12px;
+          				border-left: 2px solid #ddd;
+          				padding-left: 10px;
+          			}
+
+          			#stacktrace img {
+          				margin-top: 10px;
+          			}
+          		</style>
+          		<div id="content">
+            		<img src="/sinatra_custom_images/500.png" />
+            		<div class="info">
+                  Params: <pre>#{params.inspect}
+            		</div>
+          			<div id="stacktrace">
+          				<h1>#{Rack::Utils.escape_html(@error.class.name + ' - ' + @error.message)}</h1>
+          				<pre><code>#{Rack::Utils.escape_html(@error.backtrace.join("\n"))}</code></pre>
+          		</div>
+          	</body>
+          </html>
+          )
+        end
+      end
+    end
+  end
+  
+end
+
+def get(path, options ={}, &b)
+  Sinatra.application.define_event(:get, path, options, &b)
+end
+
+def post(path, options ={}, &b)
+  Sinatra.application.define_event(:post, path, options, &b)
+end
+
+def put(path, options ={}, &b)
+  Sinatra.application.define_event(:put, path, options, &b)
+end
+
+def delete(path, options ={}, &b)
+  Sinatra.application.define_event(:delete, path, options, &b)
+end
+
+def before(&b)
+  Sinatra.application.define_filter(:before, &b)
+end
+
+def helpers(&b)
+  Sinatra::EventContext.class_eval(&b)
+end
+
+def error(type = Sinatra::ServerError, options = {}, &b)
+  Sinatra.application.define_error(type, options, &b)
+end
+
+def not_found(options = {}, &b)
+  Sinatra.application.define_error(Sinatra::NotFound, options, &b)
+end
+
+def layout(name = :layout, &b)
+  Sinatra.application.define_template(name, &b)
+end
+
+def template(name, &b)
+  Sinatra.application.define_template(name, &b)
+end
+
+def use_in_file_templates!
+  require 'stringio'
+  templates = IO.read(caller.first.split(':').first).split('__FILE__').last
+  data = StringIO.new(templates)
+  current_template = nil
+  data.each do |line|
+    if line =~ /^##\s?(.*)/
+      current_template = $1.to_sym
+      Sinatra.application.templates[current_template] = ''
+    elsif current_template
+      Sinatra.application.templates[current_template] << line
+    end
+  end
+end
+
+def configures(*envs, &b)
+  yield if  !Sinatra.application.reloading && 
+            (envs.include?(Sinatra.application.options.env) ||
+            envs.empty?)
+end
+alias :configure :configures
+
+def set_options(opts)
+  Sinatra::Application.default_options.merge!(opts)
+  Sinatra.application.options = nil
+end
+
+def mime(ext, type)
+  Rack::File::MIME_TYPES[ext.to_s] = type
+end
+
+### Misc Core Extensions
+
+module Kernel
+
+  def silence_warnings
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+end
+
+class String
+
+  # Converts +self+ to an escaped URI parameter value
+  #   'Foo Bar'.to_param # => 'Foo%20Bar'
+  def to_param
+    URI.escape(self)
+  end
+  
+  # Converts +self+ from an escaped URI parameter value
+  #   'Foo%20Bar'.from_param # => 'Foo Bar'
+  def from_param
+    URI.unescape(self)
+  end
+  
+end
+
+class Hash
+  
+  def to_params
+    map { |k,v| "#{k}=#{URI.escape(v)}" }.join('&')
+  end
+  
+  def symbolize_keys
+    self.inject({}) { |h,(k,v)| h[k.to_sym] = v; h }
+  end
+  
+  def pass(*keys)
+    reject { |k,v| !keys.include?(k) }
+  end
+  
+end
+
+class Symbol
+  
+  def to_proc 
+    Proc.new { |*args| args.shift.__send__(self, *args) }
+  end
+  
+end
+
+class Array
+  
+  def to_hash
+    self.inject({}) { |h, (k, v)|  h[k] = v; h }
+  end
+  
+  def to_proc
+    Proc.new { |*args| args.shift.__send__(self[0], *(args + self[1..-1])) }
+  end
+  
+end
+
+module Enumerable
+  
+  def eject(&block)
+    find { |e| result = block[e] and break result }
+  end
+  
+end
+
+### Core Extension results for throw :halt
+
+class Proc
+  def to_result(cx, *args)
+    cx.instance_eval(&self)
+    args.shift.to_result(cx, *args)
+  end
+end
+
+class String
+  def to_result(cx, *args)
+    args.shift.to_result(cx, *args)
+    self
+  end
+end
+
+class Array
+  def to_result(cx, *args)
+    self.shift.to_result(cx, *self)
+  end
+end
+
+class Symbol
+  def to_result(cx, *args)
+    cx.send(self, *args)
+  end
+end
+
+class Fixnum
+  def to_result(cx, *args)
+    cx.status self
+    args.shift.to_result(cx, *args)
+  end
+end
+
+class NilClass
+  def to_result(cx, *args)
+    ''
+  end
+end
+
+at_exit do
+  raise $! if $!
+  if Sinatra.application.options.run
+    Sinatra.run 
+  end
+end
+
+mime :xml,  'application/xml'
+mime :js,  'application/javascript'

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: codebutler
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Markus Prinz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-04-04 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: coderay
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.7.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mongrel
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.0
+    version: 
+description: Simply run codebutler in a directory of your choice, and it will serve all the code files it supports on a local webserver, hilighted.
+email: markus.prinz@qsig.org
+executables: 
+- codebutler
+extensions: []
+
+extra_rdoc_files: 
+- bin/codebutler
+- lib/codebutler/sinatra.rb
+- lib/codebutler.rb
+- README
+files: 
+- bin/codebutler
+- lib/codebutler/sinatra.rb
+- lib/codebutler.rb
+- LICENCE
+- Manifest
+- README
+- codebutler.gemspec
+has_rdoc: true
+homepage: http://codebutler.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Codebutler
+- --main
+- README
+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: []
+
+rubyforge_project: codebutler
+rubygems_version: 1.1.0
+signing_key: 
+specification_version: 2
+summary: Easily serve your highlighted codefiles from a local webserver
+test_files: []
+