nanoc 4.4.4 → 4.4.5

data/lib/nanoc/base/errors.rb

@@ -207,5 +207,14 @@ module Nanoc::Int
         super("You cannot get the parent or children of an item that has a “full” identifier (#{identifier}). Getting the parent or children of an item is only possible for items that have a legacy identifier.")
       end
     end
+
+    class UndefinedFilterForLayout < Generic
+      def initialize(layout)
+        super("There is no filter defined for the layout #{layout.identifier}")
+      end
+    end
+
+    class InternalInconsistency < Generic
+    end
   end
 end

data/lib/nanoc/base/memoization.rb

@@ -4,8 +4,6 @@ module Nanoc::Int
   # Adds support for memoizing functions.
   #
   # @api private
-  #
-  # @since 3.2.0
   module Memoization
     class Wrapper
       attr_reader :ref

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

@@ -6,27 +6,25 @@ module Nanoc::Int
   class ChecksumStore < ::Nanoc::Int::Store
     include Nanoc::Int::ContractsSupport
 
-    # @param [Nanoc::Int::Site] site
-    def initialize(site: nil)
+    attr_accessor :objects
+
+    c_obj = C::Or[Nanoc::Int::Item, Nanoc::Int::Layout, Nanoc::Int::Configuration, Nanoc::Int::CodeSnippet]
+
+    contract C::KeywordArgs[site: C::Maybe[Nanoc::Int::Site], objects: C::IterOf[c_obj]] => C::Any
+    def initialize(site: nil, objects:)
       super(Nanoc::Int::Store.tmp_path_for(env_name: (site.config.env_name if site), store_name: 'checksums'), 1)
 
-      @site = site
+      @objects = objects
 
       @checksums = {}
     end
 
-    contract C::Any => C::Maybe[String]
-    # 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
+    contract c_obj => C::Maybe[String]
     def [](obj)
       @checksums[obj.reference]
     end
 
-    # Calculates and stores the checksum for the given object.
+    contract c_obj => self
     def add(obj)
       if obj.is_a?(Nanoc::Int::Document)
         @checksums[[obj.reference, :content]] = Nanoc::Int::Checksummer.calc_for_content_of(obj)
@@ -34,14 +32,16 @@ module Nanoc::Int
       end
 
       @checksums[obj.reference] = Nanoc::Int::Checksummer.calc(obj)
+
+      self
     end
 
-    contract C::Any => C::Maybe[String]
+    contract c_obj => C::Maybe[String]
     def content_checksum_for(obj)
       @checksums[[obj.reference, :content]]
     end
 
-    contract C::Any => C::Maybe[String]
+    contract c_obj => C::Maybe[String]
     def attributes_checksum_for(obj)
       @checksums[[obj.reference, :attributes]]
     end
@@ -53,7 +53,14 @@ module Nanoc::Int
     end
 
     def data=(new_data)
-      @checksums = new_data
+      references = Set.new(@objects.map(&:reference))
+
+      @checksums = {}
+      new_data.each_pair do |key, checksum|
+        if references.include?(key) || references.include?(key.first)
+          @checksums[key] = checksum
+        end
+      end
     end
   end
 end

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

@@ -4,6 +4,9 @@ module Nanoc::Int
   #
   # @api private
   class CompiledContentCache < ::Nanoc::Int::Store
+    include Nanoc::Int::ContractsSupport
+
+    contract C::KeywordArgs[env_name: C::Maybe[String], items: C::IterOf[Nanoc::Int::Item]] => C::Any
     def initialize(env_name: nil, items:)
       super(Nanoc::Int::Store.tmp_path_for(env_name: env_name, store_name: 'compiled_content'), 2)
 
@@ -11,32 +14,25 @@ module Nanoc::Int
       @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::Int::ItemRep] rep The item rep to fetch the content for
+    contract Nanoc::Int::ItemRep => C::Maybe[C::HashOf[Symbol => Nanoc::Int::Content]]
+    # Returns the cached compiled content for the given item representation.
     #
-    # @return [Hash<Symbol,String>] A hash containing 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.
     def [](rep)
       item_cache = @cache[rep.item.identifier] || {}
       item_cache[rep.name]
     end
 
+    contract Nanoc::Int::ItemRep, C::HashOf[Symbol => Nanoc::Int::Content] => self
     # Sets the compiled content for the given representation.
     #
-    # @param [Nanoc::Int::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]
+    # This cached compiled content is a hash where the keys are the snapshot
+    # names. and the values the compiled content at the given snapshot.
     def []=(rep, content)
       @cache[rep.item.identifier] ||= {}
       @cache[rep.item.identifier][rep.name] = content
