ichiban 0.0.2 → 1.0.0

data/lib/ichiban/command.rb

@@ -1,11 +1,23 @@
 module Ichiban
   class Command
     def initialize(args)
+      @task = args.shift
       @args = args
     end
     
+    def print_usage
+      puts "Usage: ichiban <command>"
+      puts "  Available commands: watch"
+    end
+    
     def run
-      raise 'TODO'
+      Ichiban.project_root = Dir.getwd
+      case @task
+      when 'watch'
+        Ichiban::Watcher.new.start
+      else
+        print_usage
+      end
     end
   end
 end

data/lib/ichiban/config.rb

@@ -5,27 +5,17 @@ module Ichiban
     @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 self.load_file
+      config_file = ::File.join(Ichiban.project_root, 'config.rb')
+      raise "#{config_file} must exist" unless ::File.exists?(config_file)
+      load config_file
+    end
+    
     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 = \'/\'')
+      @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/deleter.rb

@@ -0,0 +1,24 @@
+module Ichiban
+  class Deleter
+    # Deletes a file's associated destination file, if any.
+    def delete_dest(path)
+      file = Ichiban::File.from_abs(path)
+      # file will be nil if the path doesn't map to a known subclass of Ichiban::File. Furthermore,
+      # even if file is not nil, it may be a kind of Ichiban::File that does not have a destination.
+      if file and file.has_dest?
+        dest = file.dest
+      else
+        dest = nil
+      end
+      if dest and ::File.exists?(dest)
+        puts 'yep'
+        FileUtils.rm(dest)
+      else
+        puts 'nope'
+      end
+    
+      # Log the deletion(s)
+      Ichiban.logger.deletion(path, dest)
+    end
+  end
+end

data/lib/ichiban/dependencies.rb

@@ -0,0 +1,33 @@
+module Ichiban
+  module Dependencies
+    @graphs = {}
+    
+    # graph_file_path is an absolute path.
+    def self.graph(graph_file_path)
+      ensure_graph_initialized(graph_file_path)
+      @graphs[graph_file_path]
+    end
+    
+    def self.ensure_graph_initialized(graph_file_path)
+      unless @graphs[graph_file_path]
+        if ::File.exists?(graph_file_path)
+          @graphs[graph_file_path] = JSON.parse(::File.read(graph_file_path))
+        else
+          @graphs[graph_file_path] = {}
+        end
+      end
+    end
+    
+    # Loads the graph from disk if it's not already in memory. Updates the graph. Writes the new
+    # graph to disk. graph_file_path is an absolute path.
+    def self.update(graph_file_path, ind, dep)
+      ensure_graph_initialized(graph_file_path)
+      graph = @graphs[graph_file_path]
+      graph[ind] ||= []
+      graph[ind] << dep unless graph[ind].include?(dep)
+      ::File.open(graph_file_path, 'w') do |f|
+        f << JSON.generate(graph)
+      end
+    end
+  end
+end

data/lib/ichiban/file.rb

