ichiban 1.0.0 → 1.0.6

data/lib/ichiban/html_compiler.rb

@@ -1,43 +1,65 @@
 module Ichiban
   class HTMLCompiler
     def compile
-      ::File.open(@html_file.dest, 'w') do |f|
+      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)
+    def compile_to_str 
+      # @_template_path is a path relative to the html folder. It points to the current *complete*
+      # HTML file being rendered. I.e. if we're currently rendering a partial, @_template_path
+      # will *not* point to the partial file.
+      #
+      # _template_path may be overwritten later when we look at @ivars. This is good, because
+      # if we're in a partial, and the including template has already set _template_path, we want
+      # to inherit that value. (When you call partial from a template, all of the including template's
+      # instance variables, including @_template_path, will be put into @ivars.)
+      ivars_for_ctx = {:_template_path => @html_file.rel.slice('html/'.length..-1)}
+      
+      if @html_file.is_a?(Ichiban::HTMLFile)
+        ivars_for_ctx[:_current_path] = @html_file.web_path
+      end
+      ivars_for_ctx.merge!(@ivars) if @ivars
+      
+      ctx = Ichiban::HTMLCompiler::Context.new(ivars_for_ctx)
+      
+      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)
+      # Do layouts if appropriate
+      if @html_file.is_a?(Ichiban::HTMLFile)
+        wrap_in_layouts(ctx, inner_html)
+      else
+        # It's a PartialHTMLFile
+        inner_html
+      end
     end
     
-    # Takes an instance of Ichiban::HTMLFile
+    # Takes an instance of Ichiban::HTMLFile or Ichiban::PartialHTMLFile
     def initialize(html_file)
       @html_file = html_file
     end
     
+    attr_writer :ivars
+    
     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)
+        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),
+          File.read(layout_path),
           :filename => layout_path
         )
         html = eruby.evaluate(ctx) { html }
-        Ichiban::Dependencies.update('.layout_dependencies.json', layout_name, @html_file.abs)
+        Ichiban::Dependencies.update('.layout_dependencies.json', layout_name, @html_file.rel)
         html
       end
     end
@@ -50,12 +72,40 @@ module Ichiban
     
     class Context < Erubis::Context
       include Ichiban::Helpers
+      include Ichiban::NavHelper
       include Erubis::XmlHelper
       include ERB::Util # Give us #h
       
+      # An array of helper modules. Each Context instance will be extended with them on init.
+      # We could just include the modules in this class. But that would break reloading. Once a
+      # module has been included, deleting the module doesn't un-include it. So instead, we limit
+      # the damage to a particular instance of Context.
+      @user_defined_helpers = []
+      
+      def self.add_user_defined_helper(mod)
+        unless @user_defined_helpers.include?(mod)
+          @user_defined_helpers << mod
+        end
+      end
+      
+      def self.clear_user_defined_helpers
+        @user_defined_helpers = []
+      end
+      
+      def initialize(vars)
+        super(vars)
+        self.class.user_defined_helpers.each do |mod|
+          extend(mod)
+        end
+      end
+      
       def layout_stack
         @_layout_stack or ['default']
       end
+      
+      def self.user_defined_helpers
+        @user_defined_helpers
+      end
     end
   end
 end

data/lib/ichiban/loader.rb

@@ -0,0 +1,53 @@
+module Ichiban
+  class Loader
+    # Pass in an IchibanFile
+    def change(file)
+      if file.is_a?(Ichiban::HelperFile) or file.is_a?(Ichiban::ModelFile)
+        delete_all
+        load_all
+        Ichiban.logger.reload(file.abs)
+      end
+    end
+    
+    # Load all models and helpers in Ichiban.project_root
+    def initialize
+      @loaded_constants = []
+      load_all
+    end
+    
+    private
+    
+    # Calls Object.remove_const on all tracked modules. Also clears the compiler's list of user-defined helpers.
+    def delete_all
+      @loaded_constants.each do |const_name|
+        Object.send(:remove_const, const_name)
+      end
+      Ichiban::HTMLCompiler::Context.clear_user_defined_helpers
+    end
+    
+    def load_all
+      # Load all models
+      Dir.glob(File.join(Ichiban.project_root, 'models/**/*.rb')).each do |model_path|
+        load_file(model_path)
+      end
+      
+      # Load all helpers, and pass them to HTMLCompiler::Context
+      Dir.glob(File.join(Ichiban.project_root, 'helpers/**/*.rb')).each do |helper_path|
+        const = load_file(helper_path)
+        Ichiban::HTMLCompiler::Context.add_user_defined_helper(const)
+      end
+    end
+    
+    def load_file(path)
+      load path
+      const_name = File.basename(path, File.extname(path)).classify
+      begin
+        const = Object.const_get(const_name)
+      rescue NameError
+        raise "Expected #{path} to define #{const_name}"
+      end
+      @loaded_constants << const_name.to_sym
+      const
+    end
+  end
+end

