ichiban 0.0.2

data/.gitignore

@@ -0,0 +1,5 @@
+pkg/*
+*.gem
+.bundle
+.sass-cache
+.sass-cache/**/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ichiban.gemspec
+gemspec

data/README

@@ -0,0 +1,56 @@
+To use, create a folder for your project. Populate it with the appropriate folders. Create a Rakefile and add this:
+
+require 'ichiban'
+Ichiban::Tasks.new.define
+
+Overall design
+==============
+
+The Rakefile should have as little in it as possible.
+
+Each individual bit of functionality should be separate and self-sufficient, although they can all depend on a configured project.
+
+For each of the following:
+
+- Content file
+- Stylesheet
+- JS
+- Image
+
+...do each of these:
+
+- Compile/copy one
+- List all
+- List stale
+- Compile/copy all
+- Compile/copy stale
+
+Listing is done in files.rb. Compiling is done in compilation.rb.
+
+Further:
+
+- List all data files
+- Run scripts
+
+The compilation logger needs to be accessible from everywhere so that generators etc. can get to it.
+
+The watcher should delete files in the compiled directory when they're no longer needed. This can't be automatically determined for files based on scripts.
+
+The watcher should use the fork process described here:
+
+http://rkh.im/code-reloading
+
+Initially, the watcher forks. Both the parent and child process watch for changes, but they respond differently. The parent's only job is to kill the
+child and refork upon changes to models, scripts, and helpers. The child's job is to compile.
+
+Scripts should have an optional dependencies block:
+
+dependencies('data/employees.csv', 'data/stores.csv') do
+  # Generate calls go here
+end
+
+This will cause the block to run only when employees.csv or stores.csv has changed. Since there's no way to infer the output file paths,
+we need to simply keep track of when the script was last run. Then, if any of the dependencies have changed after that, we re-run the script.
+To track this, we'll store a JSON hash in scripts/.last_runs
+
+{'employees.rb': 1316041807}

data/bin/ichiban.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'ichiban'
+
+Ichiban::Command.new(ARGV).run