@@ -0,0 +1,115 @@
+module Ichiban
+  class File
+    attr_reader :abs
+    
+    # Returns an absolute path in the compiled directory
+    def dest
+      ::File.join(Ichiban.project_root, 'compiled', dest_rel_to_compiled)
+    end
+    
+    # Returns a new instance based on an absolute path. Will automatically pick the right subclass.
+    # Return nil if the file is not recognized.
+    def self.from_abs(abs)
+      rel = abs.slice(Ichiban.project_root.length..-1) # Relative to project root
+      rel.sub!(/^\//, '') # Remove leading slash
+      if rel.start_with?('html') and rel.end_with?('.html')
+        Ichiban::HTMLFile.new(rel)
+      elsif rel.start_with?('layouts') and rel.end_with?('.html')
+        Ichiban::LayoutFIle.new(rel)
+      elsif rel.start_with?('assets/js')
+        Ichiban::JSFile.new(rel)
+      elsif rel.start_with?('assets/css') and rel.end_with?('.css')
+        Ichiban::CSSFile.new(rel)
+      elsif rel.start_with?('assets/css') and rel.end_with?('.scss')
+        Ichiban::SCSSFile.new(rel)
+      elsif rel.start_with?('assets/img')
+        Ichiban::ImageFile.new(rel)
+      elsif rel.start_with?('assets/misc')
+        Ichiban::MiscAssetFile.new(rel)
+      elsif rel.start_with?('models')
+        Ichiban::ModelFile.new(rel)
+      elsif rel.start_with?('data')
+        Ichiban::DataFile.new(rel)
+      elsif rel.start_with?('scripts')
+        Ichiban::ScriptFile.new(rel)
+      elsif rel.start_with?('helpers')
+        Ichiban::HelperFile.new(rel)
+      else
+        nil
+      end
+    end
+    
+    def has_dest?
+      respond_to?(:dest_rel_to_compiled)
+    end
+    
+    def initialize(rel)
+      @rel = rel
+      @abs = ::File.join(Ichiban.project_root, rel)
+    end
+    
+    # Returns a new path where the old extension is replaced with new_ext
+    def replace_ext(path, new_ext)
+      path.sub(/\..+$/, '.' + new_ext)
+    end
+  end
+  
+  class HTMLFile < File
+    def dest_rel_to_compiled
+      d = @rel.slice('html/'.length..-1)
+      (d.end_with?('.markdown') or d.end_with?('.md')) ? replace_ext(d, 'html') : d
+    end
+    
+    def update
+      Ichiban::HTMLCompiler.new(self).compile
+    end
+  end
+  
+  class LayoutFile < File
+  end
+  
+  class JSFile < File
+    def dest_rel_to_compiled
+      File.join('js', @rel.slice('assets/js/'.length..-1))
+    end
+  end
+  
+  class CSSFile < File
+    def dest_rel_to_compiled
+      File.join('css', @rel.slice('assets/css/'.length..-1))
+    end
+  end
+  
+  class SCSSFile < File
+    def dest_rel_to_compiled
+      replace_ext(
+        File.join('css', @rel.slice('assets/css/'.length..-1)),
+        'css'
+      )
+    end
+  end
+  
+  class ImageFile < File
+    def dest_rel_to_compiled
+      File.join('img', @rel.slice('assets/img/'.length..-1))
+    end
+  end
+  
+  class MiscAssetFile < File
+    def dest_rel_to_compiled
+      @rel.slice('assets/misc/'.length..-1)
+    end
+  end
+  
+  class ModelFile < File
+  end
+  
+  class DataFile < File
+  end
+  
+  class ScriptFile < File
+  end
+  
+  class HelperFile < File
+  end
+end

data/lib/ichiban/helpers.rb

@@ -13,10 +13,6 @@ module Ichiban
       @_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
@@ -32,7 +28,7 @@ module Ichiban
     
     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))
+      path = normalize_path(::File.join('/javascripts', js_file))
       content_tag 'script', 'type' => 'text/javascript', 'src' => path
     end
     
@@ -42,7 +38,7 @@ module Ichiban
     
     alias_method :layouts, :layout
     
-    def limit_options(hash, keys = [])
+    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)))
@@ -86,11 +82,11 @@ module Ichiban
     # 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-') }
+      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)
+            path = ::File.join(options[:section], path)
           end
           path = normalize_path(path)
           lis + content_tag('li', (attrs or {})) do
@@ -108,7 +104,7 @@ module Ichiban
     # Otherwise, it will remain relative.
     def normalize_path(path)
       if path.start_with?('/')
-        File.join(relative_url_root, path)
+        ::File.join(relative_url_root, path)
       else
         path
       end
@@ -131,7 +127,7 @@ module Ichiban
     
     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))
+      href = normalize_path(::File.join('/stylesheets', css_file))
       tag 'link', 'href' => href, 'type' => 'text/css', 'rel' => 'stylesheet', 'media' => media
     end
     

