pith 0.0.2

data/features/support/env.rb~

@@ -0,0 +1,43 @@
+require "pathname"
+
+class DirHash
+  
+  def initialize(dir)
+    @dir = Pathname(dir)
+  end
+
+  def [](file_name)
+    file_path = @dir + file_name
+    file_path.read if file_path.exist?
+  end
+
+  def []=(file_name, content)
+    file_path = @dir + file_name
+    file_path.parent.mkpath
+    file_path.open("w") do |io|
+      io << content
+    end
+  end
+  
+end
+
+$project_dir = Pathname(__FILE__).expand_path.parent.parent.parent
+$tmp_dir = $project_dir + "tmp"
+
+$input_dir = $tmp_dir + "input"
+
+$output_dir = $tmp_dir + "output"
+$output_dir.mkpath
+
+$: << ($project_dir + "lib").to_s
+require "pith"
+
+Before do
+  [$input_dir, $output_dir].each do |dir|
+    dir.rmtree if dir.exist?
+    dir.mkpath
+  end
+  @project = Pith::Project.new(:input_dir => $input_dir, :output_dir => $output_dir)
+  @inputs = DirHash.new($input_dir)
+  @outputs = DirHash.new($output_dir)
+end

data/features/support/rspec_matchers.rb

@@ -0,0 +1,5 @@
+Spec::Matchers.define :contain do |expected|
+  match do |actual|
+    actual.any? { |x| expected === x }
+  end
+end

data/features/textile.feature

@@ -0,0 +1,29 @@
+Feature: support for Textile markup
+
+  I want to use Textile fragments in pages
+  So that I can express content succintly
+  
+Scenario: Haml page with embedded Textile
+
+  Given input file "page.html.haml" contains
+    """
+    :textile
+
+      A paragraph.
+      
+      * one
+      * two
+      * three    
+    """
+    
+  When I build the site
+  
+  Then output file "page.html" should contain
+    """
+    <p>A paragraph.</p>
+    <ul>
+      <li>one</li>
+      <li>two</li>
+      <li>three</li>
+    </ul>
+    """

data/features/textile.feature~

@@ -0,0 +1,29 @@
+Feature: support for Textile markup
+
+  I want to use Textile fragments in pages
+  So that I can express content succintly
+  
+Scenario: Haml page with embedded Textile
+
+  Given input file "page.html.haml" contains
+    """
+    :textile
+
+      A paragraph.
+      
+      * one
+      * two
+      * three    
+    """
+    
+  When I build the site
+  
+  Then output file "page.html" should contain
+    """
+    <p>A paragraph.</p>
+    <ul>
+      <li>one</li>
+      <li>two</li>
+      <li>three</li>
+    </ul>
+    """

data/features/verbatim.feature

@@ -0,0 +1,32 @@
+Feature: unrecognised input files are copied into output intact
+
+  I want any unrecognised file to be copied into the site verbatim
+  So that I can mix dynamic and static content
+  
+Scenario: text file
+
+  Given input file "verbatim.txt" contains
+    """
+    Blah de blah
+    """
+    
+  When I build the site
+  
+  Then output file "verbatim.txt" should contain
+    """
+    Blah de blah
+    """
+
+Scenario: file in subdirectory
+
+  Given input file "blah/verbatim.txt" contains
+    """
+    Blah de blah
+    """
+    
+  When I build the site
+  
+  Then output file "blah/verbatim.txt" should contain
+    """
+    Blah de blah
+    """

data/features/verbatim.feature~

@@ -0,0 +1,32 @@
+Feature: unrecognised input files are copied into output intact
+
+  I want any unrecognised file to be copied into the site verbatim
+  So that I can mix dynamic and static content
+  
+Scenario: text file
+
+  Given input file "verbatim.txt" contains
+    """
+    Blah de blah
+    """
+    
+  When I build the site
+  
+  Then output file "verbatim.txt" should contain
+    """
+    Blah de blah
+    """
+
+Scenario: file in subdirectory
+
+  Given input file "blah/verbatim.txt" contains
+    """
+    Blah de blah
+    """
+    
+  When I build the site
+  
+  Then output file "blah/verbatim.txt" should contain
+    """
+    Blah de blah
+    """