data/ichiban.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ichiban/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ichiban"
+  s.version     = Ichiban::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jarrett Colby"]
+  s.email       = ["jarrettcolby@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Static website compiler}
+  s.description = %q{The most elegant way to compile static websites}
+
+  s.rubyforge_project = "ichiban"
+  
+  s.add_dependency 'activesupport'
+  s.add_dependency 'erubis'
+  s.add_dependency 'maruku'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/klass.rb

@@ -0,0 +1,7 @@
+
+    class Foo
+      def bar
+        puts 'bar'
+      end
+    end
+  

data/lib/ichiban/command.rb

@@ -0,0 +1,11 @@
+module Ichiban
+  class Command
+    def initialize(args)
+      @args = args
+    end
+    
+    def run
+      raise 'TODO'
+    end
+  end
+end

data/lib/ichiban/compilation.rb

@@ -0,0 +1,93 @@
+module Ichiban
+  class Compiler
+    include Layouts
+    
+    # This should not be called from the watcher. The watcher should have a more fine-grained way of looking at changed files.
+    def compile
+      load_all_ruby_files
+      compile_stale
+      run_scripts
+    end
+    
+    # Includes, content, images, etc
+    def compile_all
+      content_files.each { |path| compile_content_file(path) }
+      javascripts.each { |path| copy_javascript(path) }
+      images.each { |path| copy_image(path) }
+      stylesheets.each { |path| copy_or_compile_stylesheet(path) }
+    end
+    
+    def compile_content_file(src_path)
+      dest_path = content_dest(src_path)
+      FileUtils.mkdir_p File.dirname(dest_path.abs)
+      File.open(dest_path.replace_ext('html').abs, 'w') do |f|
+        begin
+          f.write(compile_content_file_to_string(src_path))
+        rescue Exception => exc
+          Ichiban.logger.exception(exc)
+        end
+      end
+    end
+    
+    def compile_content_file_to_string(src_path)
+      erb_context = ErbPage::Context.new(:_current_path => content_dest(src_path).web)
+      result = ErbPage.new(File.read(src_path.abs), :filename => src_path.abs).evaluate(erb_context)
+      result = case src_path.ext
+      when 'markdown'
+        Maruku.new(result).to_html
+      when 'html'
+        result
+      else
+        raise "compile_file_to_string doesn't know how to handle #{src_path.abs}"
+      end
+      wrap_in_layouts(erb_context, result)
+    end
+    
+    # Includes, content, images, etc
+    def compile_stale
+      stale_content_files.each { |path| compile_content_file(path) }
+      stale_javascripts.each { |path| copy_js(path) }
+      stale_images.each { |path| copy_image(path) }
+      stale_stylesheets.each { |path| copy_or_compile_stylesheet(path) }
+    end
+    
+    def copy_image(path)
+      dest = image_dest(path)
+      FileUtils.mkdir_p(dest.dirname)
+      FileUtils.cp(path.abs, dest.abs)
+    end
+    
+    def copy_javascript(path)
+      dest = javascript_dest(path)
+      FileUtils.mkdir_p(dest.dirname)
+      FileUtils.cp(path.abs, dest.abs)
+    end
+    
+    def copy_or_compile_stylesheet(path)
+      dest = stylesheet_dest(path)
+      case path.ext
+      when 'css'
+        FileUtils.mkdir_p(dest.dirname)
+        FileUtils.cp(path.abs, dest.abs)
+      when 'scss', 'sass'
+        Sass.compile_file(path.abs, dest.abs, :style => :compressed)
+      end
+    end
+    
+    def fresh
+      load_all_ruby_files
+      compile_all
+      run_scripts
+    end
+    
+    def run_scripts
+      scripts.each do |path|
+        begin
+          ScriptRunner.run_script_file(path)
+        rescue Exception => exc
+          Ichiban.logger.exception(exc)
+        end
+      end
+    end
+  end
+end

data/lib/ichiban/config.rb

@@ -0,0 +1,31 @@
+module Ichiban
+  def self.config
+    @config ||= ::Ichiban::Config.new
+    yield @config if block_given?
+    @config
+  end
+  
+  def self.configure_for_project(project_root)
+    config.project_root = project_root
+    config_file = File.join(project_root, 'config.rb')
+    raise "#{config_file} must exist" unless File.exists?(config_file)
+    load config_file
+  end
+  
+  # It's a bit messy to have this class method that's just an alias to a method on the config object.
+  # But so many different bits of code (including client code) need to know the project root, it makes
+  # pragmatic sense to have a really compact way to get it.
+  def self.project_root
+    config.project_root
+  end
+  
+  class Config
+    attr_accessor :project_root
+
+    attr_writer :relative_url_root
+    
+    def relative_url_root
+      @relative_url_root || raise('Ichiban.config.relative_url_root not set. Set inside block in config.rb like this: cfg.relative_url_root = \'/\'')
+    end
+  end
+end

data/lib/ichiban/erb_page.rb

@@ -0,0 +1,16 @@
+module Ichiban
+  class ErbPage < Erubis::Eruby
+    def add_preamble(src)
+      src << "@_erb_out = _buf = '';"
+    end
+    
+    class Context < Erubis::Context
+      include ::Ichiban::Helpers
+      include ::Erubis::XmlHelper
+      
+      def layout_stack
+        @_layout_stack or ['default']
+      end
+    end
+  end
+end

data/lib/ichiban/files.rb

@@ -0,0 +1,105 @@
+=begin
+- Content file
+- Stylesheet
+- JS
+- Image
+
+...do each of these:
+
+- Compile/copy one
+- List all
+- List stale
+- Compile/copy all
+- Compile/copy stale
+=end
+
+module Ichiban
+  class Compiler    
+    def content_files
+      paths_in('content').reject { |path| path.directory? }
+    end
+    
+    def data_files
+      paths_in 'data'
+    end
+    
+    def helpers
+      paths_in 'helpers', 'rb'
+    end
+    
+    def images
+      paths_in 'images'
+    end
+    
+    def models
+      paths_in 'models', 'rb'
+    end
+    
+    # Returns all stylesheet except for those beginning with an underscore
+    def stylesheets
+      paths_in('stylesheets').reject { |path| path.filename.start_with?('_') }
+    end
+    
+    def javascripts
+      paths_in 'javascripts', 'js'
+    end
+    
+    def scripts
+      paths_in 'scripts', 'rb'
+    end
+    
+    # For the stale methods, we rely on the source-destination mapping as provided by mapping.rb.
+    
+    def stale_content_files
+      stale(content_files) do |src_path|
+        content_dest(src_path)
+      end
+    end
+    
+    def stale_images
+      stale(images) do |src_path|
+        image_dest(src_path)
+      end
+    end
+    
+    def stale_stylesheets
+      stale(stylesheets) do |src_path|
+        stylesheet_dest(src_path)
+      end
+    end
+    
+    def stale_javascripts
+      stale(javascripts) do |src_path|
+        javascript_dest(src_path)
+      end
+    end
+    
+    private
+    
+    def paths_in(dir, ext = nil)
+      pattern = ext ? "**/*.#{ext}" : '**/*'
+      Dir.glob(File.join(Ichiban.project_root, dir, pattern)).collect { |abs| Path.new abs }
+    end
+    
+    # This method accepts a block. The block will be passed a source file path and must return either a destination path or an array thereof.
+    def stale(source_paths)
+      source_paths.reject do |path|
+        dest = yield(path)
+        dest = [dest] unless dest.is_a?(Array)
+        up_to_date?(path, *dest)
+      end
+    end
+    
+    # Accepts one source file and one or more destination files. Pass in Path objects.
+    # Note that this method is different from the one in FileUtils: The FileUtils version accepts
+    # one destination and multiple sources.
+    def up_to_date?(src, *dests)
+      src_time = File.mtime(src.abs)
+      dests.each do |dest|
+        return false if !File.exists?(dest.abs)
+        return false unless File.mtime(dest.abs) > src_time
+      end
+      true
+    end
+  end
+end

data/lib/ichiban/helpers.rb

@@ -0,0 +1,151 @@
+module Ichiban
+  module Helpers
+    def capture
+      before_buffering = @_erb_out.dup
+      @_erb_out.replace('')
+      yield
+      captured_output = @_erb_out.dup
+      @_erb_out.replace(before_buffering)
+      captured_output
+    end
+    
+    def concat(str)
+      @_erb_out << str
+    end
+    
+    def content_for(ivar_name, &block)
+      instance_variable_set '@' + ivar_name, capture(&block)
+    end
+    
+    def content_tag(*args)
+      options = args.extract_options!
+      name = args.shift
+      content = block_given? ? yield : args.shift
+      output = '<' + name
+      output << tag_attrs(options) << ">#{content}</#{name}>"
+    end
+    
+    # Returns the path relative to site root
+    def current_path
+      @_current_path
+    end
+    
+    def javascript_include_tag(js_file)
+      js_file = js_file + '.js' unless js_file.end_with?('.js')
+      path = normalize_path(File.join('/javascripts', js_file))
+      content_tag 'script', 'type' => 'text/javascript', 'src' => path
+    end
+    
+    def layout(*stack)
+      @_layout_stack = stack
+    end
+    
+    alias_method :layouts, :layout
+    
+    def limit_options(hash, keys = [])
+      keys = keys.collect(&:to_s)
+      hash.inject({}) do |result, (key, value)|
+        result[key] = value if (keys.include?(key.to_s) or (block_given? and yield(key, value)))
+        result
+      end
+    end
+    
+    def link_to(*args)
+      options = args.extract_options!
+      if args.length == 1
+        text = url = args[0]
+      else
+        text = args[0]
+        url = args[1]
+      end
+      if url.is_a?(String)
+        url = normalize_path(url)
+      else
+        url = url.to_param
+      end
+      content_tag 'a', text, options.merge('href' => url)
+    end
+    
+    # Pass in an array of this form:
+    #
+    #   [
+    #     ['Link Text', '/path/from/relative/url/root/']
+    #     ['Link Text', '/path/from/relative/url/root/', {'id' => 'foo'}]
+    #   ]
+    #
+    # You can also do this, as a convenience:
+    #
+    #   nav([
+    #     ['Link Text', 'path/from/section/root/']
+    #   ], :section => 'section-name')
+    # 
+    # Which will generate this href:
+    # 
+    #   /section-name/path/from/section/root/
+    #
+    # If you don't specify a section, and your URLs don't have leading slashes,
+    # the hrefs will use relative URLs.
+    def nav(items, options = {})
+      ul_options = limit_options(options, %w(id class)) { |key, value| key.to_s.start_with?('data-') }
+      content_tag('ul', ul_options) do
+        items.inject('') do |lis, (text, path, attrs)|
+          if options[:section]
+            path = File.join(options[:section], path)
+          end
+          path = normalize_path(path)
+          lis + content_tag('li', (attrs or {})) do
+            if path_with_slashes(current_path) == path_with_slashes(path)
+              content_tag('span', text, 'class' => 'selected')
+            else
+              link_to(text, path)
+            end
+          end
+        end
+      end
+    end
+    
+    # If the path has a trailing slash, it will be made absolute using relative_url_root.
+    # Otherwise, it will remain relative.
+    def normalize_path(path)
+      if path.start_with?('/')
+        File.join(relative_url_root, path)
+      else
+        path
+      end
+    end
+    
+    def page_title(title)
+      @page_title = title
+    end
+    
+    # Adds leading and trailing slashes if none are present
+    def path_with_slashes(path)
+      path = '/' + path unless path.start_with?('/')
+      path << '/' unless path.end_with?('/')
+      path
+    end
+    
+    def relative_url_root
+      Ichiban.config.relative_url_root
+    end
+    
+    def stylesheet_link_tag(css_file, media = 'screen')
+      css_file = css_file + '.css' unless css_file.end_with?('.css')
+      href = normalize_path(File.join('/stylesheets', css_file))
+      tag 'link', 'href' => href, 'type' => 'text/css', 'rel' => 'stylesheet', 'media' => media
+    end
+    
+    def tag(*args)
+      name = args.shift
+      options = args.extract_options!
+      open = args.shift
+      "<#{name}#{tag_attrs(options)}#{open ? '>' : '/>'}"
+    end
+    
+    def tag_attrs(attrs)
+      attrs.inject('') do |result, (key, value)|
+        result + " #{key}=\"#{h(value)}\""
+      end
+    end
+  end
+end

data/lib/ichiban/layouts.rb

@@ -0,0 +1,10 @@
+module Ichiban
+  module Layouts
+    def wrap_in_layouts(erb_context, html)
+      erb_context.layout_stack.reverse.inject(html) do |html, layout_name|
+        layout_path = Path.new(File.join(Ichiban.project_root, 'layouts', layout_name + '.html'))
+        ErbPage.new(File.read(layout_path.abs), :filename => layout_path.abs).evaluate(erb_context) { html }
+      end
+    end
+  end
+end

data/lib/ichiban/loading.rb

@@ -0,0 +1,19 @@
+module Ichiban
+  class Compiler
+    def load_all_ruby_files
+      models.each { |path| load path.abs }
+      helpers.each { |path| load_helper path }
+    end
+    
+    def load_helper(path)
+      load path.abs
+      mod_name = path.filename_without_ext.classify
+      begin
+        mod = Object.const_get(mod_name)
+      rescue NameError
+        raise "Expected #{path.abs} to define module #{classname}"
+      end
+      ErbPage::Context.send(:include, mod)
+    end
+  end
+end

data/lib/ichiban/logger.rb

@@ -0,0 +1,19 @@
+module Ichiban
+  def self.logger
+    @logger ||= Logger.new
+  end
+  
+  class Logger
+    def compilation(src, dst)
+      out "#{src} => #{dst}"
+    end
+    
+    def exception(exc)
+      out "#{exc.class.to_s}: #{exc.message}\n" + exc.backtrace.collect { |line| '  ' + line }.join("\n")
+    end
+    
+    def out(msg)
+      puts msg
+    end
+  end
+end

data/lib/ichiban/mapping.rb

@@ -0,0 +1,38 @@
+module Ichiban
+  class Compiler
+    def content_dest(src_path)
+      if src_path.ext == 'markdown'
+        src_path = src_path.replace_ext('html')
+      end
+      Path.new(
+        File.join(Ichiban.project_root, 'compiled',
+          src_path.relative_from('content')
+        )
+      )
+    end
+    
+    def image_dest(src_path)
+      Path.new(
+        File.join(Ichiban.project_root, 'compiled', 'images',
+          src_path.relative_from('images')
+        )
+      )
+    end
+    
+    def javascript_dest(src_path)
+      Path.new(
+        File.join(Ichiban.project_root, 'compiled', 'javascripts',
+          src_path.relative_from('javascripts')
+        )
+      )
+    end
+    
+    def stylesheet_dest(src_path)
+      Path.new(
+        File.join(Ichiban.project_root, 'compiled', 'stylesheets',
+          src_path.relative_from('stylesheets')
+        )
+      ).replace_ext('css')
+    end
+  end
+end

data/lib/ichiban/path.rb

@@ -0,0 +1,55 @@
+# A Path object is a wrapper around an absolute path.
+
+class Path
+  attr_reader :abs
+  
+  def directory?
+    File.directory?(abs)
+  end
+  
+  def dirname
+    File.dirname(abs)
+  end
+  
+  def ext
+    File.extname(abs).slice(1..-1)
+  end
+  
+  def filename
+    File.basename(abs)
+  end
+  
+  def filename_without_ext
+    File.basename(abs, File.extname(abs))
+  end
+  
+  def initialize(abs)
+    @abs = abs
+  end
+  
+  # Returns a string relative to the given folder
+  def relative_from(folder_in_project_root)
+    prefix = File.join(Ichiban.project_root, folder_in_project_root)
+    raise(ArgumentError, "#{abs} does not start with #{prefix}") unless abs.start_with?(prefix)
+    abs.slice(prefix.length..-1)
+  end
+  
+  def replace_ext(new_ext)
+    self.class.new(abs.sub(/\..+$/, '.' + new_ext))
+  end
+  
+  # Only meaningful for paths in the compiled directory. Returns a string representing the path from the web root.
+  # Assumes Ichiban's standard URL rewriting rules are in effect.
+  def web
+    web_path = relative_from('compiled')    
+    if web_path.end_with?('.html')
+      if web_path.end_with?('index.html')
+        web_path.slice(0..-11) # Slice index.html off the end
+      else
+        web_path.slice(0..-6) + '/' # Slice .html off the end and add the trailing slash
+      end
+    else
+      web_path
+    end
+  end
+end

data/lib/ichiban/script_runner.rb

@@ -0,0 +1,33 @@
+module Ichiban
+  # This class runs .rb files located in the content folder. Its main purpose is to generate pages from databases.
+  class ScriptRunner
+    include Layouts
+    
+    def generate(template_path_from_content_root, destination_path_from_site_root, ivars)
+      template_path = Path.new(
+        File.join(Ichiban.project_root, 'content', template_path_from_content_root)
+      )
+      destination_path = Path.new(
+        File.join(Ichiban.project_root, 'compiled', destination_path_from_site_root + '.html')
+      )
+      erb_context = ErbPage::Context.new(ivars.merge(:_current_path => destination_path_from_site_root))
+      result = ErbPage.new(File.read(template_path.abs), :filename => template_path.abs).evaluate(erb_context)
+      result = wrap_in_layouts(erb_context, result)
+      File.open(destination_path.abs, 'w') do |f|
+        f.write result
+      end
+    end
+    
+    def initialize(path)
+      @source = path.abs
+    end
+    
+    def self.run_script_file(path)
+      new(path).run
+    end
+    
+    def run
+      instance_eval(File.read(@source), @source)
+    end
+  end
+end

data/lib/ichiban/tasks.rb

@@ -0,0 +1,23 @@
+module Ichiban
+  def self.define_tasks(rakefile)
+    desc 'Generates the static site and puts it in the "compiled" directory. Files will only be compiled as necessary. If a layout has been modified, all files will be recompiled.'
+    task :compile => :init do
+      Ichiban::Compiler.new.compile
+    end
+    
+    desc 'Generates the static site and puts it in the "compiled" directory. All files will be compiled from scratch.'
+    task :fresh => :init do
+      Ichiban::Compiler.new.fresh
+    end
+    
+    desc 'Continuously watch for changes and compile files as needed.'
+    task :watch => :init do
+      Ichiban::Watcher.new.watch
+    end
+    
+    desc 'Initialize Ichiban.'
+    task :init do
+      Ichiban.configure_for_project(File.dirname(File.expand_path(rakefile)))
+    end
+  end
+end

data/lib/ichiban/version.rb

@@ -0,0 +1,3 @@
+module Ichiban
+  VERSION = "0.0.2"
+end

data/lib/ichiban/watcher.rb

@@ -0,0 +1,7 @@
+module Ichiban
+  class Watcher
+    def watch
+      raise 'TODO'
+    end
+  end
+end

data/lib/ichiban.rb

@@ -0,0 +1,25 @@
+require 'csv'
+require 'fileutils'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/object/blank'
+require 'active_support/inflector'
+require 'erubis'
+require 'maruku'
+require 'sass'
+
+# Order matters!
+require 'ichiban/command'
+require 'ichiban/layouts'
+require 'ichiban/helpers'
+require 'ichiban/compilation'
+require 'ichiban/config'
+require 'ichiban/erb_page'
+require 'ichiban/files'
+require 'ichiban/logger'
+require 'ichiban/loading'
+require 'ichiban/mapping'
+require 'ichiban/path'
+require 'ichiban/script_runner'
+require 'ichiban/tasks'
+require 'ichiban/version'
+require 'ichiban/watcher'

data/sample/Rakefile

@@ -0,0 +1,2 @@
+require 'ichiban'
+Ichiban.define_tasks(__FILE__)

data/sample/compiled/about.html

@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<title>Sample</title>
+</head>
+
+<body>
+
+<h1>About</h1>
+
+</body>
+
+</html>

data/sample/compiled/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<title>Sample</title>
+</head>
+
+<body>
+
+<h1>Home</h1>
+
+</body>
+
+</html>

data/sample/compiled/javascripts/interaction.js

@@ -0,0 +1 @@
+// Foo

data/sample/compiled/staff/_employee.html

@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<title>Sample</title>
+</head>
+
+<body>
+
+<h1> </h1>
+
+</body>
+
+</html>

data/sample/compiled/staff/andre-marques.html

@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<title>Sample</title>
+</head>
+
+<body>
+
+<h1>Andre Marques</h1>
+
+</body>
+
+</html>

data/sample/compiled/staff/index.html

@@ -0,0 +1,17 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<title>Sample</title>
+</head>
+
+<body>
+
+<h1>Employees</h1>
+<ul>
+    <li><a href="/staff/jarrett-{employee.last.downcase}/">Jarrett Colby</a></li>
+    <li><a href="/staff/andre-{employee.last.downcase}/">Andre Marques</a></li>
+</ul>
+
+</body>
+
+</html>

data/sample/compiled/staff/jarrett-colby.html

@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<title>Sample</title>
+</head>
+
+<body>
+
+<h1>Jarrett Colby</h1>
+
+</body>
+
+</html>

data/sample/compiled/stylesheets/reset.css

@@ -0,0 +1 @@
+h1, h2, h3, h4, h5, h6 {font-size: 100%;}

data/sample/compiled/stylesheets/screen.css

@@ -0,0 +1 @@
+body h1{color:#f04040}

data/sample/config.rb

@@ -0,0 +1,3 @@
+Ichiban.config do |cfg|
+  cfg.relative_url_root = '/'
+end

data/sample/content/about.html

@@ -0,0 +1 @@
+<h1>About</h1>

data/sample/content/bad.html

@@ -0,0 +1,3 @@
+<!-- This page demonstrates what happens when an error is raised inside a page. The compiler should report the error and gracefully recover. -->
+
+<% raise "This error is being generated by content/bad.html. This is intentional. The purpose is to illustrate how the compiler recovers gracefully from an in-page error." %>

data/sample/content/index.html

@@ -0,0 +1 @@
+<h1>Home</h1>

data/sample/content/staff/_employee.html

@@ -0,0 +1 @@
+<h1><%= @first %> <%= @last %></h1>

data/sample/content/staff/index.html

@@ -0,0 +1,6 @@
+<h1>Employees</h1>
+<ul>
+  <% Employee.all.each do |employee| %>
+    <li><%= link_to employee.first + ' ' + employee.last, employee_path(employee) %></li>
+  <% end %>
+</ul>

data/sample/data/employees.csv

@@ -0,0 +1,2 @@
+Jarrett,Colby
+Andre,Marques

data/sample/errors/404.html

@@ -0,0 +1 @@
+<h1>The page does not exist.</h1>

data/sample/helpers/staff_helper.rb

@@ -0,0 +1,5 @@
+module StaffHelper
+  def employee_path(employee)
+    "/staff/#{employee.first.downcase}-{employee.last.downcase}/"
+  end
+end

data/sample/javascripts/interaction.js

@@ -0,0 +1 @@
+// Foo

data/sample/layouts/default.html

@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<title>Sample</title>
+</head>
+
+<body>
+
+<%= yield %>
+
+</body>
+
+</html>

data/sample/models/employee.rb

@@ -0,0 +1,16 @@
+class Employee
+  def self.all
+    CSV.read(File.join(Ichiban.project_root, 'data', 'employees.csv')).collect do |row|
+      new(row[0], row[1])
+    end
+  end
+  
+  attr_accessor :first
+  
+  def initialize(first, last)
+    @first = first
+    @last = last
+  end
+  
+  attr_accessor :last
+end

data/sample/scripts/bad.rb

@@ -0,0 +1 @@
+raise 'This error is being generated by scripts/bad.rb. This is intentional. The purpose is to illustrate how the compiler recovers gracefully from a script error.'

data/sample/scripts/staff.rb

@@ -0,0 +1,8 @@
+Employee.all.each do |employee|
+  generate(
+    'staff/_employee.html',
+    File.join('staff', "#{employee.first.downcase}-#{employee.last.downcase}"),
+    :first => employee.first,
+    :last => employee.last
+  )
+end

data/sample/stylesheets/reset.css

@@ -0,0 +1 @@
+h1, h2, h3, h4, h5, h6 {font-size: 100%;}

data/sample/stylesheets/screen.scss

@@ -0,0 +1,5 @@
+$red: #f04040;
+
+body {
+  h1 {color: $red;}
+}

data/spec/integration_spec.rb

@@ -0,0 +1,89 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+require 'nokogiri'
+
+describe Ichiban do
+  def compiled(path = nil)
+    path.nil? ? File.join(root, 'compiled') : File.join(root, 'compiled', path)
+  end
+  
+  def parse_compiled(path)
+    @parsed_html ||= {}
+    @parsed_html[path] ||= Nokogiri.HTML(File.read(compiled(path)))
+  end
+  
+  def root
+    File.expand_path(File.join(File.dirname(__FILE__), '../sample'))
+  end
+  
+  before(:all) do
+    FileUtils.rm_rf compiled
+    FileUtils.mkdir compiled
+  end
+  
+  shared_examples_for 'compilation' do
+    it 'creates all the content files and directories as needed' do
+      compiled('index.html').should be_file
+      compiled('about.html').should be_file
+      compiled('staff/index.html').should be_file
+    end
+    
+    it 'renders the content' do
+      parse_compiled('index.html').css('h1').inner_html.should == 'Home'
+      parse_compiled('about.html').css('h1').inner_html.should == 'About'
+      parse_compiled('staff/index.html').css('h1').inner_html.should == 'Employees'
+    end
+    
+    it 'inserts the content into the layout' do
+      parse_compiled('index.html').css('head').length.should == 1
+    end
+    
+    it 'copies images' do
+      compiled('images/check.png').should be_file
+    end
+    
+    it 'compiles SCSS' do
+      File.read(compiled('stylesheets/screen.css')).should include('body h1{color:#f04040}')
+    end
+    
+    it 'copies CSS' do
+      compiled('stylesheets/reset.css').should be_file
+    end
+    
+    it 'copies JS' do
+      compiled('javascripts/interaction.js').should be_file
+    end
+    
+    it 'logs errors raised within content files' do
+      Ichiban.logger.test_messages.detect do |msg|
+        msg.start_with?('RuntimeError: This error is being generated by content/bad.html. This is intentional. The purpose is to illustrate how the compiler recovers gracefully from an in-page error.')
+      end.should_not be_nil
+    end
+    
+    it 'logs errors raised within scripts' do
+      Ichiban.logger.test_messages.detect do |msg|
+        msg.start_with?('RuntimeError: This error is being generated by scripts/bad.rb. This is intentional. The purpose is to illustrate how the compiler recovers gracefully from a script error.')
+      end.should_not be_nil
+    end
+    
+    context 'with scripts' do
+      it 'generates files' do
+        compiled('staff/andre-marques.html').should be_file
+        compiled('staff/jarrett-colby.html').should be_file
+      end
+      
+      it 'interpolates data into the template' do
+        parse_compiled('staff/andre-marques.html').css('h1').inner_html == 'Andre Marques'
+        parse_compiled('staff/jarrett-colby.html').css('h1').inner_html == 'Jarrett Colby'
+      end
+    end
+  end
+  
+  context 'fresh compile' do
+    before(:all) do
+      Ichiban.configure_for_project(root)
+      Ichiban::Compiler.new.fresh
+    end
+    
+    it_should_behave_like 'compilation'
+  end
+end

data/spec/path_spec.rb

@@ -0,0 +1,15 @@
+require 'ichiban'
+
+include Ichiban
+
+describe Path do  
+  #describe '#relative_from' do
+  #  it 'returns the path relative to the given subfolder' do
+  #    Path.new('/project/content/foo/index.html').relative_from('content').should == 'foo/index.html'
+  #  end
+  #  
+  #  it 'raises if the file is not in the given subfolder' do
+  #    lambda { Path.new('/project/content/foo/index.html').relative_from('errors') }.should raise_error
+  #  end
+  #end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+# Put the working directory's version of Ichiban first in the list of load paths. That way,
+# we won't load an installed version of the gem.
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__)), '../lib')
+
+require 'ichiban'
+
+module Ichiban
+  class Logger
+    def out(msg)
+      (@test_messages ||= []) << msg
+    end
+    
+    attr_reader :test_messages
+  end
+end
+
+RSpec::Matchers.define :be_file do
+  match { |path| File.exists?(path) }
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: ichiban
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Jarrett Colby
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-04 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &2157055820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2157055820
+- !ruby/object:Gem::Dependency
+  name: erubis
+  requirement: &2157055400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2157055400
+- !ruby/object:Gem::Dependency
+  name: maruku
+  requirement: &2157054980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2157054980
+description: The most elegant way to compile static websites
+email:
+- jarrettcolby@gmail.com
+executables:
+- ichiban.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README
+- bin/ichiban.rb
+- ichiban.gemspec
+- klass.rb
+- lib/ichiban.rb
+- lib/ichiban/command.rb
+- lib/ichiban/compilation.rb
+- lib/ichiban/config.rb
+- lib/ichiban/erb_page.rb
+- lib/ichiban/files.rb
+- lib/ichiban/helpers.rb
+- lib/ichiban/layouts.rb
+- lib/ichiban/loading.rb
+- lib/ichiban/logger.rb
+- lib/ichiban/mapping.rb
+- lib/ichiban/path.rb
+- lib/ichiban/script_runner.rb
+- lib/ichiban/tasks.rb
+- lib/ichiban/version.rb
+- lib/ichiban/watcher.rb
+- sample/Rakefile
+- sample/compiled/about.html
+- sample/compiled/bad.html
+- sample/compiled/images/check.png
+- sample/compiled/index.html
+- sample/compiled/javascripts/interaction.js
+- sample/compiled/staff/_employee.html
+- sample/compiled/staff/andre-marques.html
+- sample/compiled/staff/index.html
+- sample/compiled/staff/jarrett-colby.html
+- sample/compiled/stylesheets/reset.css
+- sample/compiled/stylesheets/screen.css
+- sample/config.rb
+- sample/content/about.html
+- sample/content/bad.html
+- sample/content/index.html
+- sample/content/staff/_employee.html
+- sample/content/staff/index.html
+- sample/data/employees.csv
+- sample/errors/404.html
+- sample/helpers/staff_helper.rb
+- sample/images/check.png
+- sample/javascripts/interaction.js
+- sample/layouts/default.html
+- sample/models/employee.rb
+- sample/scripts/bad.rb
+- sample/scripts/staff.rb
+- sample/stylesheets/reset.css
+- sample/stylesheets/screen.scss
+- spec/integration_spec.rb
+- spec/path_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: ichiban
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Static website compiler
+test_files:
+- spec/integration_spec.rb
+- spec/path_spec.rb
+- spec/spec_helper.rb