pith 0.2.3 → 0.3.0

data/lib/pith/pathname_ext.rb

@@ -12,5 +12,10 @@ class Pathname
       path.file?
     end
   end
-  
+
+  def in?(dir)
+    prefix = "#{dir}/"
+    self.to_s[0,prefix.length] == prefix
+  end
+
 end

data/lib/pith/project.rb

@@ -2,13 +2,14 @@ require "logger"
 require "pith/input"
 require "pith/pathname_ext"
 require "pith/reference_error"
+require "set"
 require "tilt"
 
 module Pith
 
   class Project
 
-    DEFAULT_IGNORE_PATTERNS = ["_*", ".git", ".svn", "*~"].freeze
+    DEFAULT_IGNORE_PATTERNS = ["_*", ".git", ".gitignore", ".svn", ".sass-cache", "*~", "*.sw[op]"].to_set.freeze
 
     def initialize(attributes = {})
       @ignore_patterns = DEFAULT_IGNORE_PATTERNS.dup
@@ -28,63 +29,89 @@ module Pith
 
     def output_dir=(dir)
       @output_dir = Pathname(dir)
+      FileUtils.rm_rf(@output_dir)
+      @output_dir.mkpath
     end
 
     attr_accessor :assume_content_negotiation
     attr_accessor :assume_directory_index
 
+    def ignore(pattern)
+      ignore_patterns << pattern
+    end
+
     # Public: get inputs
     #
     # Returns Pith::Input objects representing the files in the input_dir.
     #
-    # The list of inputs is cached after first load;
-    #   call #refresh to discard the cached data.
-    #
     def inputs
-      @inputs ||= input_dir.all_files.map do |input_file|
-        path = input_file.relative_path_from(input_dir)
-        find_or_create_input(path)
-      end.compact
+      @input_map.values
+    end
+
+    # Public: get outputs
+    #
+    # Returns Pith::Output objects representing the files in the output_dir.
+    #
+    def outputs
+      inputs.map(&:output).compact
     end
 
     # Public: find an input.
     #
-    # path - an path relative to either input_dir or output_dir
+    # path - an path relative to input_dir
     #
-    # Returns the first input whose input_path or output_path matches.
+    # Returns the first input whose path matches.
     # Returns nil if no match is found.
     #
     def input(path)
-      path = Pathname(path)
-      inputs.each do |input|
-        return input if input.path == path || input.output_path == path
-      end
-      nil
+      @input_map[Pathname(path)]
+    end
+
+    # Public: find an output.
+    #
+    # path - an path relative to output_dir
+    #
+    # Returns the first output whose path matches.
+    # Returns nil if no match is found.
+    #
+    def output(path)
+      @output_map[Pathname(path)]
     end
 
     # Public: build the project, generating output files.
     #
     def build
-      refresh
-      load_config
-      remove_old_outputs
+      sync
       output_dir.mkpath
-      generate_outputs
+      outputs.each(&:build)
       output_dir.touch
     end
 
-    # Public: discard cached data that is out-of-sync with the file-system.
+    # Public: re-sync with the file-system.
     #
-    def refresh
-      @inputs = nil
-      @config_files = nil
+    def sync
+      @input_map ||= {}
+      @output_map ||= {}
+      @config_inputs = nil
+      load_config
+      validate_known_inputs
+      find_new_inputs
+    end
+
+    def sync_every(period)
+      @next_sync ||= 0
+      now = Time.now.to_i
+      if now >= @next_sync
+        sync
+        @next_sync = now + period
+      end
     end
 
     # Public: check for errors.
     #
     # Returns true if any errors were encountered during the last build.
     def has_errors?
-      @inputs.any?(&:error)
+      inputs.map(&:output).compact.any?(&:error)
     end
 
     def last_built_at
@@ -105,10 +132,10 @@ module Pith
       @helper_module ||= Module.new
     end
 
-    def config_files
-      @config_files ||= begin
-        input_dir.all_files("_pith/**")
-      end.to_set
+    def config_inputs
+      @config_inputs ||= inputs.select do |input|
+        input.path.to_s[0,6] == "_pith/"
+      end
     end
 
     private
@@ -121,35 +148,33 @@ module Pith
       end
     end
 
-    def remove_old_outputs
-      valid_output_paths = inputs.map { |i| i.output_path }
-      output_dir.all_files.each do |output_file|
-        output_path = output_file.relative_path_from(output_dir)
-        unless valid_output_paths.member?(output_path)
-          logger.info("removing        #{output_path}")
-          FileUtils.rm(output_file)
-        end
+    def load_input(path)
+      i = Input.new(self, path)
+      @input_map[path] = i
+      if o = i.output
+        @output_map[o.path] = o
       end
