nanoc 4.0.2 → 4.1.0a1

data/Guardfile

@@ -0,0 +1,3 @@
+guard 'rake', task: 'default' do
+  watch(%r{^(lib|test|spec)/})
+end

data/NEWS.md

@@ -1,5 +1,26 @@
 # Nanoc news
 
+## 4.1.0a1 (2015-12-05)
+
+Features:
+
+* Added `postprocess` block (#726) [Garen Torikian]
+* Added `#write` compilation instruction and `path` option to `#snapshot` (#753)
+
+Fixes:
+
+* Fixed crash when printing non-string object (#712) [Garen Torikian]
+* Removed English text from `#link_to` helper (#736) [Lucas Vuotto]
+
+Enhancements:
+
+* Allowed excluding URLs from external links check (#686) [Yannick Ihmels]
+* Added `atom` to list of text extensions (#657) [Yannick Ihmels]
+* Added `#each` to `Nanoc::ConfigView` (#705) [Garen Torikian]
+* Made `#attribute_to_time` handle `DateTime` (#717) [Micha Rosenbaum]
+* Added `Identifier#components` (#677)
+* Added `:existing` option to `#content_for` (can be `:error`, `:overwrite` and `:append`) (#744)
+
 ## 4.0.2 (2015-11-30)
 
 Fixes:

data/README.md

@@ -19,4 +19,4 @@ Contributions are greatly appreciated! Consult the [Development guidelines](http
 
 Many thanks to everyone who has contributed to Nanoc in one way or another:
 
-Ale Muñoz, Alexander Mankuta, Arnau Siches, Ben Armston, Bil Bas, Brian Candler, Bruno Dufour, Chris Eppstein, Christian Plessl, Colin Barrett, Croath Liu, Damien Pollet, Dan Callahan, Daniel Hofstetter, Daniel Mendler, Daniel Wollschlaeger, David Alexander, David Everitt, Dennis Sutch, Devon Luke Buchanan, Dmitry Bilunov, Eric Sunshine, Erik Hollensbe, Fabian Buch, Felix Hanley, Go Maeda, Gregory Pakosz, Grégory Karékinian, Guilherme Garnier, Jack Chu, Jake Benilov, Jasper Van der Jeugt, Jeff Forcier, Jim Mendenhall, John Nishinaga, Justin Clift, Justin Hileman, Kevin Lynagh, Louis T., Mathias Bynens, Matt Keveney, Matthew Frazier, Matthias Beyer, Matthias Reitinger, Matthias Vallentin, Michal Cichra, Nelson Chen, Nicky Peeters, Nikhil Marathe, Oliver Byford, Peter Aronoff, Raphael von der Grün, Rémi Barraquand, Remko Tronçon, Riley Goodside, Ruben Verborgh, Scott Vokes, Šime Ramov, Simon South, Spencer Whitt, Stanley Rost, Starr Horne, Stefan Bühler, Stuart Montgomery, Takashi Uchibe, Toon Willems, Tuomas Kareinen, Ursula Kallio, Vincent Driessen, Xavier Shay, Yannick Ihmels, Zaiste de Grengolada
+Ale Muñoz, Alexander Mankuta, Arnau Siches, Ben Armston, Bil Bas, Brian Candler, Bruno Dufour, Chris Eppstein, Christian Plessl, Colin Barrett, Croath Liu, Damien Pollet, Dan Callahan, Daniel Hofstetter, Daniel Mendler, Daniel Wollschlaeger, David Alexander, David Everitt, Dennis Sutch, Devon Luke Buchanan, Dmitry Bilunov, Eric Sunshine, Erik Hollensbe, Fabian Buch, Felix Hanley, Garen Torikian, Go Maeda, Gregory Pakosz, Grégory Karékinian, Guilherme Garnier, Jack Chu, Jake Benilov, Jasper Van der Jeugt, Jeff Forcier, Jim Mendenhall, John Nishinaga, Justin Clift, Justin Hileman, Kevin Lynagh, Louis T., Mathias Bynens, Matt Keveney, Matthew Frazier, Matthias Beyer, Matthias Reitinger, Matthias Vallentin, Michal Cichra, Nelson Chen, Nicky Peeters, Nikhil Marathe, Oliver Byford, Peter Aronoff, Raphael von der Grün, Rémi Barraquand, Remko Tronçon, Riley Goodside, Ruben Verborgh, Scott Vokes, Šime Ramov, Simon South, Spencer Whitt, Stanley Rost, Starr Horne, Stefan Bühler, Stuart Montgomery, Takashi Uchibe, Toon Willems, Tuomas Kareinen, Ursula Kallio, Vincent Driessen, Xavier Shay, Yannick Ihmels, Zaiste de Grengolada

data/lib/nanoc/base.rb

@@ -1,8 +1,5 @@
 module Nanoc
-  require 'nanoc/base/core_ext'
-
   autoload 'Error',                'nanoc/base/error'
-  autoload 'DataSource',           'nanoc/base/source_data/data_source'
   autoload 'Filter',               'nanoc/base/compilation/filter'
 end
 
@@ -15,29 +12,20 @@ module Nanoc::Int
   autoload 'Errors',               'nanoc/base/errors'
   autoload 'Memoization',          'nanoc/base/memoization'
   autoload 'PluginRegistry',       'nanoc/base/plugin_registry'
-  autoload 'IdentifiableCollection', 'nanoc/base/identifiable_collection'
-
-  # Load source data classes
-  autoload 'CodeSnippet',          'nanoc/base/source_data/code_snippet'
-  autoload 'Configuration',        'nanoc/base/source_data/configuration'
-  autoload 'Item',                 'nanoc/base/source_data/item'
-  autoload 'Site',                 'nanoc/base/source_data/site'
-
-  # Load result data classes
-  autoload 'ItemRep',              'nanoc/base/result_data/item_rep'
 
   # Load compilation classes
   autoload 'Compiler',             'nanoc/base/compilation/compiler'
   autoload 'CompilerDSL',          'nanoc/base/compilation/compiler_dsl'
   autoload 'DependencyTracker',    'nanoc/base/compilation/dependency_tracker'
+  autoload 'ItemRepRepo',          'nanoc/base/compilation/item_rep_repo'
   autoload 'OutdatednessChecker',  'nanoc/base/compilation/outdatedness_checker'
   autoload 'OutdatednessReasons',  'nanoc/base/compilation/outdatedness_reasons'
   autoload 'Rule',                 'nanoc/base/compilation/rule'
   autoload 'RuleContext',          'nanoc/base/compilation/rule_context'
-  autoload 'RuleMemoryCalculator', 'nanoc/base/compilation/rule_memory_calculator'
-  autoload 'RulesCollection',      'nanoc/base/compilation/rules_collection'
 end
 
+require_relative 'base/core_ext'
+
 require_relative 'base/entities'
 require_relative 'base/repos'
 require_relative 'base/services'

data/lib/nanoc/base/checksummer.rb

@@ -56,12 +56,10 @@ module Nanoc::Int
         end
 
         case obj
-        when ::String
-          digest.update(obj)
-        when ::Symbol
+        when ::String, ::Symbol, ::Numeric
           digest.update(obj.to_s)
         when nil, true, false
-        when ::Array
+        when ::Array, ::Nanoc::Int::IdentifiableCollection
           obj.each do |el|
             update(el, digest, visited + [obj])
             digest.update(',')
@@ -83,13 +81,9 @@ module Nanoc::Int
           end
         when Time
           digest.update(obj.to_i.to_s)
-        when Numeric
-          digest.update(obj.to_s)
         when Nanoc::Identifier
           update(obj.to_s, digest)
-        when Nanoc::Int::RulesCollection
-          update(obj.data, digest)
-        when Nanoc::Int::CodeSnippet
+        when Nanoc::Int::RulesCollection, Nanoc::Int::CodeSnippet
           update(obj.data, digest)
         when Nanoc::Int::TextualContent
           update(obj.string, digest)
@@ -106,11 +100,6 @@ module Nanoc::Int
           update(obj.identifier, digest)
         when Nanoc::ItemView, Nanoc::LayoutView, Nanoc::ConfigView, Nanoc::IdentifiableCollectionView
           update(obj.unwrap, digest)
-        when Nanoc::Int::IdentifiableCollection
-          obj.each do |el|
-            update(el, digest, visited + [obj])
-            digest.update(',')
-          end
         else
           data = begin
             Marshal.dump(obj)

data/lib/nanoc/base/compilation/compiler.rb

@@ -38,17 +38,7 @@ module Nanoc::Int
   #
   # @api private
   class Compiler
-    extend Nanoc::Int::Memoization
-
-    class IdenticalRoutesError < ::Nanoc::Error
-      def initialize(output_path, rep_a, rep_b)
-        super("The item representations #{rep_a.inspect} and #{rep_b.inspect} are both routed to #{output_path}.")
-      end
-    end
-
-    # @group Accessors
-
-    # @return [Nanoc::Int::Site] The site this compiler belongs to
+    # @api private
     attr_reader :site
 
     # The compilation stack. When the compiler begins compiling a rep or a
@@ -58,98 +48,89 @@ module Nanoc::Int
     # @return [Array] The compilation stack
     attr_reader :stack
 
-    # @group Public instance methods
+    # @api private
+    attr_reader :rules_collection
 
-    # Creates a new compiler fo the given site
-    #
-    # @param [Nanoc::Int::Site] site The site this compiler belongs to
-    def initialize(site)
-      @site = site
+    # @api private
+    attr_reader :compiled_content_cache
 
-      @stack = []
-    end
+    # @api private
+    attr_reader :checksum_store
 
-    # Compiles the site and writes out the compiled item representations.
-    #
-    # 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}.
-    #
-    # @overload run
-    #   @return [void]
-    def run(*_args)
-      # Create output directory if necessary
-      FileUtils.mkdir_p(@site.config[:output_dir])
-
-      # Compile reps
-      load
-      @site.freeze
+    # @api private
+    attr_reader :rule_memory_store
 
-      # Determine which reps need to be recompiled
-      forget_dependencies_if_outdated(items)
+    # @api private
+    attr_reader :rule_memory_calculator
 
-      dependency_tracker.start
-      compile_reps(reps)
-      dependency_tracker.stop
-      store
-    ensure
-      Nanoc::Int::TempFilenameFactory.instance.cleanup(
-        Nanoc::Filter::TMP_BINARY_ITEMS_DIR)
-      Nanoc::Int::TempFilenameFactory.instance.cleanup(
-        Nanoc::Int::ItemRepWriter::TMP_TEXT_ITEMS_DIR)
-    end
+    # @api private
+    attr_reader :dependency_store
+
+    # @api private
+    attr_reader :outdatedness_checker
+
+    # @api private
+    attr_reader :reps
 
-    # @group Private instance methods
+    def initialize(site, rules_collection, compiled_content_cache:, checksum_store:, rule_memory_store:, rule_memory_calculator:, dependency_store:, outdatedness_checker:, reps:)
+      @site = site
+      @rules_collection = rules_collection
 
-    # @return [Nanoc::Int::RulesCollection] The collection of rules to be used
-    #   for compiling this site
-    def rules_collection
-      Nanoc::Int::RulesCollection.new(self)
+      @compiled_content_cache = compiled_content_cache
+      @checksum_store         = checksum_store
+      @rule_memory_store      = rule_memory_store
+      @rule_memory_calculator = rule_memory_calculator
+      @dependency_store       = dependency_store
+      @outdatedness_checker   = outdatedness_checker
+      @reps                   = reps
+
+      @stack = []
     end
-    memoize :rules_collection
 
-    # Load the helper data that is used for compiling the site.
-    #
-    # @return [void]
-    def load
-      return if @loaded || @loading
-      @loading = true
+    # 1. Load site
+    # 2. Load rules
+    # 3. Preprocess
+    # 4. Build item reps
+    # 5. Compile
+    # 6. Postprocess
 
+    # TODO: move elsewhere
+    def run_all
       # Preprocess
-      rules_collection.load
-      preprocess
-      Nanoc::Int::SiteLoader.new.setup_child_parent_links(site.items)
+      Nanoc::Int::Preprocessor.new(site: @site, rules_collection: @rules_collection).run
+
+      # Build reps
       build_reps
-      route_reps
 
-      # Load auxiliary stores
-      stores.each(&:load)
+      # Compile
+      run
 
-      @loaded = true
-    rescue => e
-      unload
-      raise e
-    ensure
-      @loading = false
+      # Postprocess
+      Nanoc::Int::Postprocessor.new(create_view_context, site: @site, rules_collection: @rules_collection).run
     end
 
-    # Undoes the effects of {#load}. Used when {#load} raises an exception.
-    #
-    # @return [void]
-    def unload
-      return if @unloading
-      @unloading = true
+    def run
+      load_stores
+      @site.freeze
 
-      stores.each(&:unload)
+      # Determine which reps need to be recompiled
+      forget_dependencies_if_outdated
 
       @stack = []
+      dependency_tracker = Nanoc::Int::DependencyTracker.new(@dependency_store)
+      dependency_tracker.run do
+        compile_reps
+      end
+      store
+    ensure
+      Nanoc::Int::TempFilenameFactory.instance.cleanup(
+        Nanoc::Filter::TMP_BINARY_ITEMS_DIR)
+      Nanoc::Int::TempFilenameFactory.instance.cleanup(
+        Nanoc::Int::ItemRepWriter::TMP_TEXT_ITEMS_DIR)
+    end
 
-      items.each { |item| item.reps.clear }
-      rules_collection.unload
-
-      @loaded = false
-      @unloading = false
+    def load_stores
+      stores.each(&:load)
     end
 
     # Store the modified helper data used for compiling the site.
@@ -157,8 +138,8 @@ module Nanoc::Int
     # @return [void]
     def store
       # Calculate rule memory
-      (reps + layouts.to_a).each do |obj|
-        rule_memory_store[obj] = rule_memory_calculator[obj]
+      (@reps.to_a + @site.layouts.to_a).each do |obj|
+        rule_memory_store[obj] = rule_memory_calculator[obj].serialize
       end
 
       # Calculate checksums
@@ -170,26 +151,6 @@ module Nanoc::Int
       stores.each(&:store)
     end
 
-    # Returns the dependency tracker for this site, creating it first if it
-    # does not yet exist.
-    #
-    # @return [Nanoc::Int::DependencyTracker] The dependency tracker for this site
-    def dependency_tracker
-      dt = Nanoc::Int::DependencyTracker.new(@site.items.to_a + @site.layouts.to_a)
-      dt.compiler = self
-      dt
-    end
-    memoize :dependency_tracker
-
-    # Runs the preprocessors.
-    #
-    # @api private
-    def preprocess
-      rules_collection.preprocessors.each_value do |preprocessor|
-        preprocessor_context.instance_eval(&preprocessor)
-      end
-    end
-
     # Returns all objects managed by the site (items, layouts, code snippets,
     # site configuration and the rules).
     #
@@ -199,65 +160,10 @@ module Nanoc::Int
         [site.config, rules_collection]
     end
 
-    # Creates the representations of all items as defined by the compilation
-    # rules.
-    #
-    # @api private
     def build_reps
-      items.each do |item|
-        # Find matching rules
-        matching_rules = rules_collection.item_compilation_rules_for(item)
-        raise Nanoc::Int::Errors::NoMatchingCompilationRuleFound.new(item) if matching_rules.empty?
-
-        # Create reps
-        rep_names = matching_rules.map(&:rep_name).uniq
-        rep_names.each do |rep_name|
-          item.reps << Nanoc::Int::ItemRep.new(item, rep_name)
-        end
-      end
-    end
-
-    # Determines the paths of all item representations.
-    #
-    # @api private
-    def route_reps
-      paths_to_reps = {}
-
-      reps.each do |rep|
-        # Find matching rules
-        rules = rules_collection.routing_rules_for(rep)
-        raise Nanoc::Int::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, executor: nil, compiler: self)
-          next if basic_path.nil?
-          if basic_path !~ %r{^/}
-            raise "The path returned for the #{rep.inspect} item representation, “#{basic_path}”, does not start with a slash. Please ensure that all routing rules return a path that starts with a slash."
-          end
-
-          # Check for duplicate paths
-          if paths_to_reps.key?(basic_path)
-            raise IdenticalRoutesError.new(basic_path, paths_to_reps[basic_path], rep)
-          else
-            paths_to_reps[basic_path] = rep
-          end
-
-          # 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|
-            rep_path_ending = rep.paths[snapshot][-index_filename.length..-1]
-            next unless rep_path_ending == index_filename
-
-            # Strip and stop
-            rep.paths[snapshot] = rep.paths[snapshot][0..-index_filename.length - 1]
-            break
-          end
-        end
-      end
+      builder = Nanoc::Int::ItemRepBuilder.new(
+        site, rules_collection, rule_memory_calculator, @reps)
+      builder.run
     end
 
     # @param [Nanoc::Int::ItemRep] rep The item representation for which the
@@ -274,87 +180,41 @@ module Nanoc::Int
         content_or_filename_assigns = { content: rep.snapshot_contents[:last].string }
       end
 
+      view_context = create_view_context
+
       # TODO: Do not expose @site (necessary for captures store though…)
       content_or_filename_assigns.merge(
-        item: Nanoc::ItemView.new(rep.item),
-        rep: Nanoc::ItemRepView.new(rep),
-        item_rep: Nanoc::ItemRepView.new(rep),
-        items: Nanoc::ItemCollectionView.new(site.items),
-        layouts: Nanoc::LayoutCollectionView.new(site.layouts),
-        config: Nanoc::ConfigView.new(site.config),
-        site: Nanoc::SiteView.new(site),
+        item: Nanoc::ItemView.new(rep.item, view_context),
+        rep: Nanoc::ItemRepView.new(rep, view_context),
+        item_rep: Nanoc::ItemRepView.new(rep, view_context),
+        items: Nanoc::ItemCollectionView.new(site.items, view_context),
+        layouts: Nanoc::LayoutCollectionView.new(site.layouts, view_context),
+        config: Nanoc::ConfigView.new(site.config, view_context),
+        site: Nanoc::SiteView.new(site, view_context),
       )
     end
 
-    # @return [Nanoc::Int::OutdatednessChecker] The outdatedness checker
-    def outdatedness_checker
-      Nanoc::Int::OutdatednessChecker.new(
-        site: @site,
-        checksum_store: checksum_store,
-        dependency_tracker: dependency_tracker,
-      )
+    def create_view_context
+      Nanoc::ViewContext.new(reps: @reps, items: @site.items)
     end
-    memoize :outdatedness_checker
 
     private
 
-    # @return [Array<Nanoc::Int::Item>] The site’s items
-    def items
-      @site.items
-    end
-    memoize :items
-
-    # @return [Array<Nanoc::Int::ItemRep>] The site’s item representations
-    def reps
-      items.map(&:reps).flatten
-    end
-    memoize :reps
-
-    # @return [Array<Nanoc::Int::Layout>] The site’s layouts
-    def layouts
-      @site.layouts
-    end
-    memoize :layouts
-
-    # Compiles the given representations.
-    #
-    # @param [Array] reps The item representations to compile.
-    #
-    # @return [void]
-    def compile_reps(reps)
-      content_dependency_graph = Nanoc::Int::DirectedGraph.new(reps)
-
+    def compile_reps
       # Listen to processing start/stop
       Nanoc::Int::NotificationCenter.on(:processing_started, self) { |obj| @stack.push(obj) }
-      Nanoc::Int::NotificationCenter.on(:processing_ended,   self) { |_obj| @stack.pop }
+      Nanoc::Int::NotificationCenter.on(:processing_ended, self) { |_obj| @stack.pop }
 
       # Assign snapshots
-      reps.each do |rep|
-        rep.snapshot_defs = rules_collection.snapshots_defs_for(rep)
+      @reps.each do |rep|
+        rep.snapshot_defs = rule_memory_calculator.snapshots_defs_for(rep)
       end
 
-      # 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 }
+      # Find item reps to compile and compile them
+      selector = Nanoc::Int::ItemRepSelector.new(@reps)
+      selector.each do |rep|
         @stack = []
-
-        begin
-          compile_rep(rep)
-          content_dependency_graph.delete_vertex(rep)
-        rescue Nanoc::Int::Errors::UnmetDependency => e
-          other_rep = e.rep.unwrap rescue e.rep
-          content_dependency_graph.add_edge(other_rep, rep)
-          unless content_dependency_graph.vertices.include?(other_rep)
-            content_dependency_graph.add_vertex(other_rep)
-          end
-        end
-      end
-
-      # Check whether everything was compiled
-      unless content_dependency_graph.vertices.empty?
-        raise Nanoc::Int::Errors::RecursiveCompilation.new(content_dependency_graph.vertices)
+        compile_rep(rep)
       end
     ensure
       Nanoc::Int::NotificationCenter.remove(:processing_started, self)
@@ -371,26 +231,15 @@ module Nanoc::Int
     #
     # @return [void]
     def compile_rep(rep)
-      executor = Nanoc::Int::Executor.new(self)
-
       Nanoc::Int::NotificationCenter.post(:compilation_started, rep)
       Nanoc::Int::NotificationCenter.post(:processing_started,  rep)
       Nanoc::Int::NotificationCenter.post(:visit_started,       rep.item)
 
-      # Calculate rule memory if we haven’t yet done do
-      rules_collection.new_rule_memory_for_rep(rep)
-
-      if !rep.item.forced_outdated? && !outdatedness_checker.outdated?(rep) && compiled_content_cache[rep]
-        # Reuse content
+      if can_reuse_content_for_rep?(rep)
         Nanoc::Int::NotificationCenter.post(:cached_content_used, rep)
         rep.snapshot_contents = compiled_content_cache[rep]
       else
-        # Recalculate content
-        executor.snapshot(rep, :raw)
-        executor.snapshot(rep, :pre, final: false)
-        rules_collection.compilation_rule_for(rep).apply_to(rep, executor: executor, compiler: self)
-        executor.snapshot(rep, :post) if rep.has_snapshot?(:post)
-        executor.snapshot(rep, :last)
+        recalculate_content_for_rep(rep)
       end
 
       rep.compiled = true
@@ -406,53 +255,33 @@ module Nanoc::Int
       Nanoc::Int::NotificationCenter.post(:visit_ended, rep.item)
     end
 
-    # Clears the list of dependencies for items that will be recompiled.
-    #
-    # @param [Array<Nanoc::Int::Item>] items The list of items for which to forget
-    #   the dependencies
-    #
-    # @return [void]
-    def forget_dependencies_if_outdated(items)
-      items.each do |i|
-        if i.reps.any? { |r| outdatedness_checker.outdated?(r) }
-          dependency_tracker.forget_dependencies_for(i)
-        end
-      end
+    # @return [Boolean]
+    def can_reuse_content_for_rep?(rep)
+      !rep.item.forced_outdated? && !outdatedness_checker.outdated?(rep) && compiled_content_cache[rep]
     end
 
-    # Returns a preprocessor context, creating one if none exists yet.
-    def preprocessor_context
-      Nanoc::Int::Context.new(
-        config: Nanoc::MutableConfigView.new(@site.config),
-        items: Nanoc::MutableItemCollectionView.new(@site.items),
-        layouts: Nanoc::MutableLayoutCollectionView.new(@site.layouts),
-      )
-    end
-    memoize :preprocessor_context
-
-    # @return [Nanoc:Int::CompiledContentCache] The compiled content cache
-    def compiled_content_cache
-      Nanoc::Int::CompiledContentCache.new
-    end
-    memoize :compiled_content_cache
-
-    # @return [ChecksumStore] The checksum store
-    def checksum_store
-      Nanoc::Int::ChecksumStore.new(site: @site)
-    end
-    memoize :checksum_store
+    # @return [void]
+    def recalculate_content_for_rep(rep)
+      executor = Nanoc::Int::Executor.new(self)
 
-    # @return [RuleMemoryStore] The rule memory store
-    def rule_memory_store
-      Nanoc::Int::RuleMemoryStore.new(site: @site)
+      executor.snapshot(rep, :raw)
+      executor.snapshot(rep, :pre, final: false)
+      rules_collection.compilation_rule_for(rep)
+        .apply_to(rep, executor: executor, site: @site, view_context: create_view_context)
+      executor.snapshot(rep, :post) if rep.has_snapshot?(:post)
+      executor.snapshot(rep, :last)
     end
-    memoize :rule_memory_store
 
-    # @return [RuleMemoryCalculator] The rule memory calculator
-    def rule_memory_calculator
-      Nanoc::Int::RuleMemoryCalculator.new(rules_collection: rules_collection)
+    # Clears the list of dependencies for items that will be recompiled.
+    #
+    # @return [void]
+    def forget_dependencies_if_outdated
+      @site.items.each do |i|
+        if @reps[i].any? { |r| outdatedness_checker.outdated?(r) }
+          @dependency_store.forget_dependencies_for(i)
+        end
+      end
     end
-    memoize :rule_memory_calculator
 
     # Returns all stores that can load/store data that can be used for
     # compilation.
@@ -460,7 +289,7 @@ module Nanoc::Int
       [
         checksum_store,
         compiled_content_cache,
-        dependency_tracker,
+        @dependency_store,
         rule_memory_store,
       ]
     end