data/lib/ichiban/logger.rb

@@ -46,16 +46,50 @@ module Ichiban
       out msg
     end
     
+    def layout(path)
+      path = path.slice(Ichiban.project_root.length + 1..-1)
+      msg = "#{path} changed; recompiling affected pages"
+      if ansi?
+        msg = ANSI.color(msg, :magenta)
+      end
+      out msg
+    end
+    
     def initialize
       @out = STDOUT
     end
     
+    def reload(path)
+      path = path.slice(Ichiban.project_root.length + 1..-1)
+      msg = "#{path} triggered a reload"
+      if ansi?
+        msg = ANSI.color(msg, :magenta)
+      end
+      out msg
+    end
+    
     def out=(io)
       @out = io
     end
     
-    def out(msg)
-      @out.puts msg
+    # Overloaded. Pass in a string and it writes to the output stream.
+    # Pass in nothing and it returns the output stream.
+    def out(msg = nil)
+      if msg.nil?
+        @out
+      else
+        @out.puts msg
+      end
+    end
+    
+    def script_run(ind_path, dep_path)
+      ind_path = ind_path.slice(Ichiban.project_root.length + 1..-1)
+      dep_path = dep_path.slice(Ichiban.project_root.length + 1..-1)
+      msg = "#{dep_path} running due to change in #{ind_path}"
+      if ansi?
+        msg = ANSI.color(msg, :magenta)
+      end
+      out msg
     end
     
     def warn(msg)
@@ -69,7 +103,7 @@ module Ichiban
       require 'ansi'
       @ansi = true
     rescue LoadError
-      Ichiban.logger.out("Try `gem install ansi` for colorized output")
+      Ichiban.logger.out("Try `gem install ansi` for colorized output. If you're using a Gemfile, add it there too.")
     end
   end
 end

data/lib/ichiban/markdown.rb

@@ -3,6 +3,10 @@ module Ichiban
     def self.compile(src)
       require_markdown
       case @strategy
+      when :kramdown
+        Kramdown::Document.new(src).to_html
+      when :multimarkdown
+        MultiMarkdown.new(src).to_html
       when :redcarpet
         @redcarpet.render(src)
       when :maruku
@@ -16,7 +20,11 @@ module Ichiban
     
     def self.require_markdown
       unless @markdown_loaded
-        case Ichiban.try_require('redcarpet', 'maruku', 'rdiscount')
+        case Ichiban.try_require('kramdown', 'multimarkdown', 'redcarpet', 'maruku', 'rdiscount')
+        when 'kramdown'
+          @strategy = :kramdown
+        when 'multimarkdown'
+          @strategy = :multimarkdown
         when 'redcarpet'
           @redcarpet = Redcarpet::Markdown.new(Redcarpet::Render::XHTML.new)
           @strategy = :redcarpet
@@ -25,7 +33,8 @@ module Ichiban
         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."
+          raise("Your Ichiban project contains at least one Markdown file. To process it, " +
+                "you need to gem install one of: rpeg-multimarkdown redcarpet maruku rdiscount.")
         end
         @markdown_loaded = true
       end

data/lib/ichiban/nav_helper.rb

