nanoc 4.11.0 → 4.11.1

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

@@ -1,13 +1,32 @@
 # frozen_string_literal: true
 
-class Nanoc::Int::Compiler::Stage
-  def call(*args)
-    Nanoc::Int::Instrumentor.call(:stage_ran, self.class) do
-      run(*args)
-    end
-  end
+module Nanoc
+  module Int
+    class Compiler
+      class Stage
+        def call(*args)
+          notify(:stage_started)
+          res = Nanoc::Int::Instrumentor.call(:stage_ran, self.class) do
+            run(*args)
+          end
+          notify(:stage_ended)
+          res
+        rescue
+          notify(:stage_aborted)
+          raise
+        end
+
+        def run(*)
+          raise NotImplementedError
+        end
 
-  def run(*)
-    raise NotImplementedError
+        private
+
+        def notify(sym)
+          name = self.class.to_s.sub(/^.*::/, '')
+          Nanoc::Core::NotificationCenter.post(sym, name)
+        end
+      end
+    end
   end
 end

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

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 
-module Nanoc::Int::Compiler::Stages
+module Nanoc
+  module Int
+    class Compiler
+      module Stages
+      end
+    end
+  end
 end
 
 require_relative 'stage'

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

@@ -1,29 +1,35 @@
 # frozen_string_literal: true
 
-module Nanoc::Int::Compiler::Stages
-  class BuildReps < Nanoc::Int::Compiler::Stage
-    def initialize(site:, action_provider:)
-      @site = site
-      @action_provider = action_provider
-    end
+module Nanoc
+  module Int
+    class Compiler
+      module Stages
+        class BuildReps < Nanoc::Int::Compiler::Stage
+          def initialize(site:, action_provider:)
+            @site = site
+            @action_provider = action_provider
+          end
 
-    def run
-      reps = Nanoc::Int::ItemRepRepo.new
+          def run
+            reps = Nanoc::Int::ItemRepRepo.new
 
-      builder = Nanoc::Int::ItemRepBuilder.new(
-        @site, @action_provider, reps
-      )
+            builder = Nanoc::Int::ItemRepBuilder.new(
+              @site, @action_provider, reps
+            )
 
-      action_sequences = builder.run
+            action_sequences = builder.run
 
-      @site.layouts.each do |layout|
-        action_sequences[layout] = @action_provider.action_sequence_for(layout)
-      end
+            @site.layouts.each do |layout|
+              action_sequences[layout] = @action_provider.action_sequence_for(layout)
+            end
 
-      {
-        reps: reps,
-        action_sequences: action_sequences,
-      }
+            {
+              reps: reps,
+              action_sequences: action_sequences,
+            }
+          end
+        end
+      end
     end
   end
 end

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

@@ -1,38 +1,44 @@
 # frozen_string_literal: true
 
-module Nanoc::Int::Compiler::Stages
-  class CalculateChecksums < Nanoc::Int::Compiler::Stage
-    def initialize(items:, layouts:, code_snippets:, config:)
-      @items = items
-      @layouts = layouts
-      @code_snippets = code_snippets
-      @config = config
-    end
+module Nanoc
+  module Int
+    class Compiler
+      module Stages
+        class CalculateChecksums < Nanoc::Int::Compiler::Stage
+          def initialize(items:, layouts:, code_snippets:, config:)
+            @items = items
+            @layouts = layouts
+            @code_snippets = code_snippets
+            @config = config
+          end
 
-    def run
-      checksums = {}
+          def run
+            checksums = {}
 
-      [@items, @layouts].each do |documents|
-        documents.each do |document|
-          checksums[[document.reference, :content]] =
-            Nanoc::Int::Checksummer.calc_for_content_of(document)
-          checksums[[document.reference, :each_attribute]] =
-            Nanoc::Int::Checksummer.calc_for_each_attribute_of(document)
-        end
-      end
+            [@items, @layouts].each do |documents|
+              documents.each do |document|
+                checksums[[document.reference, :content]] =
+                  Nanoc::Core::Checksummer.calc_for_content_of(document)
+                checksums[[document.reference, :each_attribute]] =
+                  Nanoc::Core::Checksummer.calc_for_each_attribute_of(document)
+              end
+            end
 