+      self
     end
 
     protected

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

@@ -11,7 +11,8 @@ module Nanoc::Int
       super(Nanoc::Int::Store.tmp_path_for(env_name: env_name, store_name: 'dependencies'), 4)
 
       @objects = objects
-      @graph   = Nanoc::Int::DirectedGraph.new([nil] + @objects)
+      @new_objects = []
+      @graph = Nanoc::Int::DirectedGraph.new([nil] + @objects)
     end
 
     contract C::Or[Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout] => C::ArrayOf[Nanoc::Int::Dependency]
@@ -50,24 +51,11 @@ module Nanoc::Int
     # 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
+      if @new_objects.any?
+        [@new_objects.first]
+      else
+        @graph.direct_predecessors_of(object)
+      end
     end
 
     contract C::Maybe[C::Or[Nanoc::Int::Item, Nanoc::Int::Layout]], C::Maybe[C::Or[Nanoc::Int::Item, Nanoc::Int::Layout]], C::KeywordArgs[raw_content: C::Optional[C::Bool], attributes: C::Optional[C::Bool], compiled_content: C::Optional[C::Bool], path: C::Optional[C::Bool]] => C::Any
@@ -141,14 +129,7 @@ module Nanoc::Int
       end
 
       # Record dependency from all items on new items
-      new_objects = (@objects - previous_objects)
-      new_props = { raw_content: true, attributes: true, compiled_content: true, path: true }
-      new_objects.each do |new_obj|
-        @objects.each do |obj|
-          next unless obj.is_a?(Nanoc::Int::Item)
-          @graph.add_edge(new_obj, obj, props: new_props)
-        end
-      end
+      @new_objects = @objects - previous_objects
     end
   end
 end

data/lib/nanoc/base/services.rb

@@ -1,5 +1,6 @@
 require_relative 'services/action_provider'
 require_relative 'services/checksummer'
+require_relative 'services/compiler'
 require_relative 'services/compiler_loader'
 require_relative 'services/dependency_tracker'
 require_relative 'services/executor'
@@ -13,3 +14,5 @@ require_relative 'services/pruner'
 require_relative 'services/temp_filename_factory'
 require_relative 'services/outdatedness_rule'
 require_relative 'services/outdatedness_rules'
+
+require_relative 'services/outdatedness_checker'

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

