nanoc3 3.2.0a1 → 3.2.0a2

data/lib/nanoc3/base/{compiler.rb → compilation/compiler.rb}

@@ -30,10 +30,18 @@ module Nanoc3
   # * `visit_ended` — indicates that the compiler has finished visiting the
   #   item representation and that the requested attributes or content have
   #   been fetched (either successfully or with failure)
+  #
+  # * `processing_started` — indicates that the compiler has started
+  #   processing the specified object, which can be an item representation
+  #   (when it is compiled) or a layout (when it is used to lay out an item
+  #   representation or when it is used as a partial)
+  #
+  # * `processing_ended` — indicates that the compiler has finished processing
+  #   the specified object.
   class Compiler
 
-    # The name of the file where cached compiled content will be stored
-    COMPILED_CONTENT_CACHE_FILENAME = 'tmp/compiled_content'
+    # @return [Nanoc3::Site] The site this compiler belongs to
+    attr_reader :site
 
     # The compilation stack. When the compiler begins compiling a rep or a
     # layout, it will be placed on the stack; when it is done compiling the
@@ -42,16 +50,12 @@ module Nanoc3
     # @return [Array] The compilation stack
     attr_reader :stack
 
-    # The list of compilation rules that will be used to compile items. This
-    # array will be filled by {Nanoc3::Site#load_data}.
-    #
-    # @return [Array<Nanoc3::Rule>] The list of item compilation rules
+    # @return [Array<Nanoc3::Rule>] The list of item compilation rules that
+    #   will be used to compile items.
     attr_reader :item_compilation_rules
 
-    # The list of routing rules that will be used to give all items a path.
-    # This array will be filled by {Nanoc3::Site#load_data}.
-    #
-    # @return [Array<Nanoc3::Rule>] The list of item routing rules
+    # @return [Array<Nanoc3::Rule>] The list of routing rules that will be
+    #   used to give all items a path.
     attr_reader :item_routing_rules
 
     # The hash containing layout-to-filter mapping rules. This hash is
@@ -60,6 +64,10 @@ module Nanoc3
     # @return [Hash] The layout-to-filter mapping rules
     attr_reader :layout_filter_mapping
 
+    # @return [Proc] The code block that will be executed after all data is
+    #   loaded but before the site is compiled
+    attr_accessor :preprocessor
+
     # Creates a new compiler fo the given site
     #
     # @param [Nanoc3::Site] site The site this compiler belongs to
@@ -73,62 +81,81 @@ module Nanoc3
       @layout_filter_mapping   = OrderedHash.new
     end
 
-    # Compiles (part of) the site and writes out the compiled item
-    # representations.
-    #
-    # @param [Nanoc3::Item] item The item that should be compiled, along with
-    #   its dependencies. Pass `nil` if the entire site should be compiled.
+    # Compiles the site and writes out the compiled item representations.
     #
-    # @option params [Boolean] :force (false) true if the rep should be
-    #   compiled even if it is not outdated, false if not
+    # Previous versions of nanoc (< 3.2) allowed passing items to compile, and
+    # had a “force” option to make the compiler recompile all pages, even
+    # when not outdated. These arguments and options are, as of nanoc 3.2, no
+    # longer used, and will simply be ignored when passed to {#run}.
     #
-    # @return [void]
-    def run(item=nil, params={})
-      # Parse params
-      params[:force] = false if !params.has_key?(:force)
-
+    # @overload run
+    #   @return [void]
+    def run(*args)
       # Create output directory if necessary
       FileUtils.mkdir_p(@site.config[:output_dir])
 
-      # Load necessary data
-      compiled_content_cache = CompiledContentCache.new(COMPILED_CONTENT_CACHE_FILENAME)
-      compiled_content_cache.load
-      dependency_tracker.load_graph
-
-      # Get items and reps to compile
-      items = item ? ([ item ] + dependency_tracker.successors_of(item)).uniq : @site.items
-      reps = items.map { |i| i.reps }.flatten
-
-      # Determine which reps need to be recompiled
-      reps.each { |r| r.force_outdated = true } if params[:force]
-      dependency_tracker.propagate_outdatedness
-      forget_dependencies_if_outdated(items)
-
       # Compile reps
+      load
       dependency_tracker.start
       compile_reps(reps)
       dependency_tracker.stop
-
-      # Store necessary data
-      compiled_content_cache.store
-      @site.store_checksums
-      dependency_tracker.store_graph
+      store
     ensure
       # Cleanup
       FileUtils.rm_rf(Nanoc3::Filter::TMP_BINARY_ITEMS_DIR)
     end
 