data/lib/ichiban/html_compiler.rb

@@ -0,0 +1,61 @@
+module Ichiban
+  class HTMLCompiler
+    def compile
+      ::File.open(@html_file.dest, 'w') do |f|
+        f << compile_to_str
+      end
+      Ichiban.logger.compilation(@html_file.abs, @html_file.dest)
+    end
+    
+    def compile_to_str
+      # Compile the HTML of the content page, but not the layouts (yet)
+      ctx = Ichiban::HTMLCompiler::Context.new(:_current_path => @html_file.dest_rel_to_compiled)
+      inner_html = Eruby.new(::File.read(@html_file.abs)).evaluate(ctx)
+      
+      # Compile Markdown if necessary
+      if (@html_file.abs.end_with?('.markdown') or @html_file.abs.end_with?('.md'))
+        inner_html = Ichiban::Markdown.compile(inner_html) # Will look for installed Markdown gems
+      end
+      
+      # Layouts
+      wrap_in_layouts(ctx, inner_html)
+    end
+    
+    # Takes an instance of Ichiban::HTMLFile
+    def initialize(html_file)
+      @html_file = html_file
+    end
+    
+    def wrap_in_layouts(ctx, inner_rhtml)
+      ctx.layout_stack.reverse.inject(inner_rhtml) do |html, layout_name|
+        layout_path = ::File.join(Ichiban.project_root, 'layouts', layout_name + '.html')
+        unless ::File.exists?(layout_path)
+          raise "Layout does not exist: #{layout_path}"
+        end
+        eruby = Eruby.new(
+          ::File.read(layout_path),
+          :filename => layout_path
+        )
+        html = eruby.evaluate(ctx) { html }
+        Ichiban::Dependencies.update('.layout_dependencies.json', layout_name, @html_file.abs)
+        html
+      end
+    end
+    
+    class Eruby < Erubis::Eruby
+      def add_preamble(src)
+        src << "@_erb_out = _buf = '';"
+      end
+    end
+    
+    class Context < Erubis::Context
+      include Ichiban::Helpers
+      include Erubis::XmlHelper
+      include ERB::Util # Give us #h
+      
+      def layout_stack
+        @_layout_stack or ['default']
+      end
+    end
+  end
+end

data/lib/ichiban/logger.rb

@@ -4,16 +4,72 @@ module Ichiban
   end
   
   class Logger
+    def self.ansi?
+      @ansi
+    end
+    
+    def ansi?
+      self.class.ansi?
+    end
+    
     def compilation(src, dst)
-      out "#{src} => #{dst}"
+      src = src.slice(Ichiban.project_root.length + 1..-1)
+      dst = dst.slice(Ichiban.project_root.length + 1..-1)
+      msg = "#{src} -> #{dst}"
+      if ansi?
+        msg = ANSI.color(msg, :green)
+      end
+      out msg
+    end
+    
+    def deletion(src, dst = nil)
+      src = src.slice(Ichiban.project_root.length + 1..-1)
+      if dst
+        dst = dst.slice(Ichiban.project_root.length + 1..-1)
+      end
+      if dst
+        msg = "Deleted: #{src} -> #{dst}"
+      else
+        msg = "Deleted: #{src}"
+      end
+      if ansi?
+        msg = ANSI.color(msg, :cyan)
+      end
+      out msg
     end
     
     def exception(exc)
-      out "#{exc.class.to_s}: #{exc.message}\n" + exc.backtrace.collect { |line| '  ' + line }.join("\n")
+      msg = "#{exc.class.to_s}: #{exc.message}\n" + exc.backtrace.collect { |line| '  ' + line }.join("\n")
+      if ansi?
+        msg = ANSI.color(msg, :red)
+      end
+      out msg
+    end
+    
+    def initialize
+      @out = STDOUT
+    end
+    
+    def out=(io)
+      @out = io
     end
     
     def out(msg)