@@ -0,0 +1,175 @@
+module Ichiban
+  module NavHelper
+  
+    def nav(items, options = {})
+      Nav.new(items, options, self).to_html
+    end
+    
+    class Nav
+      def initialize(items, options, context)
+        @items = items
+        @options = options
+        @ctx = context
+      end
+      
+      def to_html
+        ul(@items, 0)
+      end
+      
+      private
+      
+      # Returns true if and only if the current path is *identical* to the passed-in path.
+      def current_path?(path)
+        @ctx.path_with_slashes(@ctx.current_path) == @ctx.path_with_slashes(path)
+      end
+      
+      # Returns true if and only if the current path *starts with* the passed-in path.
+      # So sub-paths will match.
+      def current_path_starts_with?(path)
+        @ctx.path_with_slashes(@ctx.current_path).start_with?(@ctx.path_with_slashes(path))
+      end
+      
+      
+      
+      #def merge_classes(current_classes, added_classes)
+      #  current_classes = current_classes.split(/ +/)
+      #  added_classes = added_classes.split(/ +/)
+      #  (current_classes + added_classes).uniq.join(' ')
+      #end
+      
+      # Recursive. Checks whether any item in the menu, or any item in any of its descendant
+      # menus, has a path that *starts with* the current path. E.g. if a menu or its descendants
+      # have a link to '/a/b/c/', and we're at '/a/b/c/d/e/f/', then this method returns true.
+      def menu_matches_current_path?(items)
+        !items.detect do |item|
+          if current_path_starts_with?(item[1])
+            # The current path matches this item, so we can stop looking.
+            # menu_matches_current_path? will return true.
+            true
+          elsif item[2].is_a?(Array)
+            # If an item has a sub-menu, then that menu must be the third element of the array.
+            # (The format is [text, path, sub_menu, li_options].) So we recursively search the
+            # descendant menu(s) of this item.
+            menu_matches_current_path?(items[2])
+          end
+        end.nil?
+      end
+      
+      # Recursive
+      #def sub_menu_contains_current_path?(items)
+      #  !items.detect do |item|
+      #    if current_path?(item[1])
+      #      true
+      #    elsif item[2].is_a?(Array)
+      #      sub_menu_contains_current_path?(item[2])
+      #    elsif item[3].is_a?(Array)
+      #      sub_menu_contains_current_path?(item[3])
+      #    else
+      #      false
+      #    end
+      #  end.nil?
+      #end
+      
+      # Recursive
+      def ul(items, depth)
+        # If we're in the outermost menu, add any passed-in <ul> attributes
+        ul_options = (
+          depth == 0 ?
+          (@ctx._limit_options(@options, %w(id class)) do |key, value|
+            key.to_s.start_with?('data-')
+          end) :
+          {}
+        )
+        
+        @ctx.content_tag('ul', ul_options) do
+          items.inject('') do |lis, item|
+            text = item.shift
+            path = item.shift
+            
+            # After the text and path, there are two optional parameters: Sub-menu (an array)
+            # and <li> options (a hash). If both exist, they must come in that order. But either
+            # one can exist without the other.
+            #
+            # Initialiy, sub_menu and li_attrs are set to default values. These have a chance to
+            # be overwritten when we look at the third and fourth parameters.
+            
+            sub_menu = nil
+            li_attrs = {}
+            
+            third = item.shift
+            fourth = item.shift
+            
+            case third
+            when Array
+              sub_menu = third
+              if fourth.is_a?(Hash)
+                li_attrs = fourth
+              end
+            when Hash
+              li_attrs.merge!(third)
+            end
+            
+            # If the path has a leading slash, consider it absolute and prepend it with
+            # relative_url_root. Otherwise, it's a relative URL, so do nothing to it.
+            path = @ctx.normalize_path(path)
+            
+            # Create the <li>, and recur for the sub-menu if applicable
+            lis << @ctx.content_tag('li', li_attrs) do
+              li_inner_html = ''
+              
+              # Create the <a> or <span> tag for this item.
+              if current_path?(path)
+                li_inner_html << @ctx.content_tag('span', text, 'class' => 'selected')
+              else
+                if current_path_starts_with?(path)
+                  a_attrs = {'class' => 'ancestor_of_selected'}
+                else
+                  a_attrs = {}
+                end
+                li_inner_html << @ctx.link_to(text, path, a_attrs)
+              end
+            
+              # This item's sub-menu should be open if and only if:
+              #
+              # 1. we are at or inside the item's path; or
+              # 2. we are at or inside a path included in any of this item's descendant menus.
+              
+              if sub_menu
+                sub_menu_open = (
+                  current_path_starts_with?(path) or
+                  menu_matches_current_path?(sub_menu)
+                )
+              else
+                sub_menu_open = false
+              end
+              
+              # If the sub-menu is open, then we recursively generate its HTML
+              # and append it to this <li>.
+              if sub_menu_open
+                li_inner_html << ul(sub_menu, depth + 1)
+              end
+              
+              li_inner_html
+            end
+            
+            #lis << @ctx.content_tag('li', li_attrs) do
+            #  in_sub_path = (path != '/' and @options[:consider_sub_paths] and @ctx.path_with_slashes(@ctx.current_path).start_with?(@ctx.path_with_slashes(path)))
+            #  if current_path?(path)
+            #    li_inner_html = @ctx.content_tag('span', text, 'class' => 'selected')
+            #  elsif (sub_menu and sub_menu_contains_current_path?(sub_menu)) or in_sub_path
+            #    li_inner_html = @ctx.link_to(text, path, 'class' => 'ancestor_of_selected')
+            #  else
+            #    li_inner_html = @ctx.link_to(text, path)
+            #  end
+            #  if sub_menu and (current_path?(path) or sub_menu_contains_current_path?(sub_menu) or in_sub_path)
+            #    li_inner_html << ul(sub_menu, depth + 1)
+            #  end
+            #  li_inner_html
+            #end
+            lis
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ichiban/project_generator.rb

