nanoc 3.2.4 → 3.3.0

data/README.md

@@ -0,0 +1,114 @@
+# nanoc 3
+
+nanoc is a simple but very flexible static site generator written in Ruby.
+It operates on local files, and therefore does not run on the server. nanoc
+“compiles” the local source files into HTML (usually), by evaluating eRuby,
+Markdown, etc.
+
+Note: This documentation looks best with Yardoc, not RDoc.
+
+## Resources
+
+The [nanoc web site](http://nanoc.stoneship.org) contains a few useful
+resources to help you get started with nanoc. If you need further assistance,
+the following places will help you out:
+
+* The [discussion group](http://groups.google.com/group/nanoc)
+* The [IRC channel](irc://chat.freenode.net/#nanoc)
+
+## Source Code Documentation
+
+The source code is located in `lib/nanoc` and is structured in a few
+directories:
+
+* `base` contains the bare essentials necessary for nanoc to function
+  * `source_data` contains raw, uncompiled content that will be compiled
+  * `result_data` contains the compiled content
+  * `compilation` contains the compilation functionality
+* `cli` contains the commandline interface
+* `data_sources` contains the standard data sources ({Nanoc::DataSource}
+  subclasses), such as the filesystem data source
+* `extra` contains stuff that is not needed by nanoc itself, but which may
+  be used by helpers, data sources, filters or VCSes.
+* `filters` contains the standard filters ({Nanoc::Filter} subclasses)
+  such as ERB, Markdown, Haml, …
+* `helpers` contains helpers, which provide functionality some sites
+  may find useful, such as the blogging and tagging helpers
+* `tasks` contains rake tasks that perform a variety of functions such as
+  validating HTML and CSS, uploading compiled files, …
+
+The namespaces (modules) are organised like this:
+
+* {Nanoc} is the namespace for everything nanoc-related (obviously). The
+  classes in `lib/nanoc/base` are part of this module (not `Nanoc::Base`)
+* {Nanoc::CLI} containing everything related to the commandline tool.
+* {Nanoc::DataSources} contains the data sources
+* {Nanoc::Helpers} contains the helpers
+* {Nanoc::Extra} contains useful stuff not needed by nanoc itself
+* {Nanoc::Filters} contains the (textual) filters
+
+The central class in nanoc is {Nanoc::Site}, so you should start there if
+you want to explore nanoc from a technical perspective.
+
+## Dependencies
+
+nanoc has few dependencies. It is possible to use nanoc programmatically
+without any dependencies at all, but if you want to use nanoc in a proper way,
+you’ll likely need some dependencies:
+
+* The **commandline frontend** depends on `cri`.
+* The **autocompiler** depends on `mime-types` and `rack`.
+* Filters and helpers likely have dependencies on their own too.
+
+If you’re developing for nanoc, such as writing custom filters or helpers, you
+may be interested in the development dependencies:
+
+* For **documentation generation** you’ll need `yard`.
+* For **packaging** you’ll need `rubygems` (1.3 or newer).
+* For **testing** you’ll need `mocha` and `minitest`.
+
+## Contributors
+
+(In alphabetical order)
+
+* Ben Armston
+* Colin Barrett
+* Bil Bas
+* Dmitry Bilunov
+* Fabian Buch
+* Devon Luke Buchanan
+* Stefan Bühler
+* Dan Callahan
+* Brian Candler
+* Jack Chu
+* Michal Cichra
+* Zaiste de Grengolada
+* Vincent Driessen
+* Chris Eppstein
+* Jeff Forcier
+* Riley Goodside
+* Felix Hanley
+* Justin Hileman
+* Starr Horne
+* Tuomas Kareinen
+* Matt Keveney
+* Kevin Lynagh
+* Nikhil Marathe
+* Daniel Mendler
+* Ale Muñoz
+* Nicky Peeters
+* Christian Plessl
+* Šime Ramov
+* Xavier Shay
+* Arnau Siches
+* “Soryu”
+* Eric Sunshine
+* Dennis Sutch
+* Matthias Vallentin
+* Ruben Verborgh
+* Scott Vokes
+* Toon Willems
+
+## Contact
+
+You can reach me at <denis.defreyne@stoneship.org>.

data/Rakefile

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+# Set up env
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/lib'))
+require './test/gem_loader.rb'
+
+# Load nanoc
+require 'nanoc'
+
+# Load tasks
+Dir.glob('tasks/**/*.rake').each { |r| Rake.application.add_import r }
+
+# Set default task
+task :default => :test

data/bin/nanoc

@@ -1,32 +1,12 @@
 #!/usr/bin/env ruby
 # encoding: utf-8
 
-# Find version
-version_file_path = File.join(ENV['APPDATA'] || ENV['HOME'], '.nanoc-select-version')
-if !File.exist?(version_file_path)
-  version = 3
-else
-  version = File.read(version_file_path).to_i
-end
+# Add lib to load path
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/../lib'))
 
-# Determine nanoc executable name
-VERSION_MAP = {
-  2 => 'nanoc2',
-  3 => 'nanoc3'
-}
-name = VERSION_MAP[version]
-if name.nil?
-  $stderr.puts "Unsupported nanoc version number: #{version}. Supported versions: #{VERSION_MAP.keys.join(', ')}."
-  exit 1
-end
+# Load nanoc
+require 'nanoc'
+require 'nanoc/cli'
 
-# Run nanoc
-begin
-  exec name, *ARGV
-rescue Errno::ENOENT
-  $stderr.puts "Could not execute #{name}, which is your selected nanoc version. Make sure that #{name} is installed and that it is in your $PATH."
-  $stderr.puts
-  $stderr.puts "* To install #{name}, run `gem install #{name}`."
-  $stderr.puts "* To select a different version of nanoc, run `nanoc-select`."
-  exit 1
-end
+# Run base
+Nanoc::CLI.run(ARGV)

data/bin/nanoc3

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+exec File.dirname(__FILE__) + '/nanoc', *ARGV

data/doc/yardoc_templates/default/layout/html/footer.erb

@@ -0,0 +1,10 @@
+<%= superb %>
+<script type="text/javascript">
+var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
+document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
+</script>
+<script type="text/javascript">
+try {
+var pageTracker = _gat._getTracker("UA-15639968-1");
+pageTracker._trackPageview();
+} catch(err) {}</script>

data/lib/nanoc.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module Nanoc
+
+  # The current nanoc version.
+  VERSION = '3.3.0'
+
+  # @return [String] A string containing information about this nanoc version
+  #   and its environment (Ruby engine and version, Rubygems version if any).
+  def self.version_information
+    gem_info = defined?(Gem) ? "with RubyGems #{Gem::VERSION}" : "without RubyGems"
+    engine   = defined?(RUBY_ENGINE) ? RUBY_ENGINE : "ruby"
+    res = ''
+    res << "nanoc #{Nanoc::VERSION} © 2007-2012 Denis Defreyne.\n".make_compatible_with_env
+    res << "Running #{engine} #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) on #{RUBY_PLATFORM} #{gem_info}.\n"
+    res
+  end
+
+end
+
+Nanoc3 = Nanoc
+
+# Load general requirements
+require 'digest'
+require 'enumerator'
+require 'fileutils'
+require 'forwardable'
+require 'pathname'
+require 'pstore'
+require 'set'
+require 'tempfile'
+require 'thread'
+require 'time'
+require 'yaml'
+
+# Load nanoc
+require 'nanoc/base'
+require 'nanoc/extra'
+require 'nanoc/data_sources'
+require 'nanoc/filters'
+require 'nanoc/helpers'

data/lib/nanoc/base.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module Nanoc
+
+  require 'nanoc/base/core_ext'
+  require 'nanoc/base/ordered_hash'
+
+  # Load helper classes
+  autoload 'Context',              'nanoc/base/context'
+  autoload 'DirectedGraph',        'nanoc/base/directed_graph'
+  autoload 'Errors',               'nanoc/base/errors'
+  autoload 'Memoization',          'nanoc/base/memoization'
+  autoload 'NotificationCenter',   'nanoc/base/notification_center'
+  autoload 'PluginRegistry',       'nanoc/base/plugin_registry'
+  autoload 'Store',                'nanoc/base/store'
+
+  # Load source data classes
+  autoload 'CodeSnippet',          'nanoc/base/source_data/code_snippet'
+  autoload 'Configuration',        'nanoc/base/source_data/configuration'
+  autoload 'DataSource',           'nanoc/base/source_data/data_source'
+  autoload 'Item',                 'nanoc/base/source_data/item'
+  autoload 'Layout',               'nanoc/base/source_data/layout'
+  autoload 'Site',                 'nanoc/base/source_data/site'
+
+  # Load result data classes
+  autoload 'ItemRep',              'nanoc/base/result_data/item_rep'
+
+  # Load compilation classes
+  autoload 'ChecksumStore',        'nanoc/base/compilation/checksum_store'
+  autoload 'CompiledContentCache', 'nanoc/base/compilation/compiled_content_cache'
+  autoload 'Compiler',             'nanoc/base/compilation/compiler'
+  autoload 'CompilerDSL',          'nanoc/base/compilation/compiler_dsl'
+  autoload 'DependencyTracker',    'nanoc/base/compilation/dependency_tracker'
+  autoload 'Filter',               'nanoc/base/compilation/filter'
+  autoload 'ItemRepProxy',         'nanoc/base/compilation/item_rep_proxy'
+  autoload 'ItemRepRecorderProxy', 'nanoc/base/compilation/item_rep_recorder_proxy'
+  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 'RuleMemoryStore',      'nanoc/base/compilation/rule_memory_store'
+  autoload 'RulesCollection',      'nanoc/base/compilation/rules_collection'
+
+  # Deprecated; use PluginRepository instead
+  # TODO [in nanoc 4.0] remove me
+  autoload 'Plugin',               'nanoc/base/plugin_registry'
+
+end

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

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+module Nanoc
+
+  # Stores checksums for objects in order to be able to detect whether a file
+  # has changed since the last site compilation.
+  #
+  # @api private
+  class ChecksumStore < ::Nanoc::Store
+
+    # @option params [Nanoc::Site] site The site where this checksum store
+    #   belongs to
+    def initialize(params={})
+      super('tmp/checksums', 1)
+
+      @site = params[:site] if params.has_key?(:site)
+
+      @checksums = {}
+    end
+
+    # Returns the old checksum for the given object. This makes sense for
+    # items, layouts and code snippets.
+    #
+    # @param [#reference] obj The object for which to fetch the checksum
+    #
+    # @return [String] The checksum for the given object
+    def [](obj)
+      @checksums[obj.reference]
+    end
+
+    # Sets the checksum for the given object.
+    #
+    # @param [#reference] obj The object for which to set the checksum
+    #
+    # @param [String] checksum The checksum
+    def []=(obj, checksum)
+      @checksums[obj.reference] = checksum
+    end
+
+    # @see Nanoc::Store#unload
+    def unload
+      @checksums = {}
+    end
+
+  protected
+
+    def data
+      @checksums
+    end
+
+    def data=(new_data)
+      @checksums = new_data
+    end
+
+  end
+
+end

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

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module Nanoc
+
+  # Represents a cache than can be used to store already compiled content,
+  # to prevent it from being needlessly recompiled.
+  #
+  # @api private
+  class CompiledContentCache < ::Nanoc::Store
+
+    def initialize
+      super('tmp/compiled_content', 1)
+
+      @cache = {}
+    end
+
+    # Returns the cached compiled content for the given item
+    # representation. This cached compiled content is a hash where the keys
+    # are the snapshot names and the values the compiled content at the
+    # given snapshot.
+    #
+    # @param [Nanoc::ItemRep] rep The item rep to fetch the content for
+    #
+    # @return [Hash<Symbol,String>] A hash containing the cached compiled
+    #   content for the given item representation
+    def [](rep)
+      item_cache = @cache[rep.item.identifier] || {}
+      item_cache[rep.name]
+    end
+
+    # Sets the compiled content for the given representation.
+    #
+    # @param [Nanoc::ItemRep] rep The item representation for which to set
+    #   the compiled content
+    #
+    # @param [Hash<Symbol,String>] content A hash containing the compiled
+    #   content of the given representation
+    #
+    # @return [void]
+    def []=(rep, content)
+      @cache[rep.item.identifier] ||= {}
+      @cache[rep.item.identifier][rep.name] = content
+    end
+
+    # @see Nanoc::Store#unload
+    def unload
+      @cache = {}
+    end
+
+  protected
+
+    def data
+      @cache
+    end
+
+    def data=(new_data)
+      @cache = new_data
+    end
+
+  end
+
+end

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

@@ -0,0 +1,458 @@
+# encoding: utf-8
+
+module Nanoc
+
+  # Responsible for compiling a site’s item representations.
+  #
+  # The compilation process makes use of notifications (see
+  # {Nanoc::NotificationCenter}) to track dependencies between items,
+  # layouts, etc. The following notifications are used:
+  #
+  # * `compilation_started` — indicates that the compiler has started
+  #   compiling this item representation. Has one argument: the item
+  #   representation itself. Only one item can be compiled at a given moment;
+  #   therefore, it is not possible to get two consecutive
+  #   `compilation_started` notifications without also getting a
+  #   `compilation_ended` notification in between them.
+  #
+  # * `compilation_ended` — indicates that the compiler has finished compiling
+  #   this item representation (either successfully or with failure). Has one
+  #   argument: the item representation itself.
+  #
+  # * `visit_started` — indicates that the compiler requires content or
+  #   attributes from the item representation that will be visited. Has one
+  #   argument: the visited item identifier. This notification is used to
+  #   track dependencies of items on other items; a `visit_started` event
+  #   followed by another `visit_started` event indicates that the item
+  #   corresponding to the former event will depend on the item from the
+  #   latter event.
+  #
+  # * `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
+
+    extend Nanoc::Memoization
+
+    # @group Accessors
+
+    # @return [Nanoc::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
+    # rep or layout, it will be removed from the stack.
+    #
+    # @return [Array] The compilation stack
+    attr_reader :stack
+
+    # @group Public instance methods
+
+    # Creates a new compiler fo the given site
+    #
+    # @param [Nanoc::Site] site The site this compiler belongs to
+    def initialize(site)
+      @site = site
+
+      @stack = []
+    end
+
+    # 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
+      dependency_tracker.start
+      compile_reps(reps)
+      dependency_tracker.stop
+      store
+    ensure
+      # Cleanup
+      FileUtils.rm_rf(Nanoc::Filter::TMP_BINARY_ITEMS_DIR)
+    end
+
+    # @group Private instance methods
+
+    # @return [Nanoc::RulesCollection] The collection of rules to be used
+    #   for compiling this site
+    def rules_collection
+      Nanoc::RulesCollection.new(self)
+    end
+    memoize :rules_collection
+
+    # Load the helper data that is used for compiling the site.
+    #
+    # @api private
+    #
+    # @return [void]
+    def load
+      return if @loaded || @loading
+      @loading = true
+
+      # Load site if necessary
+      site.load
+
+      # Preprocess
+      rules_collection.load
+      preprocess
+      site.setup_child_parent_links
+      build_reps
+      route_reps
+
+      # Load auxiliary stores
+      stores.each { |s| s.load }
+
+      # Determine which reps need to be recompiled
+      forget_dependencies_if_outdated(items)
+
+      @loaded = true
+    rescue => e
+      unload
+      raise e
+    ensure
+      @loading = false
+    end
+
+    # Undoes the effects of {#load}. Used when {#load} raises an exception.
+    #
+    # @api private
+    #
+    # @return [void]
+    def unload
+      return if @unloading
+      @unloading = true
+
+      stores.each { |s| s.unload }
+
+      @stack = []
+
+      items.each { |item| item.reps.clear }
+      site.teardown_child_parent_links
+      rules_collection.unload
+
+      site.unload
+
+      @loaded = false
+      @unloading = false
+    end
+
+    # Store the modified helper data used for compiling the site.
+    #
+    # @api private
+    #
+    # @return [void]
+    def store
+      # Calculate rule memory
+      (reps + layouts).each do |obj|
+        rule_memory_store[obj] = rule_memory_calculator[obj]
+      end
+
+      # Calculate checksums
+      self.objects.each do |obj|
+        checksum_store[obj] = obj.checksum
+      end
+
+      # 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 [Nanoc::DependencyTracker] The dependency tracker for this site
+    def dependency_tracker
+      dt = Nanoc::DependencyTracker.new(@site.items + @site.layouts)
+      dt.compiler = self
+      dt
+    end
+    memoize :dependency_tracker
+
+    # Runs the preprocessor.
+    #
+    # @api private
+    def preprocess
+      return if rules_collection.preprocessor.nil?
+      preprocessor_context.instance_eval(&rules_collection.preprocessor)
+    end
+
+    # Returns all objects managed by the site (items, layouts, code snippets,
+    # site configuration and the rules).
+    #
+    # @api private
+    def objects
+      site.items + site.layouts + site.code_snippets +
+        [ 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::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.each do |rep|
+        # Find matching rules
+        rules = rules_collection.routing_rules_for(rep)
+        raise Nanoc::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?
+          if basic_path !~ %r{^/}
+            raise RuntimeError, "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.".make_compatible_with_env
+          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|
+            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 [Nanoc::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
+    #
+    # @api private
+    def assigns_for(rep)
+      if rep.binary?
+        content_or_filename_assigns = { :filename => rep.temporary_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
+
+    # @return [Nanoc::OutdatednessChecker] The outdatedness checker
+    def outdatedness_checker
+      Nanoc::OutdatednessChecker.new(
+        :site => @site,
+        :checksum_store => checksum_store,
+        :dependency_tracker => dependency_tracker)
+    end
+    memoize :outdatedness_checker
+
+  private
+
+    # @return [Array<Nanoc::Item>] The site’s items
+    def items
+      @site.items
+    end
+    memoize :items
+
+    # @return [Array<Nanoc::ItemRep>] The site’s item representations
+    def reps
+      items.map { |i| i.reps }.flatten
+    end
+    memoize :reps
+
+    # @return [Array<Nanoc::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::DirectedGraph.new(reps)
+
+      # Listen to processing start/stop
+      Nanoc::NotificationCenter.on(:processing_started, self) { |obj| @stack.push(obj) }
+      Nanoc::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 = []
+
+        begin
+          compile_rep(rep)
+          content_dependency_graph.delete_vertex(rep)
+        rescue Nanoc::Errors::UnmetDependency => e
+          content_dependency_graph.add_edge(e.rep, rep)
+          unless content_dependency_graph.vertices.include?(e.rep)
+            content_dependency_graph.add_vertex(e.rep)
+          end
+        end
+      end
+
+      # Check whether everything was compiled
+      if !content_dependency_graph.vertices.empty?
+        raise Nanoc::Errors::RecursiveCompilation.new(content_dependency_graph.vertices)
+      end
+    ensure
+      Nanoc::NotificationCenter.remove(:processing_started, self)
+      Nanoc::NotificationCenter.remove(:processing_ended,   self)
+    end
+
+    # Compiles the given item representation.
+    #
+    # This method should not be called directly; please use
+    # {Nanoc::Compiler#run} instead, and pass this item representation's item
+    # as its first argument.
+    #
+    # @param [Nanoc::ItemRep] rep The rep that is to be compiled
+    #
+    # @return [void]
+    def compile_rep(rep)
+      Nanoc::NotificationCenter.post(:compilation_started, rep)
+      Nanoc::NotificationCenter.post(:processing_started,  rep)
+      Nanoc::NotificationCenter.post(:visit_started,       rep.item)
+
+      # Calculate rule memory if we haven’t yet done do
+      rules_collection.new_rule_memory_for_rep(rep)
+
+      # Assign snapshots
+      rep.snapshots = rules_collection.snapshots_for(rep)
+
+      if !outdatedness_checker.outdated?(rep) && compiled_content_cache[rep]
+        # Reuse content
+        Nanoc::NotificationCenter.post(:cached_content_used, rep)
+        rep.content = compiled_content_cache[rep]
+      else
+        # Recalculate content
+        rep.snapshot(:raw)
+        rep.snapshot(:pre, :final => false)
+        rules_collection.compilation_rule_for(rep).apply_to(rep, :compiler => self)
+        rep.snapshot(:post) if rep.has_snapshot?(:post)
+        rep.snapshot(:last)
+      end
+
+      rep.compiled = true
+      compiled_content_cache[rep] = rep.content
+    rescue => e
+      rep.forget_progress
+      Nanoc::NotificationCenter.post(:compilation_failed, rep, e)
+      raise e
+    ensure
+      Nanoc::NotificationCenter.post(:visit_ended,       rep.item)
+      Nanoc::NotificationCenter.post(:processing_ended,  rep)
+      Nanoc::NotificationCenter.post(:compilation_ended, rep)
+    end
+
+    # Clears the list of dependencies for items that will be recompiled.
+    #
+    # @param [Array<Nanoc::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
+    end
+
+    # Returns a preprocessor context, creating one if none exists yet.
+    def preprocessor_context
+      Nanoc::Context.new({
+        :site    => @site,
+        :config  => @site.config,
+        :items   => @site.items,
+        :layouts => @site.layouts
+      })
+    end
+    memoize :preprocessor_context
+
+    # @return [CompiledContentCache] The compiled content cache
+    def compiled_content_cache
+      Nanoc::CompiledContentCache.new
+    end
+    memoize :compiled_content_cache
+
+    # @return [ChecksumStore] The checksum store
+    def checksum_store
+      Nanoc::ChecksumStore.new(:site => @site)
+    end
+    memoize :checksum_store
+
+    # @return [RuleMemoryStore] The rule memory store
+    def rule_memory_store
+      Nanoc::RuleMemoryStore.new(:site => @site)
+    end
+    memoize :rule_memory_store
+
+    # @return [RuleMemoryCalculator] The rule memory calculator
+    def rule_memory_calculator
+      Nanoc::RuleMemoryCalculator.new(:rules_collection => rules_collection)
+    end
+    memoize :rule_memory_calculator
+
+    # Returns all stores that can load/store data that can be used for
+    # compilation.
+    def stores
+      [
+        checksum_store,
+        compiled_content_cache,
+        dependency_tracker,
+        rule_memory_store
+      ]
+    end
+
+  end
+
+end