-      [@items, @layouts, @code_snippets].each do |objs|
-        objs.each do |obj|
-          checksums[obj.reference] = Nanoc::Int::Checksummer.calc(obj)
-        end
-      end
+            [@items, @layouts, @code_snippets].each do |objs|
+              objs.each do |obj|
+                checksums[obj.reference] = Nanoc::Core::Checksummer.calc(obj)
+              end
+            end
 
-      checksums[@config.reference] =
-        Nanoc::Int::Checksummer.calc(@config)
-      checksums[[@config.reference, :each_attribute]] =
-        Nanoc::Int::Checksummer.calc_for_each_attribute_of(@config)
+            checksums[@config.reference] =
+              Nanoc::Core::Checksummer.calc(@config)
+            checksums[[@config.reference, :each_attribute]] =
+              Nanoc::Core::Checksummer.calc_for_each_attribute_of(@config)
 
-      Nanoc::Int::ChecksumCollection.new(checksums)
+            Nanoc::Int::ChecksumCollection.new(checksums)
+          end
+        end
+      end
     end
   end
 end

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

@@ -1,37 +1,43 @@
 # frozen_string_literal: true
 
-module Nanoc::Int::Compiler::Stages
-  class Cleanup < Nanoc::Int::Compiler::Stage
-    def initialize(output_dirs)
-      @output_dirs = output_dirs
-    end
+module Nanoc
+  module Int
+    class Compiler
+      module Stages
+        class Cleanup < Nanoc::Int::Compiler::Stage
+          def initialize(output_dirs)
+            @output_dirs = output_dirs
+          end
 
-    def run
-      cleanup_temps(Nanoc::Filter::TMP_BINARY_ITEMS_DIR)
-      cleanup_temps(Nanoc::Int::ItemRepWriter::TMP_TEXT_ITEMS_DIR)
-      cleanup_unused_stores
-      cleanup_old_stores
-    end
+          def run
+            cleanup_temps(Nanoc::Filter::TMP_BINARY_ITEMS_DIR)
+            cleanup_temps(Nanoc::Int::ItemRepWriter::TMP_TEXT_ITEMS_DIR)
+            cleanup_unused_stores
+            cleanup_old_stores
+          end
 
-    private
+          private
 
-    def cleanup_temps(dir)
-      Nanoc::Int::TempFilenameFactory.instance.cleanup(dir)
-    end
+          def cleanup_temps(dir)
+            Nanoc::Core::TempFilenameFactory.instance.cleanup(dir)
+          end
 
-    def cleanup_unused_stores
-      used_paths = @output_dirs.map { |d| Nanoc::Int::Store.tmp_path_prefix(d) }
-      all_paths = Dir.glob('tmp/nanoc/*')
-      (all_paths - used_paths).each do |obsolete_path|
-        FileUtils.rm_rf(obsolete_path)
-      end
-    end
+          def cleanup_unused_stores
+            used_paths = @output_dirs.map { |d| Nanoc::Int::Store.tmp_path_prefix(d) }
+            all_paths = Dir.glob('tmp/nanoc/*')
+            (all_paths - used_paths).each do |obsolete_path|
+              FileUtils.rm_rf(obsolete_path)
+            end
+          end
 
-    def cleanup_old_stores
-      %w[checksums compiled_content dependencies outdatedness action_sequence].each do |fn|
-        full_fn = File.join('tmp', fn)
-        if File.file?(full_fn)
-          FileUtils.rm_f(full_fn)
+          def cleanup_old_stores
+            %w[checksums compiled_content dependencies outdatedness action_sequence].each do |fn|
+              full_fn = File.join('tmp', fn)
+              if File.file?(full_fn)
+                FileUtils.rm_f(full_fn)
+              end
+            end
+          end
         end
       end
     end

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

@@ -1,88 +1,98 @@
 # frozen_string_literal: true
 
-module Nanoc::Int::Compiler::Stages
-  class CompileReps < Nanoc::Int::Compiler::Stage
-    include Nanoc::Int::ContractsSupport
-    include Nanoc::Assertions::Mixin
+module Nanoc
+  module Int
+    class Compiler
+      module Stages
+        class CompileReps < Nanoc::Int::Compiler::Stage
+          include Nanoc::Core::ContractsSupport
+          include Nanoc::Assertions::Mixin
 
