mattt-staticmatic 0.10.1

data/History.txt

@@ -0,0 +1,6 @@
+== 0.10.0 2009-01-01
+
+* Refactoring for forthcoming improvements
+* Improved Error Reporting
+	* More useful error pages
+	* Removed Haml specific error handling

data/Manifest.txt

@@ -0,0 +1,24 @@
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+bin/staticmatic
+lib/staticmatic.rb
+lib/staticmatic/base.rb
+lib/staticmatic/configuration.rb
+lib/staticmatic/error.rb
+lib/staticmatic/helpers.rb
+lib/staticmatic/mixins/build.rb
+lib/staticmatic/mixins/helpers.rb
+lib/staticmatic/mixins/render.rb
+lib/staticmatic/mixins/server.rb
+lib/staticmatic/mixins/setup.rb
+lib/staticmatic/server.rb
+lib/staticmatic/templates/default/application.haml
+lib/staticmatic/templates/default/application.sass
+lib/staticmatic/templates/default/index.haml
+lib/staticmatic/templates/default/index.haml
+lib/staticmatic/templates/rescues/default.haml
+lib/staticmatic/templates/rescues/template.haml
+lib/staticmatic/template_error.rb
+lib/staticmatic/mixins/rescue.rb

data/README.markdown

@@ -0,0 +1,50 @@
+# StaticMatic
+
+*For information on Haml & Sass please see [haml.hamptoncatlin.com](http://haml.hamptoncatlin.com)*.
+
+## What's it all about?
+
+CMS is overrated.  A lot of the time, clients want us to do what we do 
+best - well designed pages with structured, accessible and maintainable markup & styling.
+
+CMSs are often perfect for this, but sometimes they can be restrictive and more cumbersome
+than just working with good ol' source code.  At the same time we want our code to be
+structured, DRY and flexible.
+
+Enter **StaticMatic**.
+
+## Usage
+
+StaticMatic will set up a basic site structure for you with this command:
+
+    staticmatic setup <directory>
+
+After this command you'll have the following files:
+
+    <directory>/
+      site/
+        images/
+        stylesheets/
+        javascripts/
+      src/
+        helpers/
+        layouts/
+          application.haml
+        pages/
+          index.haml
+        stylesheets/
+          application.sass
+
+StaticMatic sets you up with a sample layout, stylesheet and page file.  Once you've
+edited the pages and stylesheets, you can generate the static site:
+
+    staticmatic build <directory>
+    
+All of the pages are parsed and wrapped up in application.haml and put into the site directory.
+
+## Templates
+
+StaticMatic adds a few helpers to the core Haml helpers:
+
+    = link 'Title', 'url'
+    = img 'my_image.jpg'

data/Rakefile

@@ -0,0 +1,31 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen hoe].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/staticmatic'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('staticmatic', StaticMatic::VERSION) do |p|
+  p.developer('Stephen Bartholomew', 'steve@curve21.com')
+  p.rubyforge_name       = p.name 
+  p.extra_deps         = [
+    ['haml','>= 2.0'],
+    ['mongrel','>= 1.0']
+  ]
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+
+desc "Run all unit tests"
+Rake::TestTask.new(:test) do |t|
+  t.test_files = Dir.glob("test/*_test.rb")
+  t.verbose = true
+end

data/bin/staticmatic

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/staticmatic'
+
+command = ARGV[0]
+directory = ARGV[1]
+
+if !command || !directory
+  puts "Usage: #{$0} <build|setup|preview> <directory>"
+  exit
+end
+
+configuration = StaticMatic::Configuration.new
+
+config_file = "#{directory}/src/configuration.rb"
+
+if File.exists?(config_file)
+  config = File.read(config_file)
+  eval(config)
+end
+
+staticmatic = StaticMatic::Base.new(directory, configuration)
+staticmatic.run(command)