@@ -0,0 +1,16 @@
+module Ichiban
+  class ProjectGenerator
+    # The path to the empty project template in the Ichiban gem directory
+    def empty_project_path
+      File.expand_path(File.join(File.dirname(__FILE__), '../../empty_project'))
+    end
+    
+    def initialize(path)
+      @path = path
+    end
+    
+    def generate
+      FileUtils.cp_r(empty_project_path, @path)
+    end
+  end
+end

data/lib/ichiban/scripts.rb

@@ -0,0 +1,91 @@
+module Ichiban
+  def self.script_runner
+    @script_runner ||= Ichiban::ScriptRunner.new
+  end
+  
+  class ScriptRunner
+    # Takes an absolute path. Consults the dependencies graph.
+    def data_file_changed(path)
+      # Add one to the length to remove the leading slash
+      rel_to_root = path.slice(Ichiban.project_root.length + 1..-1)
+      dep_graph = Ichiban::Dependencies.graph(self.class.dep_graph_path)
+      if deps = dep_graph[rel_to_root]
+        deps.each do |dep|
+          Ichiban.logger.script_run(path, File.join(Ichiban.project_root, dep))
+          Ichiban::Script.new(
+            File.join(Ichiban.project_root, dep)
+          ).run
+        end
+      end
+    end
+    
+    def self.dep_graph_path
+      '.script_dependencies.json'
+    end
+    
+    # Takes an absolute path
+    def script_file_changed(path)
+      Ichiban.logger.script_run(path, path)
+      script = Ichiban::Script.new(path).run
+    end
+  end
+  
+  class Script
+    # Every file that the script depends on (e.g. a data file) should be declared with this method.
+    # This is how Ichiban knows to re-run the script when one of the files changes. Pass in a path
+    # relative to the project root.
+    #
+    # However, you don't need to declare dependencies for the templates the script uses. Those will\
+    # automatically be tracked.
+    def depends_on(ind_path)
+      if ind_path.start_with?('/')
+        raise(ArgumentError, 'depends_on must be passed a path relative to the project root, e.g. "data/employees.xml"')
+      end
+      # Format in dependency graph: 'data/employees.json' => 'scripts/generate_employees.rb'
+      Ichiban::Dependencies.update(
+        Ichiban::ScriptRunner.dep_graph_path,
+        
+        # Path to independent file, relative to project root.
+        ind_path,
+        
+        # Path to dependent file (i.e. this script), relative to project root.
+        # Add one to the length to remove the leading slash.
+        @path.slice(Ichiban.project_root.length + 1..-1)
+      )
+    end
+    
+    # Automatically appends .html to dest_path
+    def generate(template_path, dest_path, ivars)
+      dest_path += '.html'
+      web_path = '/' + File.basename(dest_path, File.extname(dest_path)) + '/'
+      compiler = Ichiban::HTMLCompiler.new(
+        Ichiban::HTMLFile.new(
+          File.join('html', template_path)
+        )
+      )
+      compiler.ivars = {:_current_path => web_path}.merge(ivars)
+      html = compiler.compile_to_str
+      File.open(File.join(Ichiban.project_root, 'compiled', dest_path), 'w') do |f|
+        f << html
+      end
+      Ichiban.logger.compilation(
+        File.join(Ichiban.project_root, 'html', template_path),
+        File.join(Ichiban.project_root, 'compiled', dest_path)
+      )
+    end
+    
+    # Takes an absolute path
+    def initialize(path)
+      @path = path
+    end
+    
+    attr_reader :path
+    
+    def run
+      instance_eval(
+        File.read(@path),
+        @path
+      )
+    end
+  end
+end