+      i
     end
 
-    def generate_outputs
-      inputs.each do |input|
-        input.build
+    def validate_known_inputs
+      invalid_inputs = inputs.select { |i| !i.sync }
+      invalid_inputs.each do |i|
+        @input_map.delete(i.path)
+        if o = i.output
+          @output_map.delete(o.path)
+        end
       end
     end
 
-    def input_cache
-      @input_cache ||= Hash.new do |h, cache_key|
-        h[cache_key] = Input.new(self, cache_key.first)
+    def find_new_inputs
+      input_dir.all_files.map do |input_file|
+        next if input_file.in?(output_dir)
+        path = input_file.relative_path_from(input_dir)
+        input(path) || load_input(path)
       end
     end
 
-    def find_or_create_input(path)
-      file = input_dir + path
-      cache_key = [path, file.mtime]
-      input_cache[cache_key]
-    end
-
   end
 
 end

data/lib/pith/render_context.rb

@@ -5,20 +5,23 @@ require "set"
 require "tilt"
 
 module Pith
-  
+
   class RenderContext
-    
+
     include Tilt::CompileSite
-    
-    def initialize(project)
-      @project = project
+
+    def initialize(output)
+      @output = output
+      @page = @output.input
+      @project = @page.project
       @input_stack = []
-      @dependencies = project.config_files.dup
       self.extend(project.helper_module)
     end
 
+    attr_reader :output
+    attr_reader :page
     attr_reader :project
-    
+
     def page
       @input_stack.first
     end
@@ -26,7 +29,7 @@ module Pith
     def current_input
       @input_stack.last
     end
-    
+
     def render(input, locals = {}, &block)
       with_input(input) do
         result = input.render(self, locals, &block)
@@ -36,8 +39,6 @@ module Pith
       end
     end
 
-    attr_reader :dependencies
-    
     def include(template_ref, locals = {}, &block)
       content_block = if block_given?
         content = capture_haml(&block)
@@ -45,13 +46,13 @@ module Pith
       end
       render_ref(template_ref, locals, &content_block)
     end
-    
+
     alias :inside :include
-    
+
     def content_for
       @content_for_hash ||= Hash.new { "" }
     end
-    
+
     def relative_url_to(target_path)
       url = target_path.relative_path_from(page.path.parent).to_s
       url = url.sub(/index\.html$/, "") if project.assume_directory_index
@@ -59,46 +60,48 @@ module Pith
       url = "./" if url.empty?
       Pathname(url)
     end
-    
+
     def href(target_ref)
       relative_url_to(resolve_reference(target_ref))
     end
 
     def link(target_ref, label = nil)
       target_path = resolve_reference(target_ref)
-      label ||= begin 
+      label ||= begin
         target_input = input(target_path)
-        record_dependency_on(target_input.file)
+        output.record_dependency_on(target_input)
         target_input.title
       rescue ReferenceError