-      puts msg
+      @out.puts msg
+    end
+    
+    def warn(msg)
+      if ansi?
+        msg = ANSI.color(msg, :red)
+      end
+      out msg
+    end
+    
+    begin
+      require 'ansi'
+      @ansi = true
+    rescue LoadError
+      Ichiban.logger.out("Try `gem install ansi` for colorized output")
     end
   end
 end

data/lib/ichiban/markdown.rb

@@ -0,0 +1,34 @@
+module Ichiban
+  module Markdown    
+    def self.compile(src)
+      require_markdown
+      case @strategy
+      when :redcarpet
+        @redcarpet.render(src)
+      when :maruku
+        Maruku.new(src).to_html
+      when :rdiscount
+        RDiscount.new(src).to_html
+      else
+        raise "unrecognized @strategy: #{@strategy}"
+      end
+    end
+    
+    def self.require_markdown
+      unless @markdown_loaded
+        case Ichiban.try_require('redcarpet', 'maruku', 'rdiscount')
+        when 'redcarpet'
+          @redcarpet = Redcarpet::Markdown.new(Redcarpet::Render::XHTML.new)
+          @strategy = :redcarpet
+        when 'maruku'
+          @strategy = :maruku
+        when 'rdiscount'
+          @strategy = :rdiscount
+        else
+          raise "Your Ichiban project contains at least one Markdown file. To process it, you need to install either the redcarpet or maruku gem."
+        end
+        @markdown_loaded = true
+      end
+    end
+  end
+end

data/lib/ichiban/watcher.rb

@@ -1,7 +1,39 @@
 module Ichiban
-  class Watcher
-    def watch
-      raise 'TODO'
+  class Watcher        
+    def initialize(options = {})
+      @options = {
+        :latency => 0.5
+      }.merge(options)
+    end
+    
+    def start
+      @listener = Listen.to(
+        ::File.join(Ichiban.project_root, 'html')#,
+        #::File.join(Ichiban.project_root, 'assets')
+      )
+      .ignore(/.listen_test$/)
+      .latency(@options[:latency])
+      .change do |modified, added, deleted|
+        begin
+          (modified + added).each do |path|
+            if file = Ichiban::File.from_abs(path)
+              file.update
+            end
+          end          
+        rescue => exc
+          Ichiban.logger.exception(exc)
+        end
+        deleted.each do |path|
+          Ichiban::Deleter.new.delete(path)
+        end
+      end.start(false) # nonblocking
+    end
+    
+    def stop
+      if @listener
+        @listener.stop
+        @listener = nil
+      end
     end
   end
 end

data/lib/ichiban.rb

@@ -1,25 +1,52 @@
-require 'csv'
+# Standard lib
 require 'fileutils'
+require 'json'
+require 'erb' # Just for the helpers
+
+# Gems
 require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/object/blank'
 require 'active_support/inflector'
-require 'erubis'
-require 'maruku'
 require 'sass'
+require 'listen'
+require 'erubis'
+require 'rake'
 
-# Order matters!
-require 'ichiban/command'
-require 'ichiban/layouts'
-require 'ichiban/helpers'
-require 'ichiban/compilation'
+# Ichiban files. Order matters!
 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'
+require 'ichiban/command'
+require 'ichiban/watcher'
+require 'ichiban/deleter'
+require 'ichiban/file'
+require 'ichiban/helpers'
+require 'ichiban/html_compiler'
+require 'ichiban/markdown'
+require 'ichiban/dependencies'
+require 'ichiban/helpers'
+
+module Ichiban
+  # In addition to setting the variable, this loads the config file
+  def self.project_root=(path)
+    @project_root = path
+    if path # It's valid to set project_root to nil, though this would likely only happen in tests
+      Ichiban::Config.load_file
+    end
+  end
+  
+  def self.project_root
+    @project_root
+  end
+  
+  # Try to load the libraries
+  def self.try_require(*gems)
+    gems.each do |gem|
+      begin
+        require gem
+        return gem
+      rescue LoadError
+      end
+    end
+    false
+  end
+end