+    # Load the helper data that is used for compiling the site.
+    #
+    # @api private
+    #
+    # @return [void]
+    def load
+      return if @loaded
+      @loaded = true
+
+      stores.each { |s| s.load }
+
+      # Preprocess
+      load_rules
+      preprocess
+      site.setup_child_parent_links
+      build_reps
+      route_reps
+
+      # Determine which reps need to be recompiled
+      dependency_tracker.propagate_outdatedness
+      forget_dependencies_if_outdated(items)
+    end
+
+    # Store the modified helper data used for compiling the site.
+    #
+    # @api private
+    #
+    # @return [void]
+    def store
+      stores.each { |s| s.store }
+    end
+
     # Returns the dependency tracker for this site, creating it first if it
     # does not yet exist.
-    # 
+    #
+    # @api private
+    #
     # @return [Nanoc3::DependencyTracker] The dependency tracker for this site
     def dependency_tracker
-      @dependency_tracker ||= Nanoc3::DependencyTracker.new(@site.items + @site.layouts)
+      @dependency_tracker ||= begin
+        dt = Nanoc3::DependencyTracker.new(@site.items + @site.layouts)
+        dt.compiler = self
+        dt
+      end
     end
 
     # Finds the first matching compilation rule for the given item
     # representation.
     #
+    # @api private
+    #
     # @param [Nanoc3::ItemRep] rep The item rep for which to fetch the rule
     #
     # @return [Nanoc3::Rule, nil] The compilation rule for the given item rep,
@@ -141,6 +168,8 @@ module Nanoc3
 
     # Finds the first matching routing rule for the given item representation.
     #
+    # @api private
+    #
     # @param [Nanoc3::ItemRep] rep The item rep for which to fetch the rule
     #
     # @return [Nanoc3::Rule, nil] The routing rule for the given item rep, or
@@ -156,6 +185,8 @@ module Nanoc3
     # returned. The result is a hash containing the corresponding rule for
     # each snapshot.
     #
+    # @api private
+    #
     # @return [Hash<Symbol, Nanoc3::Rule>] The routing rules for the given rep
     def routing_rules_for(rep)
       rules = {}
@@ -171,6 +202,8 @@ module Nanoc3
 
     # Finds the filter name and arguments to use for the given layout.
     #
+    # @api private
+    #
     # @param [Nanoc3::Layout] layout The layout for which to fetch the filter.
     #
     # @return [Array, nil] A tuple containing the filter name and the filter 
@@ -182,8 +215,146 @@ module Nanoc3
       nil
     end
 