@@ -0,0 +1,379 @@
+module Nanoc::Int
+  # Responsible for compiling a site’s item representations.
+  #
+  # The compilation process makes use of notifications (see
+  # {Nanoc::Int::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.
+  #
+  # @api private
+  class Compiler
+    # Provides common functionality for accesing “context” of an item that is being compiled.
+    class CompilationContext
+      def initialize(action_provider:, reps:, site:, compiled_content_cache:)
+        @action_provider = action_provider
+        @reps = reps
+        @site = site
+        @compiled_content_cache = compiled_content_cache
+      end
+
+      def filter_name_and_args_for_layout(layout)
+        mem = @action_provider.memory_for(layout)
+        if mem.nil? || mem.size != 1 || !mem[0].is_a?(Nanoc::Int::ProcessingActions::Filter)
+          raise Nanoc::Int::Errors::UndefinedFilterForLayout.new(layout)
+        end
+        [mem[0].filter_name, mem[0].params]
+      end
+
+      def create_view_context(dependency_tracker)
+        Nanoc::ViewContext.new(
+          reps: @reps,
+          items: @site.items,
+          dependency_tracker: dependency_tracker,
+          compilation_context: self,
+        )
+      end
+
+      def assigns_for(rep, dependency_tracker)
+        content_or_filename_assigns =
+          if rep.binary?
+            { filename: rep.snapshot_contents[:last].filename }
+          else
+            { content: rep.snapshot_contents[:last].string }
+          end
+
+        view_context = create_view_context(dependency_tracker)
+
+        content_or_filename_assigns.merge(
+          item: Nanoc::ItemWithRepsView.new(rep.item, view_context),
+          rep: Nanoc::ItemRepView.new(rep, view_context),
+          item_rep: Nanoc::ItemRepView.new(rep, view_context),
+          items: Nanoc::ItemCollectionWithRepsView.new(@site.items, view_context),
+          layouts: Nanoc::LayoutCollectionView.new(@site.layouts, view_context),
+          config: Nanoc::ConfigView.new(@site.config, view_context),
+        )
+      end
+
+      def site
+        @site
+      end
+
+      def compiled_content_cache
+        @compiled_content_cache
+      end
+    end
+
+    # Provides functionality for (re)calculating the content of an item rep, without caching or
+    # outdatedness checking.
+    class RecalculatingItemRepCompiler
+      include Nanoc::Int::ContractsSupport
+
+      def initialize(action_provider:, dependency_store:, compilation_context:)
+        @action_provider = action_provider
+        @dependency_store = dependency_store
+        @compilation_context = compilation_context
+      end
+
+      contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => C::Any
+      def run(rep, is_outdated:) # rubocop:disable Lint/UnusedMethodArgument
+        dependency_tracker = Nanoc::Int::DependencyTracker.new(@dependency_store)
+        dependency_tracker.enter(rep.item)
+
+        executor = Nanoc::Int::Executor.new(rep, @compilation_context, dependency_tracker)
+
+        @action_provider.memory_for(rep).each do |action|
+          case action
+          when Nanoc::Int::ProcessingActions::Filter
+            executor.filter(action.filter_name, action.params)
+          when Nanoc::Int::ProcessingActions::Layout
+            executor.layout(action.layout_identifier, action.params)
+          when Nanoc::Int::ProcessingActions::Snapshot
+            executor.snapshot(action.snapshot_name, final: action.final?, path: action.path)
+          else
+            raise Nanoc::Int::Errors::InternalInconsistency, "unknown action #{action.inspect}"
+          end
+        end
+      ensure
+        dependency_tracker.exit
+      end
+    end
+
+    # Provides functionality for (re)calculating the content of an item rep, with caching or
+    # outdatedness checking. Delegates to RecalculatingItemRepCompiler if outdated or no cache available.
+    class CachingItemRepCompiler
+      include Nanoc::Int::ContractsSupport
+
+      def initialize(compiled_content_cache:, wrapped:)
+        @compiled_content_cache = compiled_content_cache
+        @wrapped = wrapped
+      end
+
+      contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => C::Any
+      def run(rep, is_outdated:)
+        if can_reuse_content_for_rep?(rep, is_outdated: is_outdated)
+          Nanoc::Int::NotificationCenter.post(:cached_content_used, rep)
+          rep.snapshot_contents = @compiled_content_cache[rep]
+        else
+          @wrapped.run(rep, is_outdated: is_outdated)
+        end
+
+        rep.compiled = true
+        @compiled_content_cache[rep] = rep.snapshot_contents
+      end
+
+      contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => C::Bool
+      def can_reuse_content_for_rep?(rep, is_outdated:)
+        !is_outdated && !@compiled_content_cache[rep].nil?
+      end
+    end
+
+    # Provides functionality for suspending and resuming item rep compilation (using fibers).
+    class ResumableItemRepCompiler
+      include Nanoc::Int::ContractsSupport
+
+      def initialize(wrapped:)
+        @wrapped = wrapped
+      end
+
+      contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => C::Any
+      def run(rep, is_outdated:)
+        fiber = fiber_for(rep, is_outdated: is_outdated)
+        while fiber.alive?
+          Nanoc::Int::NotificationCenter.post(:compilation_started, rep)
+          res = fiber.resume
+
+          case res
+          when Nanoc::Int::Errors::UnmetDependency
+            Nanoc::Int::NotificationCenter.post(:compilation_suspended, rep, res)
+            raise(res)
+          when Proc
+            fiber.resume(res.call)
+          else
+            # TODO: raise
+          end
+        end
+
+        Nanoc::Int::NotificationCenter.post(:compilation_ended, rep)
+      end
+
+      private
+
+      contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => Fiber
+      def fiber_for(rep, is_outdated:)
+        @fibers ||= {}
+
+        @fibers[rep] ||=
+          Fiber.new do
+            @wrapped.run(rep, is_outdated: is_outdated)
+            @fibers.delete(rep)
+          end
+
+        @fibers[rep]
+      end
+    end
+
+    class WritingItemRepCompiler
+      include Nanoc::Int::ContractsSupport
+
+      def initialize(wrapped:)
+        @wrapped = wrapped
+      end
+
+      contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => C::Any
+      def run(rep, is_outdated:)
+        @wrapped.run(rep, is_outdated: is_outdated)
+
+        rep.snapshot_defs.each do |sdef|
+          if sdef.final?
+            ItemRepWriter.new.write(rep, sdef.name)
+          end
+        end
+      end
+    end
+
+    include Nanoc::Int::ContractsSupport
+
+    # @api private
+    attr_reader :site
+
+    # @api private
+    attr_reader :compiled_content_cache
+
+    # @api private
+    attr_reader :checksum_store
+
+    # @api private
+    attr_reader :rule_memory_store
+
+    # @api private
+    attr_reader :action_provider
+
+    # @api private
+    attr_reader :dependency_store
+
+    # @api private
+    attr_reader :outdatedness_checker
+
+    # @api private
+    attr_reader :reps
+
+    def initialize(site, compiled_content_cache:, checksum_store:, rule_memory_store:, action_provider:, dependency_store:, outdatedness_checker:, reps:)
+      @site = site
+
+      @compiled_content_cache = compiled_content_cache
+      @checksum_store         = checksum_store
+      @rule_memory_store      = rule_memory_store
+      @dependency_store       = dependency_store
+      @outdatedness_checker   = outdatedness_checker
+      @reps                   = reps
+      @action_provider        = action_provider
+    end
+
+    def run_all
+      @action_provider.preprocess(@site)
+      build_reps
+      prune
+      run
+      @action_provider.postprocess(@site, @reps)
+    end
+
+    def run
+      load_stores
+      @site.freeze
+
+      compile_reps
+      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
+
+    def load_stores
+      # FIXME: icky hack to update the dependency/checksum store’s list of objects
+      # (does not include preprocessed objects otherwise)
+      dependency_store.objects = site.items.to_a + site.layouts.to_a
+      checksum_store.objects = site.items.to_a + site.layouts.to_a + site.code_snippets + [site.config]
+
+      stores.each(&:load)
+    end
+
+    # Store the modified helper data used for compiling the site.
+    #
+    # @return [void]
+    def store
+      # Calculate rule memory
+      (@reps.to_a + @site.layouts.to_a).each do |obj|
+        rule_memory_store[obj] = action_provider.memory_for(obj).serialize
+      end
+
+      # Calculate checksums
+      objects_to_checksum =
+        site.items.to_a + site.layouts.to_a + site.code_snippets + [site.config]
+      objects_to_checksum.each { |obj| checksum_store.add(obj) }
+
+      # Store
+      stores.each(&:store)
+    end
+
+    def build_reps
+      builder = Nanoc::Int::ItemRepBuilder.new(
+        site, action_provider, @reps
+      )
+      builder.run
+    end
+
+    def compilation_context
+      @_compilation_context ||= CompilationContext.new(
+        action_provider: action_provider,
+        reps: @reps,
+        site: @site,
+        compiled_content_cache: compiled_content_cache,
+      )
+    end
+
+    private
+
+    def prune
+      if site.config[:prune][:auto_prune]
+        Nanoc::Pruner.new(site.config, reps, exclude: prune_config_exclude).run
+      end
+    end
+
+    def prune_config
+      site.config[:prune] || {}
+    end
+
+    def prune_config_exclude
+      prune_config[:exclude] || {}
+    end
+
+    def compile_reps
+      outdated_items = @reps.select { |r| outdatedness_checker.outdated?(r) }.map(&:item).uniq
+      outdated_items.each { |i| @dependency_store.forget_dependencies_for(i) }
+
+      reps_to_recompile = Set.new(outdated_items.flat_map { |i| @reps[i] })
+      selector = Nanoc::Int::ItemRepSelector.new(reps_to_recompile)
+      selector.each do |rep|
+        handle_errors_while(rep) { compile_rep(rep, is_outdated: reps_to_recompile.include?(rep)) }
+      end
+    end
+
+    def handle_errors_while(item_rep)
+      yield
+    rescue => e
+      raise Nanoc::Int::Errors::CompilationError.new(e, item_rep)
+    end
+
+    def compile_rep(rep, is_outdated:)
+      item_rep_compiler.run(rep, is_outdated: is_outdated)
+    end
+
+    def item_rep_compiler
+      @_item_rep_compiler ||= begin
+        recalculating_item_rep_compiler = RecalculatingItemRepCompiler.new(
+          action_provider: action_provider,
+          dependency_store: @dependency_store,
+          compilation_context: compilation_context,
+        )
+
+        caching_item_rep_compiler = CachingItemRepCompiler.new(
+          compiled_content_cache: compiled_content_cache,
+          wrapped: recalculating_item_rep_compiler,
+        )
+
+        resumable_item_rep_compiler = ResumableItemRepCompiler.new(
+          wrapped: caching_item_rep_compiler,
+        )
+
+        WritingItemRepCompiler.new(
+          wrapped: resumable_item_rep_compiler,
+        )
+      end
+    end
+
+    # Returns all stores that can load/store data that can be used for
+    # compilation.
+    def stores
+      [
+        checksum_store,
+        compiled_content_cache,
+        @dependency_store,
+        rule_memory_store,
+      ]
+    end
+  end
+end