pith 0.2.3 → 0.3.0

data/bin/pith

@@ -48,8 +48,6 @@ class PithCommand < Clamp::Command
 
   subcommand "serve", "Serve the generated website" do
     def execute
-      build
-      Thread.new { watch }
       serve
     end
   end
@@ -65,16 +63,17 @@ class PithCommand < Clamp::Command
   end
 
   def project
-    unless @project
+    @project ||= begin
       pith_dir = input_dir + "_pith"
       unless pith_dir.directory?
         signal_usage_error %(No "#{pith_dir}" directory ... this doesn't look right!)
       end
       puts %{Generating to "#{output_dir}"}
-      @project = Pith::Project.new(:input_dir => input_dir, :output_dir => output_dir)
-      @project.logger = Pith::ConsoleLogger.new
+      @project = Pith::Project.new(
+        :input_dir => input_dir, :output_dir => output_dir,
+        :logger => Pith::ConsoleLogger.new
+      )
     end
-    @project
   end
 
   def build

data/features/relative_linking.feature

@@ -10,12 +10,12 @@ Background:
 
 Scenario: link from one top-level page to another
 
-  Given input file "index.html.haml" contains 
+  Given input file "index.html.haml" contains
     """
     = link("page.html", "Page")
     """
   And input file "page.html" exists
-   
+
   When I build the site
   Then output file "index.html" should contain
     """
@@ -93,7 +93,7 @@ Scenario: links included from a partial
 
 Scenario: use "title" meta-data attribute in link
 
-  Given input file "index.html.haml" contains 
+  Given input file "index.html.haml" contains
     """
     = link("page.html")
     """
@@ -117,7 +117,7 @@ Scenario: link to an Input object
 
   Given input file "subdir/page.html.haml" contains
     """
-    = link(project.input("help.html"))
+    = link(project.input("help.html.haml"))
     """
 
   And input file "help.html.haml" contains
@@ -135,11 +135,11 @@ Scenario: link to an Input object
 
 Scenario: link to a missing resource
 
-  Given input file "index.html.haml" contains 
+  Given input file "index.html.haml" contains
     """
     = link("missing_page.html")
     """
-   
+
   When I build the site
   Then output file "index.html" should contain
     """
@@ -149,11 +149,11 @@ Scenario: link to a missing resource
 Scenario: assume content negotiation
 
   Given the "assume_content_negotiation" flag is enabled
-  And input file "index.html.haml" contains 
+  And input file "index.html.haml" contains
     """
     = link("page.html", "Page")
     """
-   
+
   When I build the site
   Then output file "index.html" should contain
     """
@@ -164,11 +164,11 @@ Scenario: link to an index page
 
   Given the "assume_directory_index" flag is enabled
 
-  And input file "page.html.haml" contains 
+  And input file "page.html.haml" contains
     """
     = link("stuff/index.html", "Stuff")
     """
-   
+
   When I build the site
   Then output file "page.html" should contain
     """
@@ -179,11 +179,11 @@ Scenario: link to an index page in the same directory
 
   Given the "assume_directory_index" flag is enabled
 
-  And input file "page.html.haml" contains 
+  And input file "page.html.haml" contains
     """
     = link("index.html", "Index")
     """
-   
+
   When I build the site
   Then output file "page.html" should contain
     """

data/lib/pith/console_logger.rb

@@ -1,27 +1,34 @@
 module Pith
-  
+
   class ConsoleLogger
-    
+
     def initialize(out = STDOUT, err = STDERR)
       @out = out
       @err = err
     end
 
-    def info(message, &block)
+    def debug(message = nil, &block)
+      if ENV["PITH_DEBUG"]
+        message ||= block.call
+        @out.puts("DEBUG: " + message)
+      end
+    end
+
+    def info(message = nil, &block)
       message ||= block.call
       @out.puts(message)
     end
 
-    def warn(message, &block)
+    def warn(message = nil, &block)
       message ||= block.call
       @err.puts(message)
     end
 
-    def error(message, &block)
+    def error(message = nil, &block)
       message ||= block.call
       @err.puts("ERROR: " + message)
     end
-    
+
   end
-  
-end
+
+end

data/lib/pith/input.rb

@@ -1,49 +1,34 @@
 require "fileutils"
 require "pathname"
-require "pith/render_context"
+require "observer"
+require "pith/output"
 require "tilt"
 require "yaml"
 
 module Pith
+
   class Input
 
+    include Observable
+
     def initialize(project, path)
       @project = project
       @path = path
-      @meta = {}
       determine_pipeline
-      load unless resource?
+      when_created
     end
 
     attr_reader :project, :path
 
     attr_reader :output_path
-    attr_reader :dependencies
     attr_reader :pipeline
-    attr_reader :error
 
     # Public: Get the file-system location of this input.
     #
     # Returns a fully-qualified Pathname.
     #
     def file
-      project.input_dir + path
-    end
-
-    # Public: Get the file-system location of the corresponding output file.
-    #
-    # Returns a fully-qualified Pathname.
-    #
-    def output_file
-      project.output_dir + output_path
-    end
-
-    # Public: Generate an output file.
-    #
-    def build
-      return false if ignorable? || uptodate?
-      logger.info("--> #{output_path}")
-      generate_output
+      @file ||= project.input_dir + path
     end
 
     # Consider whether this input can be ignored.
@@ -51,45 +36,32 @@ module Pith
     # Returns true if it can.
     #
     def ignorable?
-      path.each_filename do |path_component|
+      @ignorable ||= path.each_filename do |path_component|
         project.ignore_patterns.each do |pattern|
           return true if File.fnmatch(pattern, path_component)
         end
       end
     end
 
-    # Check whether output is up-to-date.
+    # Determine whether this input is a template, requiring evaluation.
     #
-    # Return true unless output needs to be re-generated.
+    # Returns true if it is.
     #
-    def uptodate?
-      dependencies && FileUtils.uptodate?(output_file, dependencies)
+    def template?
+      !pipeline.empty?
     end
 
-    # Generate output for this template
-    #
-    def generate_output
-      output_file.parent.mkpath
-      return FileUtils.copy(file, output_file) if resource?
-      render_context = RenderContext.new(project)
-      output_file.open("w") do |out|
-        begin
-          @error = nil
-          out.puts(render_context.render(self))
-        rescue StandardError, SyntaxError => e
-          @error = e
-          logger.warn exception_summary(e, :max_backtrace => 5)
-          out.puts "<pre>"
-          out.puts exception_summary(e)
-        end
+    def output
+      unless ignorable?
+        @output ||= Output.for(self, @output_path)
       end
-      @dependencies = render_context.dependencies
     end
 
     # Render this input using Tilt
     #
     def render(context, locals = {}, &block)
-      return file.read if resource?
+      return file.read if !template?
+      ensure_loaded
       @pipeline.inject(@template_text) do |text, processor|
         template = processor.new(file.to_s, @template_start_line) { text }
         template.render(context, locals, &block)
@@ -116,6 +88,7 @@ module Pith
     # Returns a Hash.
     #
     def meta
+      ensure_loaded
       @meta
     end
 
@@ -153,6 +126,39 @@ module Pith
       end
     end
 
+    # Synchronise the state of the Input with the filesystem
+    #
+    # Returns true if the file still exists.
+    #
+    def sync
+      mtime = file.mtime
+      if mtime.to_i > @last_mtime.to_i
+        @last_mtime = mtime
+        when_changed
+      end
+      true
+    rescue Errno::ENOENT => e
+      when_deleted
+      nil
+    end
+
+    def when_created
+      log_lifecycle "+"
+      @last_mtime = file.mtime
+    end
+
+    def when_changed
+      log_lifecycle "~"
+      unload if loaded?
+      changed(true)
+      notify_observers
+    end
+
+    def when_deleted
+      log_lifecycle "X"
+      output.delete if output
+    end
+
     private
 
     def default_title
@@ -163,36 +169,45 @@ module Pith
       @pipeline = []
       remaining_path = path.to_s
       while remaining_path =~ /^(.+)\.(.+)$/
-        if Tilt[$2]
+        if handler = Tilt[$2]
           remaining_path = $1
-          @pipeline << Tilt[$2]
+          @pipeline << handler
         else
           break
         end
       end
       @output_path = Pathname(remaining_path)
-      if resource?
-        @dependencies = [file]
-      end
     end
 
-    def resource?
-      pipeline.empty?
+    def loaded?
+      @load_time
+    end
+
+    # Make sure we've loaded the input file.
+    #
+    def ensure_loaded
+      load unless loaded?
     end
 
     # Read input file, extracting YAML meta-data header, and template content.
     #
     def load
-      file.open do |input|
-        load_meta(input)
-        load_template(input)
+      @load_time = Time.now
+      @meta = {}
+      if template?
+        logger.debug "loading #{path}"
+        file.open do |io|
+          read_meta(io)
+          @template_start_line = io.lineno + 1
+          @template_text = io.read
+        end
       end
     end
 
-    def load_meta(input)
-      header = input.gets
+    def read_meta(io)
+      header = io.gets
       if header =~ /^---/
-        while line = input.gets
+        while line = io.gets
           break if line =~ /^(---|\.\.\.)/
           header << line
         end
@@ -202,25 +217,25 @@ module Pith
           logger.warn "#{file}:1: badly-formed YAML header"
         end
       else
-        input.rewind
+        io.rewind
       end
     end
 
-    def load_template(input)
-      @template_start_line = input.lineno + 1
-      @template_text = input.read
-    end
-
-    def exception_summary(e, options = {})
-      max_backtrace = options[:max_backtrace] || 999
-      trimmed_backtrace = e.backtrace[0, max_backtrace]
-      (["#{e.class}: #{e.message}"] + trimmed_backtrace).join("\n    ") + "\n"
+    # Note that the input file has changed, so we'll need to re-load it.
+    #
+    def unload
+      logger.debug "unloading #{path}"
+      @load_time = nil
     end
 
     def logger
       project.logger
     end
 
+    def log_lifecycle(state)
+      logger.info("#{state} #{path}")
+    end
+
   end
 
 end

data/lib/pith/output.rb

@@ -0,0 +1,107 @@
+require "fileutils"
+require "pith/render_context"
+require "set"
+
+module Pith
+
+  class Output
+
+    def self.for(input, path)
+      new(input, path)
+    end
+
+    def initialize(input, path)
+      @input = input
+      @path = path
+    end
+
+    attr_reader :input
+    attr_reader :error
+    attr_reader :path
+
+    def project
+      input.project
+    end
+
+    def file
+      @file ||= project.output_dir + path
+    end
+
+    # Generate output for this template
+    #
+    def build
+      return false if @generated
+      logger.info("--> #{path}")
+      @dependencies = Set.new
+      file.parent.mkpath
+      if input.template?
+        evaluate_template
+      else
+        copy_resource
+      end
+      @generated = true
+    end
+
+    def record_dependency_on(*inputs)
+      inputs.each do |input|
+        @dependencies << input
+        input.add_observer(self)
+      end
+    end
+
+    def delete
+      invalidate
+      logger.info("--X #{path}")
+      FileUtils.rm_f(file)
+    end
+
+    def update # called by dependencies that change
+      invalidate
+    end
+
+    private
+
+    def invalidate
+      if @generated
+        @dependencies.each do |d|
+          d.delete_observer(self)
+        end
+        @dependencies = nil
+        @generated = nil
+      end
+    end
+
+    def copy_resource
+      FileUtils.copy(input.file, file)
+      record_dependency_on(input)
+    end
+
+    def evaluate_template
+      render_context = RenderContext.new(self)
+      file.open("w") do |out|
+        begin
+          @error = nil
+          out.puts(render_context.render(input))
+        rescue StandardError, SyntaxError => e
+          @error = e
+          logger.warn exception_summary(e, :max_backtrace => 5)
+          out.puts "<pre>"
+          out.puts exception_summary(e)
+        end
+      end
+      record_dependency_on(*project.config_inputs)
+    end
+
+    def logger
+      project.logger
+    end
+
+    def exception_summary(e, options = {})
+      max_backtrace = options[:max_backtrace] || 999
+      trimmed_backtrace = e.backtrace[0, max_backtrace]
+      (["#{e.class}: #{e.message}"] + trimmed_backtrace).join("\n    ") + "\n"
+    end
+
+  end
+
+end