data/lib/staticmatic.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'haml'
+require 'sass'
+require 'mongrel'
+require 'fileutils'
+
+module StaticMatic
+  VERSION = '0.10.1'
+end
+
+["render", "build", "setup", "server", "helpers", "rescue"].each do |mixin|
+  require File.join(File.dirname(__FILE__), "staticmatic", "mixins", mixin)
+end
+
+["base", "configuration", "error", "server", "helpers", "template_error"].each do |lib|
+  require File.join(File.dirname(__FILE__), "staticmatic", lib)
+end
+
+Haml::Helpers.class_eval("include StaticMatic::Helpers")
+

data/lib/staticmatic/base.rb

@@ -0,0 +1,87 @@
+module StaticMatic
+  # Directories generated for a new site setup
+  BASE_DIRS = %w{
+    site/
+    site/stylesheets
+    site/images
+    site/javascripts
+    src/
+    src/pages/
+    src/layouts
+    src/stylesheets
+    src/helpers
+  }
+
+  # Templates for setup and their location
+  TEMPLATES = {
+    'application.haml' => 'layouts',
+    'application.sass' => 'stylesheets',
+    'index.haml' => 'pages'
+  }
+  
+  class Base
+    
+    include StaticMatic::RenderMixin
+    include StaticMatic::BuildMixin
+    include StaticMatic::SetupMixin
+    include StaticMatic::HelpersMixin    
+    include StaticMatic::ServerMixin    
+    include StaticMatic::RescueMixin    
+  
+    attr_accessor :configuration
+    attr_reader :current_page, :src_dir, :site_dir
+
+    def current_file
+      @current_file_stack[0] || ""
+    end
+    
+    def initialize(base_dir, configuration = Configuration.new)
+      @configuration = configuration
+      @current_page = nil
+      @current_file_stack = []
+      @base_dir = base_dir
+      @src_dir = "#{@base_dir}/src"
+      @site_dir = "#{@base_dir}/site"
+      @templates_dir = File.dirname(__FILE__) + '/templates/default/'
+      @layout = "application"
+      @scope = Object.new
+      @scope.instance_variable_set("@staticmatic", self)
+      load_helpers
+    end
+    
+    def base_dir
+      @base_dir
+    end
+  
+    def run(command)
+      if %w(build setup preview).include?(command)
+        send(command)
+      else
+        puts "#{command} is not a valid StaticMatic command"
+      end
+    end
+      
+    # TODO: DRY this _exists? section up
+    def template_exists?(name, dir = '')
+      File.exists?(File.join(@src_dir, 'pages', dir, "#{name}.haml")) || File.exists?(File.join(@src_dir, 'stylesheets', "#{name}.sass"))
+    end
+    
+    def layout_exists?(name)
+      File.exists? full_layout_path(name)
+    end
+    
+    def template_directory?(path)
+      File.directory?(File.join(@src_dir, 'pages', path))
+    end
+    
+    def full_layout_path(name)
+      "#{@src_dir}/layouts/#{name}.haml"
+    end
+    
+    class << self
+      def base_dirs
+        StaticMatic::BASE_DIRS
+      end
+    end
+  end
+end

data/lib/staticmatic/configuration.rb

@@ -0,0 +1,16 @@
+module StaticMatic
+  class Configuration
+    attr_accessor :preview_server_port
+
+    attr_accessor :preview_server_host
+    
+    attr_accessor :use_extensions_for_page_links
+    attr_accessor :sass_options
+
+    def initialize
+      self.preview_server_port = 3000
+      self.use_extensions_for_page_links = true
+      self.sass_options = {}
+    end
+  end
+end

data/lib/staticmatic/error.rb

@@ -0,0 +1,17 @@
+module StaticMatic
+  class Error < StandardError
+    attr_reader :line
+
+    attr_reader :filename
+    
+    def initialize(lineno, filename, message)
+      @line = lineno
+      @filename = filename
+      @message = message
+    end
+    
+    def message
+      "#{@filename}, line #{@line}: #{@message}"
+    end
+  end
+end