-    def initialize(reps:, outdatedness_store:, dependency_store:, action_sequences:, compilation_context:, compiled_content_cache:)
-      @reps = reps
-      @outdatedness_store = outdatedness_store
-      @dependency_store = dependency_store
-      @action_sequences = action_sequences
-      @compilation_context = compilation_context
-      @compiled_content_cache = compiled_content_cache
-    end
+          def initialize(reps:, outdatedness_store:, dependency_store:, action_sequences:, compilation_context:, compiled_content_cache:)
+            @reps = reps
+            @outdatedness_store = outdatedness_store
+            @dependency_store = dependency_store
+            @action_sequences = action_sequences
+            @compilation_context = compilation_context
+            @compiled_content_cache = compiled_content_cache
+          end
 
-    def run
-      outdated_reps = @reps.select { |r| @outdatedness_store.include?(r) }
-      selector = Nanoc::Int::ItemRepSelector.new(outdated_reps)
-      run_phase_stack do |phase_stack|
-        selector.each do |rep|
-          handle_errors_while(rep) do
-            compile_rep(rep, phase_stack: phase_stack, is_outdated: @outdatedness_store.include?(rep))
+          def run
+            outdated_reps = @reps.select { |r| @outdatedness_store.include?(r) }
+            selector = Nanoc::Int::ItemRepSelector.new(outdated_reps)
+            run_phase_stack do |phase_stack|
+              selector.each do |rep|
+                handle_errors_while(rep) do
+                  compile_rep(rep, phase_stack: phase_stack, is_outdated: @outdatedness_store.include?(rep))
+                end
+              end
+            end
+
+            assert Nanoc::Assertions::AllItemRepsHaveCompiledContent.new(
+              compiled_content_cache: @compiled_content_cache,
+              item_reps: @reps,
+            )
+          ensure
+            @outdatedness_store.store
+            @compiled_content_cache.prune(items: @reps.map(&:item).uniq)
+            @compiled_content_cache.store
           end
-        end
-      end
 
-      assert Nanoc::Assertions::AllItemRepsHaveCompiledContent.new(
-        compiled_content_cache: @compiled_content_cache,
-        item_reps: @reps,
-      )
-    ensure
-      @outdatedness_store.store
-      @compiled_content_cache.prune(items: @reps.map(&:item).uniq)
-      @compiled_content_cache.store
-    end
+          private
 
-    private
+          def handle_errors_while(item_rep)
+            yield
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            raise Nanoc::Int::Errors::CompilationError.new(e, item_rep)
+          end
 
-    def handle_errors_while(item_rep)
-      yield
-    rescue Exception => e # rubocop:disable Lint/RescueException
-      raise Nanoc::Int::Errors::CompilationError.new(e, item_rep)
-    end
+          def compile_rep(rep, phase_stack:, is_outdated:)
+            phase_stack.call(rep, is_outdated: is_outdated)
+          end
 
-    def compile_rep(rep, phase_stack:, is_outdated:)
-      phase_stack.call(rep, is_outdated: is_outdated)
-    end
+          def run_phase_stack
+            phase_stack = build_phase_stack
+            phase_stack.start
+            yield(phase_stack)
+          ensure
+            phase_stack.stop
+          end
 
-    def run_phase_stack
-      phase_stack = build_phase_stack
-      phase_stack.start
-      yield(phase_stack)
-    ensure
-      phase_stack.stop
-    end
+          def build_phase_stack
+            recalculate_phase = Nanoc::Int::Compiler::Phases::Recalculate.new(
+              action_sequences: @action_sequences,
+              dependency_store: @dependency_store,
+              compilation_context: @compilation_context,
+            )
 
-    def build_phase_stack
-      recalculate_phase = Nanoc::Int::Compiler::Phases::Recalculate.new(
-        action_sequences: @action_sequences,
-        dependency_store: @dependency_store,
-        compilation_context: @compilation_context,
-      )
+            cache_phase = Nanoc::Int::Compiler::Phases::Cache.new(
+              compiled_content_cache: @compiled_content_cache,
+              compiled_content_store: @compilation_context.compiled_content_store,
+              wrapped: recalculate_phase,
+            )
 
