vintage 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2008-01-01
+
+* 1 major enhancement:
+  * Initial release

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Jeremy McAnally
+
+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.txt

@@ -0,0 +1,33 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/vintage
+config/hoe.rb
+config/requirements.rb
+lib/vintage.rb
+lib/vintage/version.rb
+lib/vintage/errors.rb
+lib/vintage/handler.rb
+lib/vintage/helpers.rb
+lib/vintage/log.rb
+lib/vintage/renderer.rb
+lib/vintage/request_context.rb
+lib/vintage/server.rb
+log/debug.log
+script/destroy
+script/generate
+setup.rb
+tasks/deployment.rake
+tasks/environment.rake
+tasks/website.rake
+test/test_helper.rb
+test/test_vintage.rb
+app_generators/vintage_application/USAGE
+app_generators/vintage_application/vintage_application_generator.rb
+app_generators/vintage_application/templates/configuration.yml
+app_generators/vintage_application/templates/index.erb
+app_generators/vintage_application/templates/README
+app_generators/vintage_application/templates/style.css
+app_generators/vintage_application/templates/vintage.png

data/README.txt

@@ -0,0 +1,40 @@
+= Vintage - The super slim, microwebframework of doom!
+
+Vintage is a very small web framework based on the original idea of Merb: Mongrel serving up
+ERb (Embedded Ruby) templates.  The idea has been expanded and now Vintage helps you serve up
+ERb, HAML, Textile, Markdown, and Markaby templates.
+
+== Basic Usage
+
+To use Vintage, you have two options.  You can use it in standard mode or application mode. In
+standard mode, there is no configuration and Vintage will serve up templates and static files 
+from the current folder.  To get this mode, then simply type <tt>vintage start</tt> in any folder.
+
+  $ vintage start
+  - vintage version 0.0.1
+	   starting server on port 5000
+
+Now navigating to a URL will look in the current folder for the file or template.  For example, going
+to <tt>http://localhost:5000/my_template</tt> will look for <tt>my_template.erb</tt> (or whatever template 
+engine you are using) in the current folder and render it if available.  If a static file is requested, then
+it is served up.  If you request <tt>http://localhost:5000/my_folder/my_template</tt>, then the application
+will look in <tt>my_folder</tt> for the <tt>my_template</tt> template.
+
+=== Vintage as an application server
+
+Vintage can also be configured to be used as an application server.  To do so, you can either generate an
+application or hand create a <tt>configuration.yml</tt> file (see one from a generated project for an example).
+To generate an application, simple run +vintage+ with a project name as the argument.
+
+  vintage my_project
+  
+This command will generate a number of files.  Chief among these is <tt>configuration.yml</tt> which tells
+Vintage how you'd like to run it.  Other files include a sample template and the proper folder structure
+for the generated configuration to work properly.  This setup allows you to more easily segment your code
+for easier maintenance.
+
+== Helpers
+
+Vintage comes with a few helpers that live in Vintage::Helpers.  You can add your own helpers by creating a
+<tt>helpers</tt> folder and stashing modules in there.  As of right now, helpers must live in the Vintage::Helpers
+module, but this will hopefully be changing very soon.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/app_generators/vintage_application/USAGE

@@ -0,0 +1,5 @@
+Description:
+  
+  
+Usage:
+  

data/app_generators/vintage_application/templates/README

@@ -0,0 +1,6 @@
+Vintage - The super slim web framework for men and women
+========================================================
+
+Vintage is a very small web framework based on the original idea of Merb: Mongrel serving up
+ERb (Embedded Ruby) templates.  The idea has been expanded and now Vintage helps you serve up
+ERb, HAML, Textile, Markdown, and Markaby templates.

data/app_generators/vintage_application/templates/configuration.yml

@@ -0,0 +1,17 @@
+--- 
+# Path for static files
+:static_path: static/
+# Path for application templates
+:path: app/
+# Templating engine to use
+:templates: erb
+# Port to launch server on
+:port: 5000
+# Relative URL to mount application on
+:mount: /
+# Default template to render on root
+:root: index
+# You can also define error templates
+# :errors:
+#   :not_found: not_found
+#   :internal_error: internal_error