data/lib/pith.rb

@@ -0,0 +1 @@
+require 'pith/project'

data/lib/pith.rb~

@@ -0,0 +1,2 @@
+require 'pith/console_logger'
+require 'pith/project'

data/lib/pith/console_logger.rb

@@ -0,0 +1,20 @@
+module Pith
+  
+  class ConsoleLogger
+    
+    def initialize(io = STDOUT)
+      @io = io
+    end
+
+    def info(message, &block)
+      message ||= block.call
+      @io.puts(message)
+    end
+    
+    def write(message)
+      @io.puts(message)
+    end
+    
+  end
+  
+end

data/lib/pith/console_logger.rb~

@@ -0,0 +1,20 @@
+module Pith
+  
+  class ConsoleLogger
+    
+    def initialize(io = STDOUT)
+      @io = io
+    end
+
+    def info(message, &block)
+      message ||= block.call
+      @io.puts(message)
+    end
+    
+    def write(message)
+      @io.puts(message)
+    end
+    
+  end
+  
+end

data/lib/pith/input.rb

@@ -0,0 +1,189 @@
+require "pith/render_context"
+require "pith/metadata"
+require "fileutils"
+
+module Pith
+  module Input
+
+    class << self
+
+      def new(project, path)
+        if path.to_s =~ /^(.*)\.(.*)$/ && RenderContext.can_render?($2)
+          Template.new(project, path)
+        else
+          Verbatim.new(project, path)
+        end
+      end
+
+    end
+
+    class Abstract
+
+      def initialize(project, path)
+        @project = project
+        @path = path
+      end
+
+      attr_reader :project, :path
+
+      # Public: Get the file-system location of this input.
+      #
+      # Returns a fully-qualified Pathname.
+      #
+      def full_path
+        project.input_dir + path
+      end
+
+      # Public: Get YAML metadata declared in the header of of a template.
+      # 
+      # The first line of the template must end with "---".  Any preceding characters
+      # are considered to be a comment prefix, and are stripped from the following
+      # lines.  The metadata block ends when the comment block ends, or a line ending
+      # with "..." is encountered.
+      #
+      # Examples
+      #
+      #   Given input starting with:
+      #
+      #     -# ---
+      #     -# published: 2008-09-15
+      #     -# ...
+      #
+      #   input.meta
+      #   #=> { "published" => "2008-09-15" }
+      #  
+      # Returns a Hash.
+      #
+      def meta
+        if @metadata.nil?
+          full_path.open do |io|
+            @metadata = Pith::Metadata.extract_from(io).freeze
+          end
+        end
+        @metadata
+      end
+
+      # Public: Generate a corresponding output file.
+      #
+      # Returns the output Pathname.
+      # Returns nil if no output was generated.
+      #
+      def build
+        generate_output unless ignorable? || uptodate?
+      end
+
+      # Public: Resolve a reference relative to this input.
+      #
+      # href - a String referencing another asset
+      #
+      # An href starting with "/" is resolved relative to the project root;
+      # anything else is resolved relative to this input.
+      #
+      # Returns a fully-qualified Pathname of the asset.
+      #
+      def relative_path(href)
+        href = href.to_str
+        if href[0,1] == "/"
+          Pathname(href[1..-1])
+        else
+          path.parent + href
+        end
+      end
+
+      # Resolve a reference relative to this input.
+      #
+      # href - a String referencing another asset
+      #
+      # Returns the referenced Input.
+      #
+      def relative_input(href)
+        project.input(relative_path(href))
+      end
+
+      # Consider whether this input can be ignored.
+      #
+      # Returns true if it can.
+      #
+      def ignorable?
+        path.to_s.split("/").any? { |component| component.to_s[0,1] == "_" }
+      end
+
+      protected
+
+      def logger
+        project.logger
+      end
+
+      def trace(strategy, output_path = nil)
+        output_path ||= "X"
+        logger.info("%-36s%-14s%s" % [path, "--(#{strategy})-->", output_path])
+      end
+
+    end
+
+    class Template < Abstract
+      
+      def initialize(project, path)
+        super(project, path)
+        path.to_s =~ /^(.*)\.(.*)$/
+        @output_path = $1
+        @type = $2
+      end
+
+      attr_reader :output_path, :type
+      
+      def full_output_path
+        project.output_dir + output_path
+      end
+      
+      def uptodate?
+        return false if all_input_paths.nil?
+        FileUtils.uptodate?(full_output_path, all_input_paths)
+      end
+      
+      # Render this input using Tilt
+      #
+      def generate_output
+        trace(type, output_path)
+        full_output_path.parent.mkpath
+        render_context = RenderContext.new(project)
+        full_output_path.open("w") do |out|
+          out.puts(render_context.render(self))
+        end
+        remember_dependencies(render_context.rendered_inputs)
+      end
+
+      private
+
+      def remember_dependencies(rendered_inputs)
+        @all_input_paths = rendered_inputs.map { |input| input.full_path }
+      end
+
+      def all_input_paths
+        @all_input_paths
+      end
+      
+    end
+
+    class Verbatim < Abstract
+
+      def full_output_path
+        project.output_dir + path
+      end
+      
+      def uptodate?
+        FileUtils.uptodate?(full_output_path, [full_path])
+      end
+      
+      # Copy this input verbatim into the output directory
+      #
+      def generate_output
+        trace("copy", path)
+        full_output_path.parent.mkpath
+        FileUtils.copy(full_path, full_output_path)
+      end
+      
+    end
+    
+  end
+end

