nanoc 4.0.2 → 4.1.0a1

data/lib/nanoc/base/entities/rule_memory_actions/snapshot.rb

@@ -0,0 +1,26 @@
+module Nanoc::Int::RuleMemoryActions
+  class Snapshot < Nanoc::Int::RuleMemoryAction
+    # snapshot :before_layout
+    # snapshot :before_layout, final: true
+    # snapshot :before_layout, path: '/about.md'
+
+    attr_reader :snapshot_name
+    attr_reader :final
+    attr_reader :path
+    alias_method :final?, :final
+
+    def initialize(snapshot_name, final, path)
+      @snapshot_name = snapshot_name
+      @final = final
+      @path = path
+    end
+
+    def serialize
+      [:snapshot, @snapshot_name, @final, @path]
+    end
+
+    def to_s
+      "snapshot #{@snapshot_name.inspect}, final: #{@final.inspect}, path: #{@path.inspect}"
+    end
+  end
+end

data/lib/nanoc/base/entities/rules_collection.rb

@@ -0,0 +1,120 @@
+module Nanoc::Int
+  # Keeps track of the rules in a site.
+  #
+  # @api private
+  class RulesCollection
+    # @return [String] the contents of the Rules file
+    attr_accessor :data
+
+    # The hash containing layout-to-filter mapping rules. This hash is
+    # ordered: iterating over the hash will happen in insertion order.
+    #
+    # @return [Hash] The layout-to-filter mapping rules
+    attr_reader :layout_filter_mapping
+
+    # The hash containing preprocessor code blocks that will be executed after
+    #   all data is loaded but before the site is compiled.
+    #
+    # @return [Hash] The hash containing the preprocessor code blocks that will
+    #   be executed after all data is loaded but before the site is compiled
+    attr_accessor :preprocessors
+
+    # The hash containing postprocessor code blocks that will be executed after
+    #   all data is loaded and the site is compiled.
+    #
+    # @return [Hash] The hash containing the postprocessor code blocks that will
+    #   be executed after all data is loaded and the site is compiled
+    attr_accessor :postprocessors
+
+    def initialize
+      @item_compilation_rules = []
+      @item_routing_rules     = []
+      @layout_filter_mapping  = {}
+      @preprocessors          = {}
+      @postprocessors         = {}
+    end
+
+    # Add the given rule to the list of item compilation rules.
+    #
+    # @param [Nanoc::Int::Rule] rule The item compilation rule to add
+    #
+    # @return [void]
+    def add_item_compilation_rule(rule)
+      @item_compilation_rules << rule
+    end
+
+    # Add the given rule to the list of item routing rules.
+    #
+    # @param [Nanoc::Int::Rule] rule The item routing rule to add
+    #
+    # @return [void]
+    def add_item_routing_rule(rule)
+      @item_routing_rules << rule
+    end
+
+    # @param [Nanoc::Int::Item] item The item for which the compilation rules
+    #   should be retrieved
+    #
+    # @return [Array] The list of item compilation rules for the given item
+    def item_compilation_rules_for(item)
+      @item_compilation_rules.select { |r| r.applicable_to?(item) }
+    end
+
+    # Finds the first matching compilation rule for the given item
+    # representation.
+    #
+    # @param [Nanoc::Int::ItemRep] rep The item rep for which to fetch the rule
+    #
+    # @return [Nanoc::Int::Rule, nil] The compilation rule for the given item rep,
+    #   or nil if no rules have been found
+    def compilation_rule_for(rep)
+      @item_compilation_rules.find do |rule|
+        rule.applicable_to?(rep.item) && rule.rep_name == rep.name
+      end
+    end
+
+    # Returns the list of routing rules that can be applied to the given item
+    # representation. For each snapshot, the first matching rule will be
+    # returned. The result is a hash containing the corresponding rule for
+    # each snapshot.
+    #
+    # @param [Nanoc::Int::ItemRep] rep The item rep for which to fetch the rules
+    #
+    # @return [Hash<Symbol, Nanoc::Int::Rule>] The routing rules for the given rep
+    def routing_rules_for(rep)
+      rules = {}
+      @item_routing_rules.each do |rule|
+        next unless rule.applicable_to?(rep.item)
+        next if rule.rep_name != rep.name
+        next if rules.key?(rule.snapshot_name)
+
+        rules[rule.snapshot_name] = rule
+      end
+      rules
+    end
+
+    # Finds the filter name and arguments to use for the given layout.
+    #
+    # @param [Nanoc::Int::Layout] layout The layout for which to fetch the filter.
+    #
+    # @return [Array, nil] A tuple containing the filter name and the filter
+    #   arguments for the given layout.
+    def filter_for_layout(layout)
+      @layout_filter_mapping.each_pair do |pattern, filter_name_and_args|
+        return filter_name_and_args if pattern.match?(layout.identifier)
+      end
+      nil
+    end
+
+    # Returns an object that can be used for uniquely identifying objects.
+    #
+    # @return [Object] An unique reference to this object
+    def reference
+      :rules
+    end
+
+    def inspect
+      "<#{self.class}>"
+    end
+  end
+end