+    # @api private
+    #
+    # @return [Boolean] true if the object is outdated, false otherwise
+    def outdated?(obj)
+      outdatedness_checker.outdated?(obj)
+    end
+
+    # Returns the reason why the given object is outdated.
+    #
+    # @see Nanoc3::OutdatednessChecker#outdatedness_reason_for
+    #
+    # @api private
+    def outdatedness_reason_for(obj)
+      outdatedness_checker.outdatedness_reason_for(obj)
+    end
+
+    # Returns the Nanoc3::CompilerDSL that should be used for this site.
+    #
+    # @api private
+    def dsl
+      @dsl ||= Nanoc3::CompilerDSL.new(self)
+    end
+
+    # Loads this site’s rules.
+    #
+    # @api private
+    def load_rules
+      # Find rules file
+      rules_filename = [ 'Rules', 'rules', 'Rules.rb', 'rules.rb' ].find { |f| File.file?(f) }
+      raise Nanoc3::Errors::NoRulesFileFound.new if rules_filename.nil?
+
+      # Get rule data
+      @rules = File.read(rules_filename)
+
+      # Load DSL
+      dsl.instance_eval(@rules, "./#{rules_filename}")
+    end
+
+    # Runs the preprocessor.
+    #
+    # @api private
+    def preprocess
+      preprocessor_context.instance_eval(&preprocessor) if preprocessor
+    end
+
+    # FIXME get rid of this
+    #
+    # @api private
+    def rules_with_reference
+      rules = @rules
+      @rules_pseudo ||= begin
+        pseudo = Object.new
+        pseudo.instance_eval { @data = rules }
+        def pseudo.reference ; :rules ; end
+        def pseudo.data ; @data.inspect ; end
+        pseudo
+      end
+    end
+
+    # Creates the representations of all items as defined by the compilation
+    # rules.
+    #
+    # @api private
+    def build_reps
+      @site.items.each do |item|
+        # Find matching rules
+        matching_rules = item_compilation_rules.select { |r| r.applicable_to?(item) }
+        raise Nanoc3::Errors::NoMatchingCompilationRuleFound.new(item) if matching_rules.empty?
+
+        # Create reps
+        rep_names = matching_rules.map { |r| r.rep_name }.uniq
+        rep_names.each do |rep_name|
+          item.reps << ItemRep.new(item, rep_name)
+        end
+      end
+    end
+
+    # Determines the paths of all item representations.
+    #
+    # @api private
+    def route_reps
+      reps = @site.items.map { |i| i.reps }.flatten
+      reps.each do |rep|
+        # Find matching rules
+        rules = routing_rules_for(rep)
+        raise Nanoc3::Errors::NoMatchingRoutingRuleFound.new(rep) if rules[:last].nil?
+
+        rules.each_pair do |snapshot, rule|
+          # Get basic path by applying matching rule
+          basic_path = rule.apply_to(rep, :compiler => self)
+          next if basic_path.nil?
+
+          # Get raw path by prepending output directory
+          rep.raw_paths[snapshot] = @site.config[:output_dir] + basic_path
+
+          # Get normal path by stripping index filename
+          rep.paths[snapshot] = basic_path
+          @site.config[:index_filenames].each do |index_filename|
+            if rep.paths[snapshot][-index_filename.length..-1] == index_filename
+              # Strip and stop
+              rep.paths[snapshot] = rep.paths[snapshot][0..-index_filename.length-1]
+              break
+            end
+          end
+        end
+      end
+    end
+
+    # @param [Nanoc3::ItemRep] rep The item representation for which the
+    #   assigns should be fetched
+    #
+    # @return [Hash] The assigns that should be used in the next filter/layout
+    #   operation
+    def assigns_for(rep)
+      if rep.binary?
+        content_or_filename_assigns = { :filename => rep.filenames[:last] }
+      else
+        content_or_filename_assigns = { :content => rep.content[:last] }
+      end
+
+      content_or_filename_assigns.merge({
+        :item       => rep.item,
+        :item_rep   => rep,
+        :items      => site.items,
+        :layouts    => site.layouts,
+        :config     => site.config,
+        :site       => site
+      })
+    end
+
   private
 
+    def items
+      @items ||= @site.items
+    end
+
+    def reps
+      @reps ||= items.map { |i| i.reps }.flatten
+    end
+
     # Compiles the given representations.
     #
     # @param [Array] reps The item representations to compile.
@@ -196,19 +367,23 @@ module Nanoc3
       outdated_reps = Set.new
       skipped_reps  = Set.new
       reps.each do |rep|
-        target = (rep.outdated? || rep.item.outdated_due_to_dependencies?) ? outdated_reps : skipped_reps
+        target = (outdated?(rep) || dependency_tracker.outdated_due_to_dependencies?(rep.item)) ? outdated_reps : skipped_reps
         target.add(rep)
       end
 
       # Build graph for outdated reps
       content_dependency_graph = Nanoc3::DirectedGraph.new(outdated_reps)
 
+      # Listen to processing start/stop
+      Nanoc3::NotificationCenter.on(:processing_started, self) { |obj| @stack.push(obj) }
+      Nanoc3::NotificationCenter.on(:processing_ended,   self) { |obj| @stack.pop       }
+
       # Attempt to compile all active reps
       loop do
         # Find rep to compile
         break if content_dependency_graph.roots.empty?
         rep = content_dependency_graph.roots.each { |e| break e }
-        @stack = [ rep ]
+        @stack = []
 
         begin
           compile_rep(rep)
@@ -226,6 +401,9 @@ module Nanoc3
       if !content_dependency_graph.vertices.empty?
         raise Nanoc3::Errors::RecursiveCompilation.new(content_dependency_graph.vertices)
       end
+    ensure
+      Nanoc3::NotificationCenter.remove(:processing_started, self)
+      Nanoc3::NotificationCenter.remove(:processing_ended,   self)
     end
 
     # Compiles the given item representation.
@@ -239,15 +417,16 @@ module Nanoc3
     # @return [void]
     def compile_rep(rep)
       Nanoc3::NotificationCenter.post(:compilation_started, rep)
+      Nanoc3::NotificationCenter.post(:processing_started,  rep)
       Nanoc3::NotificationCenter.post(:visit_started,       rep.item)
 
-      if !rep.outdated? && !rep.item.outdated_due_to_dependencies && compiled_content_cache[rep]
+      if !outdated?(rep) && !dependency_tracker.outdated_due_to_dependencies?(rep.item) && compiled_content_cache[rep]
         Nanoc3::NotificationCenter.post(:cached_content_used, rep)
         rep.content = compiled_content_cache[rep]
       else
         rep.snapshot(:raw)
         rep.snapshot(:pre, :final => false)