-        "???" 
+        "???"
       end
       url = relative_url_to(target_path)
       %{<a href="#{url}">#{label}</a>}
     end
 
-    def record_dependency_on(file)
-      @dependencies << file
-    end
-    
     private
-    
+
     def resolve_reference(ref)
-      if ref.respond_to?(:output_path)
-        ref.output_path
+      if ref.kind_of?(Pith::Input)
+        raise(ReferenceError, %{No output for "#{ref.path}"}) if ref.output.nil?
+        ref.output.path
       else
         current_input.resolve_path(ref)
       end
     end
-    
+
     def input(path)
-      input = project.input(path)
-      raise(ReferenceError, %{Can't find "#{path}"}) if input.nil?
-      input
+      project.input(path) ||
+      input_with_output_path(path) ||
+      raise(ReferenceError, %{Can't find "#{path}"})
+    end
+
+    def input_with_output_path(path)
+      o = project.output(path)
+      o ? o.input : nil
     end
-    
+
     def with_input(input)
-      record_dependency_on(input.file)
+      output.record_dependency_on(input)
       @input_stack.push(input)
       begin
         yield
@@ -106,12 +109,12 @@ module Pith
         @input_stack.pop
       end
     end
-    
+
     def render_ref(template_ref, locals = {}, &block)
       template_input = input(resolve_reference(template_ref))
       render(template_input, locals, &block)
     end
 
   end
-  
+
 end

data/lib/pith/server.rb

@@ -1,5 +1,6 @@
 require "rack"
-require "adsf/rack"
+require "pathname"
+require "thread"
 
 module Pith
 
@@ -10,29 +11,48 @@ module Pith
         use Rack::CommonLogger
         use Rack::ShowExceptions
         use Rack::Lint
-        use Adsf::Rack::IndexFileFinder, :root => project.output_dir
-        use Pith::Server::DefaultToHtml, project.output_dir
+        use Pith::Server::OutputFinder, project
         run Rack::Directory.new(project.output_dir)
       end
     end
 
     extend self
 
-    class DefaultToHtml
+    class OutputFinder
 
-      def initialize(app, root)
+      def initialize(app, project)
         @app  = app
-        @root = root
+        @project = project
       end
 
       def call(env)
 
+        @project.sync_every(1)
+
         path_info = ::Rack::Utils.unescape(env["PATH_INFO"])
-        file = "#{@root}#{path_info}"
-        unless File.exist?(file)
-          if File.exist?("#{file}.html")
-            env["PATH_INFO"] += ".html"
+        ends_with_slash = (path_info[-1] == '/')
+
+        outputs = @project.outputs.sort_by { |output| output.path }
+        outputs.each do |output|
+
+          output_path = "/" + output.path.to_s
+
+          if !ends_with_slash && output_path =~ %r{^#{path_info}/}
+            return [
+              302,
+              { "Location" => path_info + "/" },
+              []
+            ]
           end
+
+          ["", ".html", "index.html"].map do |ext|
+            if output_path == (path_info + ext)
+              output.build
+              env["PATH_INFO"] += ext
+              return @app.call(env)
+            end
+          end
+
         end
 
         @app.call(env)

data/lib/pith/version.rb

@@ -1,3 +1,3 @@
 module Pith
-  VERSION = "0.2.3".freeze
+  VERSION = "0.3.0".freeze
 end

data/spec/pith/input_spec.rb

@@ -5,53 +5,90 @@ require "pith/project"
 describe Pith::Input do
 
   before do
-    $input_dir.mkpath
     @project = Pith::Project.new(:input_dir => $input_dir)
   end
 
   def make_input(path)
+    path = Pathname(path)
     input_file = $input_dir + path
     input_file.parent.mkpath
     input_file.open("w") do |io|
       yield io if block_given?
     end
-    @project.input(path)
+    Pith::Input.new(@project, path)
   end
 
-  describe "#title" do
+  context "for a template" do
 
-    it "is based on last component of filename" do
-      @input = make_input("dir/some_page.html.haml")
-      @input.title.should == "Some page"
+    subject do
+      make_input("dir/some_page.html.md.erb")
     end
 
-    it "can be over-ridden in metadata" do
-      @input = make_input("dir/some_page.html.haml") do |i|
-        i.puts "---"
-        i.puts "title: Blah blah"
-        i.puts "..."
+    it { should be_template }
+
+    describe "#title" do
+
+      it "is based on last component of filename" do
+        subject.title.should == "Some page"
+      end
+
+      it "can be over-ridden in metadata" do
+        input = make_input("dir/some_page.html.haml") do |i|
+          i.puts "---"
+          i.puts "title: Blah blah"
+          i.puts "..."
+        end
+        input.title.should == "Blah blah"
+      end
+
+    end
+
+    describe "#output" do
+
+      it "returns an Output" do
+        subject.output.should_not be_nil
       end
-      @input.title.should == "Blah blah"
+
+    end
+
+    describe "#output_path" do
+
+      it "excludes the template-type extensions" do
+        subject.output_path.should == Pathname("dir/some_page.html")
+      end
+
+    end
+
+    describe "#pipeline" do
+
+      it "is a list of Tilt processors" do
+        subject.pipeline.should == [Tilt["erb"], Tilt["md"]]
+      end
+
     end
 
   end
 
-  describe "#output_path" do
+  context "for a resource" do
 
-    it "excludes the template-type extension" do
-      @input = make_input("dir/some_page.html.haml")
-      @input.output_path.should == Pathname("dir/some_page.html")
+    subject do
+      make_input("dir/some_image.gif")
     end
 
+    it { should_not be_template }
+
+    its(:pipeline) { should be_empty }
+
   end
 
-  describe "#pipeline" do
+  context "for an ignored file" do
 
-    it "is a list of Tilt processors" do
-      @input = make_input("dir/some_page.html.haml")
-      @input.pipeline.should == [Tilt["haml"]]
+    subject do
+      make_input("_blah/blah.de")
     end
 
+    its(:output) { should be_nil }
+
   end
 
 end