data/app_generators/vintage_application/templates/index.erb

@@ -0,0 +1,29 @@
+<html>
+  <head>
+    <title>
+      Welcome to Vintage
+    </title>
+    <link rel="stylesheet" href="style.css" />
+  </head>
+  <body>
+    <img src="vintage.png" />
+    <h1>Welcome to Vintage</h1>
+    <p>
+      Come on in and relax.  Actually, don't relax.  Build something.
+    </p>
+    <div>
+      <h2>Request Information</h2>  
+      <ul>
+        <li>Remote IP: <%= request.remote_ip %></li>
+        <li>Referer: <%= request.referer %></li>
+        <li>Requested URI: <%= request.uri %></li>
+        <li>Request method: <%= request.method %></li>
+        <li>User agent: <%= request.user_agent %></li>
+        <li>Query string: <%= request.query_string %></li>
+        <li>Parameters: <%= request.params == {} ? "None" : request.params.to_a.map{|k,v| "#{k} = #{v}"}.join(", ") %></li>
+      </ul>
+    </div>
+    <br />
+    <%= link_to "Vintage homepage", "http://vintage.rubyforge.org" %>
+  </body>
+</html>

data/app_generators/vintage_application/templates/style.css

@@ -0,0 +1,8 @@
+BODY { background: #3E2B09; text-align: center; font-family: sans-serif; }
+h1 { color: white; }
+p { color: #ccd69f; }
+div { background: #ccd69f; color: black; width: 450px; padding: 10px; margin: auto; border: 2px solid #aab47d;}
+div h2 { font-size: 14pt; color: #33400a; margin: 0px; }
+div ul { list-style-type: none; }
+div ul li { padding: 0px; margin: 8px 0px; text-align: left; }
+A { color: white; }

data/app_generators/vintage_application/vintage_application_generator.rb

@@ -0,0 +1,71 @@
+class VintageApplicationGenerator < RubiGen::Base
+  
+  DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
+                              Config::CONFIG['ruby_install_name'])
+  
+  default_options :author => nil
+  
+  attr_reader :name
+  
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @destination_root = File.expand_path(args.shift)
+    @name = base_name
+    extract_options
+  end
+
+  def manifest
+    record do |m|
+      # Ensure appropriate folder(s) exists
+      m.directory ''
+      BASEDIRS.each { |path| m.directory path }
+
+      m.file "configuration.yml", "configuration.yml"
+      m.file "README", "README"
+      m.file "index.erb", "app/index.erb"
+      m.file "vintage.png", "static/vintage.png"
+      m.file "style.css", "static/style.css"
+      
+      # m.dependency "install_rubigen_scripts", [destination_root, 'vintage_application'], 
+      #   :shebang => options[:shebang], :collision => :force
+    end
+  end
+
+  protected
+    def banner
+      <<-EOS
+Creates a ...
+
+USAGE: #{spec.name} name"
+EOS
+    end
+
+    def add_options!(opts)
+      opts.separator ''
+      opts.separator 'Options:'
+      # For each option below, place the default
+      # at the top of the file next to "default_options"
+      # opts.on("-a", "--author=\"Your Name\"", String,
+      #         "Some comment about this option",
+      #         "Default: none") { |options[:author]| }
+      opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+    end
+    
+    def extract_options
+      # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+      # Templates can access these value via the attr_reader-generated methods, but not the
+      # raw instance variable value.
+      # @author = options[:author]
+    end
+
+    # Installation skeleton.  Intermediate directories are automatically
+    # created so don't sweat their absence here.
+    BASEDIRS = %w(
+      app
+      static
+      helpers
+      test
+      tmp
+    )
+end

data/bin/vintage

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+#
+#  Created by Jeremy McAnally on 2008-1-1.
+#  Copyright (c) 2008. All rights reserved.
+
+$:.unshift File.dirname(__FILE__)
+require File.dirname(__FILE__) + '/../lib/vintage'
+
+require 'rubygems'
+require 'optparse'
+require 'rubigen'
+
+# NOTE: the option -p/--path= is given as an example, and should probably be replaced in your application.
+
+OPTIONS = {
+  :path         => Dir.pwd,
+  :static_path  => Dir.pwd,
+  :port         => 5000,
+  :config       => 'configuration.yml',
+  :templates    => 'erb',
+  :mount        => '/',
+  :root         => 'index'
+}
+MANDATORY_OPTIONS = %w(  )
+
+parser = OptionParser.new do |opts|
+  opts.banner = <<BANNER
+  
+Vintage - v.#{Vintage::VERSION::STRING}
+=================
+The super-micro web framework.  If a project name is provided,
+a new project is generated.  Otherwise, Vintage will start serving
+given the defaults and/or any provided options.
+
+Usage: #{File.basename($0)} [options]
+       #{File.basename($0)} [project name]
+
+Options are:
+BANNER
+  opts.separator ""
+  opts.on("-p", "--path=PATH", String,
+          "The root path for selecting files",
+          "Default: ~") { |OPTIONS[:path]| }
+  opts.on("-P", "--port=PORT", Integer,
+          "The port to serve up your Vintage application on",
+          "Default: 5000") { |OPTIONS[:port]| }
+  opts.on("-c", "--config=FILE", String,
+          "The configuration file to use when launching this Vintage application",
+          "Default: configuration.rb") { |OPTIONS[:config]| } 
+  opts.on("-t", "--template=TYPE", String,
+          "The parser used for templates (can be erb, haml, mab, markdown, or textile)",
+          "Default: erb") { |OPTIONS[:templates]| }
+  opts.on("-m", "--mount-at=url", String,
+          "The relative URL to mount this application at (e.g., vintage -m myapp will mount at http://localhost/myapp)",
+          "Default: none (mounted at /)") { |OPTIONS[:mount]| }
+  opts.on("-r", "--root=template", String,
+          "The template to render at the root URL",
+          "Default: index") { |OPTIONS[:root]| }
+  opts.on("-h", "--help",
+          "Show this help message.") { puts opts; exit }
+  opts.parse!(ARGV)
+end
+
+if ARGV.empty?
+  puts parser
+  puts
+elsif ARGV[0] == "start"
+  OPTIONS.merge!(YAML::load_file(OPTIONS[:config])) if File.exists?(OPTIONS[:config])
+  Vintage::Server.run(OPTIONS)
+else
+  require 'rubigen/scripts/generate'
+  source = RubiGen::PathSource.new(:application, File.join(File.dirname(__FILE__), "../app_generators"))
+  RubiGen::Base.reset_sources
+  RubiGen::Base.append_sources source
+  RubiGen::Scripts::Generate.new.run(ARGV, :generator => 'vintage_application')
+end

data/config/hoe.rb

@@ -0,0 +1,72 @@
+require 'vintage/version'
+
+AUTHOR = 'Jeremy McAnally'  # can also be an array of Authors
+EMAIL = "jeremymcanally@gmail.com"
+DESCRIPTION = "A super simple web framework"
+GEM_NAME = 'vintage' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'vintage' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "unknown"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil 
+# UNCOMMENT IF REQUIRED: 
+# REV = `svn info`.each {|line| if line =~ /^Revision:/ then k,v = line.split(': '); break v.chomp; else next; end} rescue nil
+VERS = Vintage::VERSION::STRING + (REV ? ".#{REV}" : "")
+VERSION = VERS
+RDOC_OPTS = ['--quiet', '--title', 'vintage documentation',
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' } 
+    @extra_deps
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  #p.extra_deps = []     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
+  
+  #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  
+end
+
+CHANGES = hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+hoe.rsync_args = '-av --delete --ignore-errors'

data/config/requirements.rb

@@ -0,0 +1,17 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))
+
+require 'vintage'

data/lib/vintage/errors.rb

@@ -0,0 +1,76 @@
+module Vintage
+  # A class to render the default error pages.  These will
+  # not render if error pages are specified in the configuration.
+  class ErrorReporter
+    # Standard template to render for a <tt>500 Internal Server Error</tt>
+    def self.internal_error(error, params)
+      """
+      <html>
+        <head>
+          <title>Vintage Error: 500 Internal Server Error</title>
+          <style>
+            body { margin: 0px; padding: 0px; font-family: sans-serif; }
+            h1 { background: #3E2B09; padding: 45px 10px 10px 10px; color: #6F5E3C;  border: 0px; border-bottom: 2px solid #1C0907; margin: 0px; }
+            h1 span.error { text-shadow: 0.1em 0.1em #333; color: white; }
+            h2 { margin: 0px; padding: 5px 5px 10px 10px; font-size: 14pt !important; }
+            h2 span.where { color: #999; }
+            h3 { margin: 0px; padding: 10px 10px; color: #999;}
+            ul { margin: 0px; }
+            li { margin: 0px; padding: 0px 30px; }
+            pre { padding: 0 30px; margin: 0px; }
+          </style>
+        </head>
+
+        <body>
+          <h1><span class='error'>#{error.class}</span> 500 Internal Server Error</h1>
+          <h2>#{error.message} <span class='where'>at #{error.backtrace[0]}</span></h2>
+          <div>
+            <h3>Parameters</h3>
+            <ul>
+              #{params == {} ? "None" : params.to_a.map{|key, val| "<li><b>" + key.to_s + "<b> = " + val.to_s + "</li>"}.join("\n") }
+            </ul>
+            <br />
+            <h3>Backtrace</h3>
+            <pre>#{error.backtrace.join("\n")}</pre>
+          </div>
+        </body>
+      </html>
+      
+      """
+    end
+    
+    # Standard template to render for a <tt>404 Page Not Found</tt> error
+    def self.not_found(url, remote_ip, params)
+      """
+      <html>
+        <head>
+          <title>Vintage Error: 404 Page Not Found</title>
+          <style>
+            body { margin: 0px; padding: 0px; font-family: sans-serif; }
+            h1 { background: #3E2B09; padding: 45px 10px 10px 10px; color: #6F5E3C;  border: 0px; border-bottom: 2px solid #1C0907; margin: 0px; }
+            h1 span.error { text-shadow: 0.1em 0.1em #333; color: white; }
+            h2 { margin: 0px; padding: 5px 5px 10px 10px; font-size: 14pt !important; }
+            h2 span.where { color: #999; }
+            h3 { margin: 0px; padding: 10px 10px; color: #999;}
+            ul { margin: 0px; }
+            li { margin: 0px; padding: 0px 30px; }
+            pre { padding: 0 30px; margin: 0px; }
+          </style>
+        </head>
+
+        <body>
+          <h1><span class='error'>Page Not Found</span> 404 Not Found</h1>
+          <h2>Request for #{url} <span class='where'>from #{remote_ip}</span></h2>
+          <div>
+            <h3>Parameters</h3>
+            <ul>
+              #{params == {} ? "None" : params.to_a.map{|key, val| "<li><b>" + key.to_s + "<b> = " + val.to_s + "</li>"}.join("\n") }
+            </ul>
+          </div>
+        </body>
+      </html>
+      
+      """
+    end
+  end
+end

data/lib/vintage/handler.rb

@@ -0,0 +1,121 @@
+require 'rubygems'
+require 'mongrel'
+require 'erubis'
+require 'erb'
+require 'mime/types'
+
+require 'vintage/renderer'
+require 'vintage/request_context'
+require 'vintage/errors'
+
+module Vintage
+  # The Mongrel HTTP Handler.  Handles all operations with requests.
+  class Handler < Mongrel::HttpHandler    
+    def initialize(options)
+      # Make our configuration options avialable to the handler
+      @options = options
+      
+      # Setup a DirHandler for sending static files securely
+      @static_handler = Mongrel::DirHandler.new(@options[:static_path], false, nil)
+      
+      # Inject our helpers in the RequestContext class to make them
+      # available on each request.
+      include_helpers
+    end
+  
+    # Main request handler for Mongrel.
+    def process(request, response)
+      # Parse params into a nice Hash
+      handle_params(request.params["QUERY_STRING"])
+      
+      # Setup our request's path
+      @request_path = request.params["PATH_INFO"]
+      
+      # Setup up the request's context (response and request information)
+      context = RequestContext.new(request, @params, {})
+      
+      # Initialize the buffered log entry
+      log_entry = ""
+      log_entry << "*** request for [#{request.params['REQUEST_URI']}] from [#{request.params['REMOTE_ADDR']}]\n"
+
+      # If it's a root request, we want to render the template we configured
+      @request_path = @options[:root] if @request_path == '/'
+      
+      # If it's a static file we don't need to append a file extension
+      filename = (@request_path =~ /\.(.*)$/) ? "#{@options[:static_path]}/#{@request_path}" : "#{@options[:path]}/#{@request_path}.#{@options[:templates]}"
+      
+      # Does the file exist...?
+      if File.exists?(filename)
+        # It's found!  Let's add to our log entry...
+        log_entry << "    response: [200]\n"
+        log_entry << "    rendering [#{@request_path}]\n"
+
+        # Is it a static file?
+        if (@request_path =~ /\.(.*)$/)
+          # Yes?  Let our static handler take it away!
+          @static_handler.process(request, response)
+        else
+          # No!  Render a template...
+          content = Renderer.send(@options[:templates].to_sym, File.open("#{@options[:path]}#{@request_path}.#{@options[:templates]}", "r").read, context)
+        end
+        
+        # Render (if response is 200) or redirect
+        response.start(context.response.code) do |head, out|
+          # Add any custom headers (e.g., from redirect_to)
+          context.response.headers.each do |k,v|
+            head[k] = v
+          end
+          
+          # Set the content type if we're responding with a render
+          head["Content-Type"] = "text/html" if context.response.code == 200
+          
+          # Write out to the response
+          out.write content
+        end
+      else
+        # Page not found
+        response.start(404) do |head, out|
+          # Log the 404
+          log_entry << "    response: [404]\n"
+          log_entry << "    rendering 'page not found'\n"
+          
+          # Send back the default or a custom template
+          head["Content-Type"] = "text/html"
+          out.write @options[:errors] && @options[:errors][:not_found] ? Renderer.send(@options[:templates].to_sym, File.open("#{@options[:path]}#{@options[:errors][:not_found]}.#{@options[:templates]}", "r").read, context) : ErrorReporter.not_found(@request_path, request.params['REMOTE_ADDR'], @params)
+        end
+      end
+    rescue StandardError => err
+      # OOPS!  Something broke.
+      response.start(500) do |head, out|
+        # Log it and send an error page...
+        log_entry << "\t!!! [500] #{err}\n"
+        head["Content-Type"] = "text/html"
+        out.write @options[:errors] && @options[:errors][:internal_error] ? Renderer.send(@options[:templates].to_sym, File.open("#{@options[:path]}#{@options[:errors][:internal_error]}.#{@options[:templates]}", "r").read, context) : ErrorReporter.internal_error(err, @params)
+      end
+    ensure
+      # After every request push the buffered log entry out to the logger
+      Log.enter log_entry.to_s + "\n"
+    end
+    
+    # Parse HTTP params into a +Hash+.
+    def handle_params(params)
+      @params = {}
+      
+      unless params == nil || params == ''
+        # Split the query string and hack it up
+        params.split('&').each do |param|
+          key, val = param.split('=')
+
+          @params[key.to_sym] = val
+        end
+      end
+    end
+    
+    # Inject the default helpers and helpers from the 
+    # +helpers/+ directory (if available) into the 
+    # RequestContext class.
+    def include_helpers
+      RequestContext.send(:include, Vintage::Helpers)
+    end
+  end
+end