-        compilation_rule_for(rep).apply_to(rep)
+        compilation_rule_for(rep).apply_to(rep, :compiler => self)
         rep.snapshot(:post) if rep.has_snapshot?(:post)
         rep.snapshot(:last)
       end
@@ -260,6 +439,7 @@ module Nanoc3
       raise e
     ensure
       Nanoc3::NotificationCenter.post(:visit_ended,       rep.item)
+      Nanoc3::NotificationCenter.post(:processing_ended,  rep)
       Nanoc3::NotificationCenter.post(:compilation_ended, rep)
     end
 
@@ -271,21 +451,41 @@ module Nanoc3
     # @return [void]
     def forget_dependencies_if_outdated(items)
       items.each do |i|
-        if i.outdated? || i.outdated_due_to_dependencies?
+        if i.reps.any? { |r| outdated?(r) } || dependency_tracker.outdated_due_to_dependencies?(i)
           dependency_tracker.forget_dependencies_for(i)
         end
       end
     end
 
-    # Returns the cache used for storing compiled content.
-    #
+    # Returns a preprocessor context, creating one if none exists yet.
+    def preprocessor_context
+      @preprocessor_context ||= Nanoc3::Context.new({
+        :site    => @site,
+        :config  => @site.config,
+        :items   => @site.items,
+        :layouts => @site.layouts
+      })
+    end
+
     # @return [CompiledContentCache] The compiled content cache
     def compiled_content_cache
-      @compiled_content_cache ||= begin
-        cache = Nanoc3::CompiledContentCache.new(COMPILED_CONTENT_CACHE_FILENAME)
-        cache.load
-        cache
-      end
+      @compiled_content_cache ||= Nanoc3::CompiledContentCache.new
+    end
+
+    # @return [ChecksumStore] The checksum store
+    def checksum_store
+      @checksum_store ||= Nanoc3::ChecksumStore.new(:site => @site)
+    end
+
+    # @return [Nanoc3::OutdatednessChecker] The outdatedness checker
+    def outdatedness_checker
+      @outdatedness_checker ||= Nanoc3::OutdatednessChecker.new(:site => @site, :checksum_store => checksum_store)
+    end
+
+    # Returns all stores that can load/store data that can be used for
+    # compilation.
+    def stores
+      [ compiled_content_cache, checksum_store, dependency_tracker ]
     end
 
   end

data/lib/nanoc3/base/{compiler_dsl.rb → compilation/compiler_dsl.rb}

@@ -5,11 +5,16 @@ module Nanoc3
   # Contains methods that will be executed by the site’s `Rules` file.
   class CompilerDSL
 
+    # @return [Nanoc3::Compiler] The compiler where this DSL belongs to.
+    attr_reader :compiler
+
     # Creates a new compiler DSL for the given compiler.
     #
+    # @api private
+    #
     # @param [Nanoc3::Site] site The site this DSL belongs to
-    def initialize(site)
-      @site = site
+    def initialize(compiler)
+      @compiler = compiler
     end
 
     # Creates a preprocessor block that will be executed after all data is
@@ -19,7 +24,7 @@ module Nanoc3
     #
     # @return [void]
     def preprocess(&block)
-      @site.preprocessor = block
+      compiler.preprocessor = block
     end
 
     # Creates a compilation rule for all items whose identifier match the
@@ -63,7 +68,7 @@ module Nanoc3
 
       # Create rule
       rule = Rule.new(identifier_to_regex(identifier), rep_name, block)
-      @site.compiler.item_compilation_rules << rule
+      compiler.item_compilation_rules << rule
     end
 
     # Creates a routing rule for all items whose identifier match the
@@ -108,7 +113,7 @@ module Nanoc3
 
       # Create rule
       rule = Rule.new(identifier_to_regex(identifier), rep_name, block, :snapshot_name => snapshot_name)
-      @site.compiler.item_routing_rules << rule
+      compiler.item_routing_rules << rule
     end
 
     # Creates a layout rule for all layouts whose identifier match the given
@@ -136,7 +141,7 @@ module Nanoc3
     #
     #     layout '/custom/',  :haml, :format => :html5
     def layout(identifier, filter_name, params={})
-      @site.compiler.layout_filter_mapping[identifier_to_regex(identifier)] = [ filter_name, params ]
+      compiler.layout_filter_mapping[identifier_to_regex(identifier)] = [ filter_name, params ]
     end
 
   private