data/lib/ichiban/watcher.rb

@@ -6,31 +6,48 @@ module Ichiban
       }.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
+    def start(blocking = true)
+      @loader = Ichiban::Loader.new
+      
+      Ichiban.logger.out 'Starting watcher'
+      begin
+        @listener = Listen.to(
+          File.join(Ichiban.project_root, 'html'),
+          File.join(Ichiban.project_root, 'layouts'),
+          File.join(Ichiban.project_root, 'assets'),
+          File.join(Ichiban.project_root, 'models'),
+          File.join(Ichiban.project_root, 'helpers'),
+          File.join(Ichiban.project_root, 'scripts'),
+          File.join(Ichiban.project_root, 'data'),
+          File.join(Ichiban.project_root, 'webserver')
+        )
+        .ignore(/.listen_test$/)
+        .latency(@options[:latency])
+        .change do |modified, added, deleted|
+          (modified + added).uniq.each do |path|
+            if file = Ichiban::ProjectFile.from_abs(path)
+              @loader.change(file) # Tell the Loader that this file has changed
+              begin
+                file.update
+              rescue => exc
+                Ichiban.logger.exception(exc)
+              end
             end
-          end          
-        rescue => exc
-          Ichiban.logger.exception(exc)
+          end                    
+          deleted.each do |path|
+            Ichiban::Deleter.new.delete_dest(path)
+          end
         end
-        deleted.each do |path|
-          Ichiban::Deleter.new.delete(path)
-        end
-      end.start(false) # nonblocking
+        @listener.start(blocking)
+      rescue Interrupt
+        Ichiban.logger.out "Stopping watcher"
+        exit 0
+      end
     end
     
     def stop
       if @listener
+        Ichiban.logger.out "Stopping watcher"
         @listener.stop
         @listener = nil
       end

data/lib/ichiban.rb

@@ -4,30 +4,42 @@ 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/core_ext/class/attribute'
+#require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/array/extract_options'
 require 'active_support/inflector'
 require 'sass'
 require 'listen'
 require 'erubis'
 require 'rake'
+require 'bundler'
 
 # Ichiban files. Order matters!
+require 'ichiban/bundle'
 require 'ichiban/config'
 require 'ichiban/logger'
 require 'ichiban/command'
+require 'ichiban/project_generator'
+require 'ichiban/dependencies'
+require 'ichiban/loader'
 require 'ichiban/watcher'
 require 'ichiban/deleter'
 require 'ichiban/file'
 require 'ichiban/helpers'
+require 'ichiban/nav_helper'
 require 'ichiban/html_compiler'
+require 'ichiban/asset_compiler'
 require 'ichiban/markdown'
-require 'ichiban/dependencies'
-require 'ichiban/helpers'
+require 'ichiban/scripts'
 
 module Ichiban
   # In addition to setting the variable, this loads the config file
   def self.project_root=(path)
+    unless @project_root == path
+      # If we're changing the project root, then we need to clear all dependency graphs from memory.
+      # This doesn't delete any files.
+      Ichiban::Dependencies.clear_graphs
+    end
     @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