data/lib/pith/input.rb~

@@ -0,0 +1,95 @@
+require "tilt"
+require "pith/output_context"
+require "pith/metadata"
+
+module Pith
+  
+  class Input
+    
+    def initialize(project, path)
+      @project = project
+      @path = path
+    end
+
+    attr_reader :project, :path
+    
+    def build
+      ignore || evaluate_as_tilt_template || copy_verbatim
+    end
+
+    def relative_input(name)
+      resolved_path = relative_path(name)
+      input = project.inputs.find do |input|
+        input.path == resolved_path
+      end
+      raise %{can't locate "#{resolved_path}"} if input.nil?
+      input
+    end
+    
+    def relative_path(name)
+      name = name.to_str
+      if name[0,1] == "/"
+        Pathname(name[1..-1])
+      else
+        path.parent + name
+      end
+    end
+    
+    def render(context, locals = {}, &block)
+      Tilt.new(full_path).render(context, locals, &block)
+    end
+
+    def meta
+      if @metadata.nil?
+        full_path.open do |io|
+          @metadata = Pith::Metadata.extract_from(io).freeze
+        end
+      end
+      @metadata
+    end
+    
+    private
+
+    def logger
+      project.logger
+    end
+
+    def trace(strategy, output_path = nil)
+      output_path ||= "X"
+      logger.info("%-36s%-14s%s" % [path, "--(#{strategy})-->", output_path])
+    end
+    
+    def full_path
+      project.input_dir + path
+    end
+    
+    def ignore
+      path.to_s.split("/").any? { |component| component.to_s[0,1] == "_" }
+    end
+    alias :ignorable? :ignore
+    
+    def evaluate_as_tilt_template
+      if path.to_s =~ /^(.*)\.(.*)$/ && Tilt.registered?($2)
+        output_path = Pathname($1); ext = $2
+        trace(ext, output_path)
+        output_file = project.output_dir + output_path
+        output_file.parent.mkpath
+        output_file.open("w") do |out|
+          output = render(RenderContext.new(self))
+          out.puts(output)
+        end
+        output_file
+      end
+    end
+
+    def copy_verbatim
+      trace("copy", path)
+      output_path = project.output_dir + path
+      output_path.parent.mkpath
+      FileUtils.copy(full_path, output_path)
+      output_path
+    end
+
+  end
+  
+end