data/lib/nanoc/base/{source_data → entities}/site.rb

@@ -1,14 +1,15 @@
 module Nanoc::Int
   # @api private
   class Site
-    # @option params [Nanoc::Int::Configuration] :config
-    #
-    # @option params [Enumerable<Nanoc::Int::CodeSnippet>] :code_snippets
-    def initialize(params = {})
-      @config = params.fetch(:config)
-      @code_snippets = params.fetch(:code_snippets)
-      @items = params.fetch(:items)
-      @layouts = params.fetch(:layouts)
+    # @param [Nanoc::Int::Configuration] config
+    # @param [Enumerable<Nanoc::Int::CodeSnippet>] code_snippets
+    # @param [Enumerable<Nanoc::Int::Item>] items
+    # @param [Enumerable<Nanoc::Int::Layout>] layouts
+    def initialize(config:, code_snippets:, items:, layouts:)
+      @config = config
+      @code_snippets = code_snippets
+      @items = items
+      @layouts = layouts
 
       ensure_identifier_uniqueness(@items, 'item')
       ensure_identifier_uniqueness(@layouts, 'layout')
@@ -20,7 +21,7 @@ module Nanoc::Int
     #
     # @since 3.2.0
     def compile
-      compiler.run
+      compiler.run_all
     end
 
     # Returns the compiler for this site. Will create a new compiler if none
@@ -28,7 +29,7 @@ module Nanoc::Int
     #
     # @return [Nanoc::Int::Compiler] The compiler for this site
     def compiler
-      @compiler ||= Nanoc::Int::Compiler.new(self)
+      @compiler ||= Nanoc::Int::CompilerLoader.new.load(self)
     end
 
     attr_reader :code_snippets

data/lib/nanoc/base/repos.rb

@@ -3,5 +3,7 @@ require_relative 'repos/store'
 require_relative 'repos/checksum_store'
 require_relative 'repos/compiled_content_cache'
 require_relative 'repos/config_loader'
+require_relative 'repos/data_source'
+require_relative 'repos/dependency_store'
 require_relative 'repos/rule_memory_store'
 require_relative 'repos/site_loader'

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

@@ -4,12 +4,11 @@ module Nanoc::Int
   #
   # @api private
   class ChecksumStore < ::Nanoc::Int::Store
-    # @option params [Nanoc::Int::Site] site The site where this checksum store
-    #   belongs to
-    def initialize(params = {})
+    # @param [Nanoc::Int::Site] site
+    def initialize(site: nil)
       super('tmp/checksums', 1)
 
-      @site = params[:site] if params.key?(:site)
+      @site = site
 
       @checksums = {}
     end
@@ -33,11 +32,6 @@ module Nanoc::Int
       @checksums[obj.reference] = checksum
     end
 
-    # @see Nanoc::Int::Store#unload
-    def unload
-      @checksums = {}
-    end
-
     protected
 
     def data

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