data/lib/staticmatic/helpers.rb

@@ -0,0 +1,197 @@
+module StaticMatic
+  module Helpers
+    self.extend self
+    
+    # Generates links to all stylesheets in the source directory
+    # = stylesheets
+    # or specific stylesheets in a specific order
+    # = stylesheets :reset, :application
+    # Can also pass options hash in at the end so you can specify :media => :print
+    def stylesheets(*params)
+      options = {}
+      if params.last.is_a?(Hash)
+        options = params.last
+        params.slice!(-1, 1)
+      end
+      options[:media] = 'all' unless options.has_key?(:media)
+      options[:rel] = 'stylesheet'; options[:type] = 'text/css'
+
+      relative_path = current_page_relative_path
+
+      output = ""
+      if params.length == 0
+        # no specific files requested so include all in no particular order
+        stylesheet_dir = File.join(@staticmatic.src_dir, 'stylesheets')
+        stylesheet_directories = Dir[File.join(stylesheet_dir, '**','*.sass')]
+        
+        # Bit of a hack here - adds any stylesheets that exist in the site/ dir that haven't been generated from source sass
+        Dir[File.join(@staticmatic.site_dir, 'stylesheets', '*.css')].each do |filename|
+          search_filename = File.basename(filename).chomp(File.extname(filename))
+
+          already_included = false
+          stylesheet_directories.each do |path|
+            if File.basename(path).include?(search_filename)
+              already_included = true
+              break
+            end
+          end
+          
+          stylesheet_directories << filename unless already_included
+        end
+
+        stylesheet_directories.each do |path|
+          filename_without_extension = File.basename(path).chomp(File.extname(path))
+
+          options[:href] = "#{relative_path}stylesheets/#{filename_without_extension}.css"
+          output << tag(:link, options)
+        end
+      else
+        #specific files requested and in a specific order
+        params.each do |file|
+          if File.exist?(File.join(@staticmatic.src_dir, 'stylesheets', "#{file}.sass")) ||
+             File.exist?(File.join(@staticmatic.site_dir, 'stylesheets', "#{file}.css"))
+            options[:href] = "#{relative_path}stylesheets/#{file}.css"
+            output << tag(:link, options)
+          end
+        end
+      end
+      
+      output
+    end
+    
+    # Generate javascript source tags for the specified files
+    #
+    # javascripts('test')   ->   <script language="javascript" src="javascripts/test.js"></script>
+    #    
+    def javascripts(*files)
+      relative_path = current_page_relative_path
+
+      output = ""
+      files.each do |file|
+        file_str = file.to_s
+        src = file_str.match(%r{^((\.\.?)?/|https?://)}) ? file_str : "#{relative_path}javascripts/#{file_str}.js"
+        output << tag(:script, :language => 'javascript', :src => src, :type => "text/javascript") { "" }
+      end
+      output
+    end
+
+    # Generates a form text field
+    #
+    def text_field(name, value, options = {})
+      options.merge!(:type => "text", :name => name, :value => value)
+      tag(:input, options)
+    end
+    
+    # Generate a form textarea
+    #
+    def text_area(name, value, options = {})
+      options.merge!(:name => name)
+      tag(:textarea, options) { value }
+    end
+    
+    # Generate an HTML link
+    #
+    # If only the title is passed, it will automatically
+    # create a link from this value:
+    #
+    # link('Test')  ->  <a href="test.html">Test</a>
+    #
+    def link(title, href = "", options = {})
+      if href.is_a?(Hash)
+        options = href
+        href = ""
+      end
+
+      if href.nil? || href.strip.length < 1
+        path_prefix = ''
+        if title.match(/^(\.\.?)?\//)
+          # starts with relative path so strip it off and prepend it to the urlified title
+          path_prefix_match = title.match(/^[^\s]*\//)
+          path_prefix = path_prefix_match[0] if path_prefix_match
+          title = title[path_prefix.length, title.length]
+        end
+        href = path_prefix + urlify(title) + ".html"
+      end
+
+      options[:href] = "#{current_page_relative_path(href)}#{href}"
+      
+      local_page = (options[:href].match(/^(\#|.+?\:)/) == nil)
+      unless @staticmatic.configuration.use_extensions_for_page_links || !local_page
+        options[:href].chomp!(".html")
+        options[:href].chomp!("index") if options[:href][-5, 5] == 'index'
+      end
+
+      tag(:a, options) { title }
+    end
+    alias link_to link
+
+    # Generates an image tag always relative to the current page unless absolute path or http url specified.
+    # 
+    # img('test_image.gif')   ->   <img src="/images/test_image.gif" alt="Test image"/>
+    # img('contact/test_image.gif')   ->   <img src="/images/contact/test_image.gif" alt="Test image"/>
+    # img('http://localhost/test_image.gif')   ->   <img src="http://localhost/test_image.gif" alt="Test image"/>
+    def img(name, options = {})
+      options[:src] = name.match(%r{^((\.\.?)?/|https?://)}) ? name : "#{current_page_relative_path}images/#{name}"
+      options[:alt] ||= name.split('/').last.split('.').first.capitalize.gsub(/_|-/, ' ')
+      tag :img, options
+    end
+  
+    # Generates HTML tags:
+    #
+    # tag(:br)   ->   <br/>
+    # tag(:a, :href => 'test.html') { "Test" }    ->    <a href="test.html">Test</a>
+    #
+    def tag(name, options = {}, &block)
+      options[:id] ||= options[:name] if options[:name]
+      output = "<#{name}"
+      options.keys.sort { |a, b| a.to_s <=> b.to_s }.each do |key|
+        output << " #{key}=\"#{options[key]}\"" if options[key]
+      end
+      
+      if block_given?
+        output << ">"
+        output << yield
+        output << "</#{name}>"
+      else
+        output << "/>"
+      end
+      output
+    end
+    
+    # Generates a URL friendly string from the value passed:
+    #
+    # "We love Haml"  ->  "we_love_haml"
+    # "Elf & Ham"     ->  "elf_and_ham"
+    # "Stephen's gem" ->  "stephens_gem"
+    #
+    def urlify(string)
+      string.tr(" ", "_").
+             sub("&", "and").
+             sub("@", "at").
+             tr("^A-Za-z0-9_", "").
+             sub(/_{2,}/, "_").
+             downcase
+    end
+    
+    # Include a partial template
+    def partial(name, options = {})
+      @staticmatic.generate_partial(name, options)
+    end
+
+    def current_page
+      @staticmatic.current_page
+    end
+
+    private
+
+    def current_page_relative_path(current_path = nil)
+      if current_path.nil? || current_path.match(/^((\.\.?)?\/|\#|.+?\:)/) == nil
+        current_page_depth = current_page.split('/').length - 2;
+        (current_page_depth > 0) ? ([ '..' ] * current_page_depth).join('/') + '/' : ''
+      else
+        ''
+      end
+    end
+
+  end
+end

data/lib/staticmatic/mixins/build.rb

@@ -0,0 +1,46 @@
+module StaticMatic::BuildMixin
+    
+  def build
+    build_css
+    build_html
+  end
+    
+  # Build HTML from the source files
+  def build_html
+    Dir["#{@src_dir}/pages/**/*.haml"].each do |path|
+      next if File.basename(path) =~ /^\_/  # skip partials
+      file_dir, template = source_template_from_path(path.sub(/^#{@src_dir}\/pages/, ''))
+      save_page(File.join(file_dir, template), generate_html_with_layout(template, file_dir))
+    end
+  end
+
+  # Build CSS from the source files
+  def build_css
+    Dir["#{@src_dir}/stylesheets/**/*.sass"].each do |path|
+      file_dir, template = source_template_from_path(path.sub(/^#{@src_dir}\/stylesheets/, ''))
+      save_stylesheet(File.join(file_dir, template), generate_css(template, file_dir))
+    end
+  end
+  
+  def copy_file(from, to)
+    FileUtils.cp(from, to)
+  end
+
+  def save_page(filename, content)
+    generate_site_file(filename, 'html', content)
+  end
+
+  def save_stylesheet(filename, content)
+    generate_site_file(File.join('stylesheets', filename), 'css', content)
+  end
+
+  def generate_site_file(filename, extension, content)
+    path = File.join(@site_dir,"#{filename}.#{extension}")
+    FileUtils.mkdir_p(File.dirname(path))
+    File.open(path, 'w+') do |f|
+      f << content
+    end
+    
+    puts "created #{path}"
+  end
+end

data/lib/staticmatic/mixins/helpers.rb

@@ -0,0 +1,15 @@
+module StaticMatic::HelpersMixin    
+  # Loads any helpers present in the helpers dir and mixes them into the template helpers
+  def load_helpers
+
+    Dir["#{@src_dir}/helpers/**/*_helper.rb"].each do |helper|
+      load_helper(helper)
+    end
+  end
+
+  def load_helper(helper)
+    load helper
+    module_name = File.basename(helper, '.rb').gsub(/(^|\_)./) { |c| c.upcase }.gsub(/\_/, '')
+    Haml::Helpers.class_eval("include #{module_name}")
+  end
+end

data/lib/staticmatic/mixins/render.rb

@@ -0,0 +1,125 @@
+module StaticMatic::RenderMixin
+  
+  def source_for_layout
+    if layout_exists?(@layout)
+      File.read(full_layout_path(@layout))
+    else
+      raise StaticMatic::Error.new("", full_layout_path(@layout), "Layout not found")
+    end
+  end
+
+  # Generate html from source file:
+  # generate_html("index")
+  def generate_html(source_file, source_dir = '')
+    full_file_path = File.join(@src_dir, 'pages', source_dir, "#{source_file}.haml")
+
+    begin
+      # clear all scope variables except @staticmatic
+      @scope.instance_variables.each do |var|
+        @scope.instance_variable_set(var, nil) unless var == '@staticmatic' 
+      end
+      html = generate_html_from_template_source(File.read(full_file_path))
+  
+      @layout = determine_layout(source_dir)
+    rescue StaticMatic::TemplateError => e
+      raise e # re-raise inline errors
+    rescue Exception => e
+      raise StaticMatic::TemplateError.new(full_file_path, e)
+    end
+
+    html
+  end
+
+  def generate_html_with_layout(source, source_dir = '')
+    @current_page = File.join(source_dir, "#{source}.html")
+    @current_file_stack.unshift(File.join(source_dir, "#{source}.haml"))
+    begin 
+      template_content = generate_html(source, source_dir)
+      @layout = determine_layout(source_dir)
+      generate_html_from_template_source(source_for_layout) { template_content }
+    rescue Exception => e
+      render_rescue_from_error(e)
+    ensure
+      @current_page = nil
+      @current_file_stack.shift
+    end
+  end
+
+  def generate_partial(name, options = {})
+    partial_dir, partial_name = File.dirname(self.current_file), name  # default relative to current file
+    partial_dir, partial_name = File.split(name) if name.index('/') # contains a path so it's absolute from src/pages dir
+    partial_name = "_#{partial_name}.haml"
+
+    partial_path = File.join(@src_dir, 'pages', partial_dir, partial_name)
+    unless File.exists?(partial_path)
+      # couldn't find it in the pages subdirectory tree so try old way (ignoring the path)
+      partial_dir = 'partials'
+      partial_name = "#{File.basename(name)}.haml"
+      partial_path = File.join(@src_dir, partial_dir, partial_name)
+    end
+  
+    if File.exists?(partial_path)
+      partial_rel_path = "/#{partial_dir}/#{partial_name}".gsub(/\/+/, '/')
+      @current_file_stack.unshift(partial_rel_path)
+      begin
+        generate_html_from_template_source(File.read(partial_path), options)
+      rescue Exception => e
+        raise StaticMatic::TemplateError.new(partial_path, e)
+      ensure
+        @current_file_stack.shift
+      end
+    else
+      raise StaticMatic::Error.new("", name, "Partial not found")
+    end
+  end
+
+  def generate_css(source, source_dir = '')
+    full_file_path = File.join(@src_dir, 'stylesheets', source_dir, "#{source}.sass")
+    begin
+      sass_options = { :load_paths => [ File.join(@src_dir, 'stylesheets') ] }.merge(self.configuration.sass_options)
+      stylesheet = Sass::Engine.new(File.read(full_file_path), sass_options)
+      stylesheet.to_css
+    rescue Exception => e
+      render_rescue_from_error(StaticMatic::TemplateError.new(full_file_path, e))
+    end
+  end
+
+  # Generates html from the passed source string
+  #
+  # generate_html_from_template_source("%h1 Welcome to My Site") -> "<h1>Welcome to My Site</h1>"
+  #
+  # Pass a block containing a string to yield within in the passed source:
+  #
+  # generate_html_from_template_source("content:\n= yield") { "blah" } -> "content: blah"
+  #
+  def generate_html_from_template_source(source, options = {})
+    html = Haml::Engine.new(source, self.configuration.haml_options.merge(options))
+    
+    html.render(@scope, options) { yield }
+  end
+
+  def determine_layout(dir = '')
+    layout_name = "application"
+  
+    if @scope.instance_variable_get("@layout")
+      layout_name = @scope.instance_variable_get("@layout")
+    elsif dir
+      dirs = dir.split("/")
+      dir_layout_name = dirs[1]
+    
+      if layout_exists?(dir_layout_name)
+        layout_name = dir_layout_name
+      end
+    end
+
+    layout_name
+  end
+    
+  # Returns a raw template name from a source file path:
+  # source_template_from_path("/path/to/site/src/stylesheets/application.sass")  ->  "application"
+  def source_template_from_path(path)
+    file_dir, file_name = File.split(path)
+    file_name.chomp!(File.extname(file_name))
+    [ file_dir, file_name ]
+  end
+end

data/lib/staticmatic/mixins/rescue.rb

@@ -0,0 +1,12 @@
+module StaticMatic::RescueMixin
+  # Pass back an error template for the given exception
+  def render_rescue_from_error(exception)
+    rescue_template     = (exception.is_a?(StaticMatic::TemplateError)) ? "template" : "default"
+      
+    error_template_path = File.expand_path(File.dirname(__FILE__) + "/../templates/rescues/#{rescue_template}.haml")
+    
+    @scope.instance_variable_set("@exception", exception)
+    
+    generate_html_from_template_source(File.read(error_template_path))
+  end
+end

data/lib/staticmatic/mixins/server.rb

@@ -0,0 +1,6 @@
+module StaticMatic::ServerMixin
+  def preview
+    puts "StaticMatic Preview Server Starting..."
+    StaticMatic::Server.start(self)
+  end
+end

data/lib/staticmatic/mixins/setup.rb

@@ -0,0 +1,20 @@
+module StaticMatic::SetupMixin
+  
+  def setup
+    Dir.mkdir(@base_dir) unless File.exists?(@base_dir)
+  
+    StaticMatic::BASE_DIRS.each do |directory|
+      directory = "#{@base_dir}/#{directory}"
+      if !File.exists?(directory)
+        Dir.mkdir(directory)
+        puts "created #{directory}"
+      end
+    end
+
+    StaticMatic::TEMPLATES.each do |template, destination|
+      copy_file("#{@templates_dir}/#{template}", "#{@src_dir}/#{destination}")
+    end
+
+    puts "Done"
+  end
+end

data/lib/staticmatic/server.rb

@@ -0,0 +1,94 @@
+module StaticMatic
+  class Server < Mongrel::HttpHandler
+    @@file_only_methods = ["GET","HEAD"]
+ 
+    def initialize(staticmatic)
+      @files = Mongrel::DirHandler.new(staticmatic.site_dir, false)
+      @staticmatic = staticmatic
+    end
+  
+    def process(request, response)
+      @staticmatic.load_helpers
+      path_info = request.params[Mongrel::Const::PATH_INFO]
+      get_or_head = @@file_only_methods.include? request.params[Mongrel::Const::REQUEST_METHOD]
+      
+      file_dir, file_name, file_ext = expand_path(path_info)
+
+      # remove stylesheets/ directory if applicable
+      file_dir.gsub!(/^\/stylesheets\/?/, "")
+      
+      file_dir = CGI::unescape(file_dir)
+      file_name = CGI::unescape(file_name)
+      
+      if file_ext && file_ext.match(/html|css/)
+        response.start(200) do |head, out|
+          head["Content-Type"] = "text/#{file_ext}"
+          output = ""
+
+          if @staticmatic.template_exists?(file_name, file_dir) && !(File.basename(file_name) =~ /^\_/)
+
+            begin
+              if file_ext == "css"
+                output = @staticmatic.generate_css(file_name, file_dir)
+              else
+                output = @staticmatic.generate_html_with_layout(file_name, file_dir)
+              end
+            rescue StaticMatic::Error => e
+              output = e.message
+            end
+          else
+            if @files.can_serve(path_info)
+              @files.process(request,response)
+            else
+              output = "File not Found"
+            end
+          end
+          out.write output
+        end
+      else
+        # try to serve static file from site dir
+        if @files.can_serve(path_info)
+          @files.process(request,response)
+        end
+      end
+    end
+
+    def expand_path(path_info)
+      dirname, basename = File.split(path_info)
+
+      extname = File.extname(path_info).sub(/^\./, '')
+      filename = basename.chomp(".#{extname}")
+
+      if extname.empty?
+        dir = File.join(dirname, filename)
+        is_dir = path_info[-1, 1] == '/' || (@staticmatic.template_directory?(dir) && !@staticmatic.template_exists?(filename, dirname))
+        if is_dir
+          dirname = dir
+          filename = 'index'
+        end
+        extname = 'html'
+      end
+
+      [ dirname, filename, extname ]
+    end
+    
+    class << self
+      # Starts the StaticMatic preview server
+      def start(staticmatic)
+        port = staticmatic.configuration.preview_server_port || 3000
+        
+        host = staticmatic.configuration.preview_server_host || ""
+        
+        config = Mongrel::Configurator.new :host => host do
+          puts "Running Preview of #{staticmatic.base_dir} on #{host}:#{port}"
+          listener :port => port do
+            uri "/", :handler => Server.new(staticmatic)
+          end
+          trap("INT") { stop }
+          run
+        end
+        config.join
+      end
+    end
+  end
+end

data/lib/staticmatic/template_error.rb

@@ -0,0 +1,40 @@
+class StaticMatic::TemplateError < StandardError
+  SOURCE_CODE_RADIUS = 3
+  
+  attr_reader :original_exception, :backtrace
+
+  def initialize(template, original_exception)
+    @template, @original_exception = template, original_exception
+    @backtrace = original_exception.backtrace
+
+    @source = File.read(template)
+  end
+  
+  # TODO: Replace 'haml|sass' with any registered engines
+  def line_number
+    @line_number ||= $2 if backtrace.find { |line| line =~ /\((haml|sass)\)\:(\d+)/ }
+  end
+  
+  def filename
+    @template
+  end
+  
+  def source_extract(indentation = 0)
+    return unless num = line_number
+    num = num.to_i
+
+    source_code = @source.split("\n")
+
+    start_on_line = [ num - SOURCE_CODE_RADIUS - 1, 0 ].max
+    end_on_line   = [ num + SOURCE_CODE_RADIUS - 1, source_code.length].min
+
+    indent = ' ' * indentation
+    line_counter = start_on_line
+    return unless source_code = source_code[start_on_line..end_on_line]
+
+    source_code.collect do |line|
+      line_counter += 1
+      "#{indent}#{line_counter}: #{line}\n"
+    end.to_s
+  end
+end

data/lib/staticmatic/templates/default/application.haml

@@ -0,0 +1,7 @@
+!!!
+%html
+  %head
+    %title StaticMatic
+    = stylesheets
+  %body
+    = yield

data/lib/staticmatic/templates/default/application.sass

@@ -0,0 +1,4 @@
+body
+  :font
+    :family Verdana
+    :size 10pt

data/lib/staticmatic/templates/default/index.haml

@@ -0,0 +1 @@
+%h1 StaticMatic!

data/lib/staticmatic/templates/rescues/default.haml

@@ -0,0 +1,7 @@
+%h1= @exception.class.name
+
+%p= @exception.message
+
+%h2 Stack Trace
+
+= @exception.backtrace.join("<br/>")

data/lib/staticmatic/templates/rescues/template.haml

@@ -0,0 +1,18 @@
+%html
+  %head
+    %style{:type => "text/css"}
+      body { font-family: helvetica, verdana, arial; font-size: 10pt;}
+  %body
+    %h1
+      = @exception.class.name
+      in
+      = @exception.filename
+
+    %p= @exception.original_exception.message
+  
+    = @exception.source_extract.gsub(/\n/, "<br/>")
+
+
+    %h2 Backtrace
+
+    = @exception.backtrace.join("<br/>")

data/test/test_helper.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'stringio'
+require 'test/unit'
+
+require File.dirname(__FILE__) + '/../lib/staticmatic'
+
+TEST_SITE_PATH = File.join(File.dirname(__FILE__), "sandbox", "test_site")
+
+class Test::Unit::TestCase
+  def self.should(description, &block)
+    test_name = "test_should_#{description.gsub(/[\s]/,'_')}".to_sym
+    raise "#{test_name} is already defined in #{self}" if self.instance_methods.include?(test_name.to_s)
+    define_method(test_name, &block)
+  end
+end
+
+def setup_staticmatic
+  @staticmatic = StaticMatic::Base.new(TEST_SITE_PATH)
+end
+

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: mattt-staticmatic
+version: !ruby/object:Gem::Version 
+  version: 0.10.1
+platform: ruby
+authors: 
+- Stephen Bartholomew
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-29 00:00:00 -08:00
+default_executable: staticmatic
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: haml
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mongrel
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: newgem
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.3
+    version: 
+description: 
+email: 
+- steve@curve21.com
+executables: 
+- staticmatic
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.markdown
+- Rakefile
+- bin/staticmatic
+- lib/staticmatic.rb
+- lib/staticmatic/base.rb
+- lib/staticmatic/configuration.rb
+- lib/staticmatic/error.rb
+- lib/staticmatic/helpers.rb
+- lib/staticmatic/mixins/build.rb
+- lib/staticmatic/mixins/helpers.rb
+- lib/staticmatic/mixins/render.rb
+- lib/staticmatic/mixins/server.rb
+- lib/staticmatic/mixins/setup.rb
+- lib/staticmatic/server.rb
+- lib/staticmatic/templates/default/application.haml
+- lib/staticmatic/templates/default/application.sass
+- lib/staticmatic/templates/default/index.haml
+- lib/staticmatic/templates/rescues/default.haml
+- lib/staticmatic/templates/rescues/template.haml
+- lib/staticmatic/template_error.rb
+- lib/staticmatic/mixins/rescue.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: 
+post_install_message: 
+rdoc_options: 
+- --main
+- README.markdown
+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: staticmatic
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: The Lightweight Static Content framework
+test_files: 
+- test/test_helper.rb