-      cache_phase = Nanoc::Int::Compiler::Phases::Cache.new(
-        compiled_content_cache: @compiled_content_cache,
-        snapshot_repo: @compilation_context.snapshot_repo,
-        wrapped: recalculate_phase,
-      )
+            resume_phase = Nanoc::Int::Compiler::Phases::Resume.new(
+              wrapped: cache_phase,
+            )
 
-      resume_phase = Nanoc::Int::Compiler::Phases::Resume.new(
-        wrapped: cache_phase,
-      )
+            write_phase = Nanoc::Int::Compiler::Phases::Write.new(
+              compiled_content_store: @compilation_context.compiled_content_store,
+              wrapped: resume_phase,
+            )
 
-      write_phase = Nanoc::Int::Compiler::Phases::Write.new(
-        snapshot_repo: @compilation_context.snapshot_repo,
-        wrapped: resume_phase,
-      )
+            mark_done_phase = Nanoc::Int::Compiler::Phases::MarkDone.new(
+              wrapped: write_phase,
+              outdatedness_store: @outdatedness_store,
+            )
 
-      mark_done_phase = Nanoc::Int::Compiler::Phases::MarkDone.new(
-        wrapped: write_phase,
-        outdatedness_store: @outdatedness_store,
-      )
+            notify_phrase = Nanoc::Int::Compiler::Phases::Notify.new(
+              wrapped: mark_done_phase,
+            )
 
-      mark_done_phase
+            notify_phrase
+          end
+        end
+      end
     end
   end
 end

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

@@ -1,45 +1,51 @@
 # frozen_string_literal: true
 
-module Nanoc::Int::Compiler::Stages
-  class DetermineOutdatedness < Nanoc::Int::Compiler::Stage
-    include Nanoc::Int::ContractsSupport
-
-    def initialize(reps:, outdatedness_checker:, outdatedness_store:)
-      @reps = reps
-      @outdatedness_checker = outdatedness_checker
-      @outdatedness_store = outdatedness_store
-    end
-
-    contract C::None => C::Any
-    def run
-      outdated_items = select_outdated_items
-      outdated_reps = reps_of_items(outdated_items)
-
-      store_outdated_reps(outdated_reps)
-
-      outdated_items
-    end
-
-    private
-
-    def store_outdated_reps(reps)
-      @outdatedness_store.clear
-      reps.each { |r| @outdatedness_store.add(r) }
-    end
-
-    def select_outdated_items
-      @reps
-        .select { |r| outdated?(r) }
-        .map(&:item)
-        .uniq
-    end
-
-    def reps_of_items(items)
-      Set.new(items.flat_map { |i| @reps[i] })
-    end
-
-    def outdated?(rep)
-      @outdatedness_store.include?(rep) || @outdatedness_checker.outdated?(rep)
+module Nanoc
+  module Int
+    class Compiler
+      module Stages
+        class DetermineOutdatedness < Nanoc::Int::Compiler::Stage
+          include Nanoc::Core::ContractsSupport
+
+          def initialize(reps:, outdatedness_checker:, outdatedness_store:)
+            @reps = reps
+            @outdatedness_checker = outdatedness_checker
+            @outdatedness_store = outdatedness_store
+          end
+
+          contract C::None => C::Any
+          def run
+            outdated_items = select_outdated_items
+            outdated_reps = reps_of_items(outdated_items)
+
+            store_outdated_reps(outdated_reps)
+
+            outdated_items
+          end
+
+          private
+
+          def store_outdated_reps(reps)
+            @outdatedness_store.clear
+            reps.each { |r| @outdatedness_store.add(r) }
+          end
+
+          def select_outdated_items
+            @reps
+              .select { |r| outdated?(r) }
+              .map(&:item)
+              .uniq
+          end
+
+          def reps_of_items(items)
+            Set.new(items.flat_map { |i| @reps[i] })
+          end
+
+          def outdated?(rep)
+            @outdatedness_store.include?(rep) || @outdatedness_checker.outdated?(rep)
+          end
+        end
+      end
     end
   end
 end