@@ -38,11 +38,6 @@ module Nanoc::Int
       @cache[rep.item.identifier][rep.name] = content
     end
 
-    # @see Nanoc::Int::Store#unload
-    def unload
-      @cache = {}
-    end
-
     protected
 
     def data

data/lib/nanoc/base/{source_data → repos}/data_source.rb

@@ -138,12 +138,9 @@ module Nanoc
     #
     # @param [String] identifier This item's identifier.
     #
-    # @param [Hash] params Extra parameters.
-    #
-    # @option params [Symbol, nil] :binary (true) Whether or not this item is
-    #   binary
-    def new_item(content, attributes, identifier, params = {})
-      content = Nanoc::Int::Content.create(content, params)
+    # @param [Boolean] :binary Whether or not this item is binary
+    def new_item(content, attributes, identifier, binary: false)
+      content = Nanoc::Int::Content.create(content, binary: binary)
       Nanoc::Int::Item.new(content, attributes, identifier)
     end
 

data/lib/nanoc/base/repos/dependency_store.rb

@@ -0,0 +1,118 @@
+module Nanoc::Int
+  # @api private
+  class DependencyStore < ::Nanoc::Int::Store
+    # @return [Array<Nanoc::Int::Item, Nanoc::Int::Layout>]
+    attr_reader :objects
+
+    # @param [Array<Nanoc::Int::Item, Nanoc::Int::Layout>] objects
+    def initialize(objects)
+      super('tmp/dependencies', 4)
+
+      @objects = objects
+      @graph   = Nanoc::Int::DirectedGraph.new([nil] + @objects)
+    end
+
+    # Returns the direct dependencies for the given object.
+    #
+    # The direct dependencies of the given object include the items and
+    # layouts that, when outdated will cause the given object to be marked as
+    # outdated. Indirect dependencies will not be returned (e.g. if A depends
+    # on B which depends on C, then the direct dependencies of A do not
+    # include C).
+    #
+    # The direct predecessors can include nil, which indicates an item that is
+    # no longer present in the site.
+    #
+    # @param [Nanoc::Int::Item, Nanoc::Int::Layout] object The object for
+    #   which to fetch the direct predecessors
+    #
+    # @return [Array<Nanoc::Int::Item, Nanoc::Int::Layout, nil>] The direct
+    # predecessors of
+    #   the given object
+    def objects_causing_outdatedness_of(object)
+      @graph.direct_predecessors_of(object)
+    end
+
+    # Returns the direct inverse dependencies for the given object.
+    #
+    # The direct inverse dependencies of the given object include the objects
+    # that will be marked as outdated when the given object is outdated.
+    # Indirect dependencies will not be returned (e.g. if A depends on B which
+    # depends on C, then the direct inverse dependencies of C do not include
+    # A).
+    #
+    # @param [Nanoc::Int::Item, Nanoc::Int::Layout] object The object for which to
+    #   fetch the direct successors
+    #
+    # @return [Array<Nanoc::Int::Item, Nanoc::Int::Layout>] The direct successors of
+    #   the given object
+    def objects_outdated_due_to(object)
+      @graph.direct_successors_of(object).compact
+    end
+
+    # Records a dependency from `src` to `dst` in the dependency graph. When
+    # `dst` is oudated, `src` will also become outdated.
+    #
+    # @param [Nanoc::Int::Item, Nanoc::Int::Layout] src The source of the dependency,
+    #   i.e. the object that will become outdated if dst is outdated
+    #
+    # @param [Nanoc::Int::Item, Nanoc::Int::Layout] dst The destination of the
+    #   dependency, i.e. the object that will cause the source to become
+    #   outdated if the destination is outdated
+    #
+    # @return [void]
+    def record_dependency(src, dst)
+      # Warning! dst and src are *reversed* here!
+      @graph.add_edge(dst, src) unless src == dst
+    end
+
+    # Empties the list of dependencies for the given object. This is necessary
+    # before recompiling the given object, because otherwise old dependencies
+    # will stick around and new dependencies will appear twice. This function
+    # removes all incoming edges for the given vertex.
+    #
+    # @param [Nanoc::Int::Item, Nanoc::Int::Layout] object The object for which to
+    #   forget all dependencies
+    #
+    # @return [void]
+    def forget_dependencies_for(object)
+      @graph.delete_edges_to(object)
+    end
+
+    protected
+
+    def data
+      {
+        edges: @graph.edges,
+        vertices: @graph.vertices.map { |obj| obj && obj.reference },
+      }
+    end
+
+    def data=(new_data)
+      # Create new graph
+      @graph = Nanoc::Int::DirectedGraph.new([nil] + @objects)
+
+      # Load vertices
+      previous_objects = new_data[:vertices].map do |reference|
+        @objects.find { |obj| reference == obj.reference }
+      end
+
+      # Load edges
+      new_data[:edges].each do |edge|
+        from_index, to_index = *edge
+        from = from_index && previous_objects[from_index]
+        to   = to_index && previous_objects[to_index]
+        @graph.add_edge(from, to)
+      end
+
+      # Record dependency from all items on new items
+      new_objects = (@objects - previous_objects)
+      new_objects.each do |new_obj|
+        @objects.each do |obj|
+          next unless obj.is_a?(Nanoc::Int::Item)
+          @graph.add_edge(new_obj, obj)
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/base/repos/rule_memory_store.rb

@@ -4,13 +4,9 @@ module Nanoc::Int
   #
   # @api private
   class RuleMemoryStore < ::Nanoc::Int::Store
-    # @option params [Nanoc::Int::Site] site The site where this rule memory store
-    #   belongs to
-    def initialize(params = {})
+    def initialize
       super('tmp/rule_memory', 1)
 
-      @site = params[:site] if params.key?(:site)
-
       @rule_memories = {}
     end
 

data/lib/nanoc/base/repos/site_loader.rb

@@ -12,32 +12,6 @@ module Nanoc::Int
       site_from_config(Nanoc::Int::ConfigLoader.new.new_from_cwd)
     end
 
-    # @api private
-    def setup_child_parent_links(items)
-      items.each do |item|
-        item.parent = nil
-        item.children = []
-      end
-
-      item_map = {}
-      items.each do |item|
-        next if item.identifier !~ /\/\z/
-        item_map[item.identifier.to_s] = item
-      end
-
-      items.each do |item|
-        parent_id_end = item.identifier.to_s.rindex('/', -2)
-        next unless parent_id_end
-
-        parent_id = item.identifier.to_s[0..parent_id_end]
-        parent = item_map[parent_id]
-        next unless parent
-
-        item.parent = parent
-        parent.children << item
-      end
-    end
-
     private
 
     def site_from_config(config)
@@ -60,8 +34,6 @@ module Nanoc::Int
         end
       end
 
-      setup_child_parent_links(items)
-
       Nanoc::Int::Site.new(
         config: config,
         code_snippets: code_snippets,

data/lib/nanoc/base/repos/store.rb

@@ -57,15 +57,9 @@ module Nanoc::Int
     #
     # @return [void]
     def load
-      # Don’t load twice
-      if @loaded
-        return
-      end
-
       # Check file existance
       unless File.file?(filename)
         no_data_found
-        @loaded = true
         return
       end
 
@@ -74,13 +68,11 @@ module Nanoc::Int
           # Check version
           if pstore[:version] != version
             version_mismatch_detected
-            @loaded = true
             return
           end
 
           # Load
           self.data = pstore[:data]
-          @loaded = true
         end
       rescue
         FileUtils.rm_f(filename)
@@ -88,10 +80,6 @@ module Nanoc::Int
       end
     end
 
-    # Undoes the effects of {#load}. Used when {#load} raises an exception.
-    def unload
-    end
-
     # Stores the data contained in memory to the filesystem. This method will
     #   use the {#data} method to fetch the data that should be written.
     #