nanoc-core 4.11.12 → 4.11.17

data/lib/nanoc/core/compilation_stages/cleanup.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CompilationStages
+      class Cleanup < Nanoc::Core::CompilationStage
+        def initialize(output_dirs)
+          @output_dirs = output_dirs
+        end
+
+        def run
+          cleanup_temps(Nanoc::Core::Filter::TMP_BINARY_ITEMS_DIR)
+          cleanup_temps(Nanoc::Core::ItemRepWriter::TMP_TEXT_ITEMS_DIR)
+          cleanup_unused_stores
+          cleanup_old_stores
+        end
+
+        private
+
+        def cleanup_temps(dir)
+          Nanoc::Core::TempFilenameFactory.instance.cleanup(dir)
+        end
+
+        def cleanup_unused_stores
+          used_paths = @output_dirs.map { |d| Nanoc::Core::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)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/compilation_stages/compile_reps.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CompilationStages
+      class CompileReps < Nanoc::Core::CompilationStage
+        include Nanoc::Core::ContractsSupport
+        include Nanoc::Core::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 run
+          outdated_reps = @reps.select { |r| @outdatedness_store.include?(r) }
+          selector = Nanoc::Core::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::Core::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
+
+        def handle_errors_while(item_rep)
+          yield
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          raise Nanoc::Core::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 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::Core::CompilationPhases::Recalculate.new(
+            action_sequences: @action_sequences,
+            dependency_store: @dependency_store,
+            compilation_context: @compilation_context,
+          )
+
+          cache_phase = Nanoc::Core::CompilationPhases::Cache.new(
+            compiled_content_cache: @compiled_content_cache,
+            compiled_content_store: @compilation_context.compiled_content_store,
+            wrapped: recalculate_phase,
+          )
+
+          resume_phase = Nanoc::Core::CompilationPhases::Resume.new(
+            wrapped: cache_phase,
+          )
+
+          write_phase = Nanoc::Core::CompilationPhases::Write.new(
+            compiled_content_store: @compilation_context.compiled_content_store,
+            wrapped: resume_phase,
+          )
+
+          mark_done_phase = Nanoc::Core::CompilationPhases::MarkDone.new(
+            wrapped: write_phase,
+            outdatedness_store: @outdatedness_store,
+          )
+
+          notify_phrase = Nanoc::Core::CompilationPhases::Notify.new(
+            wrapped: mark_done_phase,
+          )
+
+          notify_phrase
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/compilation_stages/determine_outdatedness.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CompilationStages
+      class DetermineOutdatedness < Nanoc::Core::CompilationStage
+        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

data/lib/nanoc/core/compilation_stages/forget_outdated_dependencies.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CompilationStages
+      class ForgetOutdatedDependencies < Nanoc::Core::CompilationStage
+        include Nanoc::Core::ContractsSupport
+
+        def initialize(dependency_store:)
+          @dependency_store = dependency_store
+        end
+
+        contract C::IterOf[Nanoc::Core::Item] => C::Any
+        def run(outdated_items)
+          outdated_items.each { |i| @dependency_store.forget_dependencies_for(i) }
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/compilation_stages/load_stores.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CompilationStages
+      class LoadStores < Nanoc::Core::CompilationStage
+        include Nanoc::Core::ContractsSupport
+
+        def initialize(checksum_store:, compiled_content_cache:, dependency_store:, action_sequence_store:, outdatedness_store:)
+          @checksum_store = checksum_store
+          @compiled_content_cache = compiled_content_cache
+          @dependency_store = dependency_store
+          @action_sequence_store = action_sequence_store
+          @outdatedness_store = outdatedness_store
+        end
+
+        contract C::None => C::Any
+        def run
+          load_store(@checksum_store)
+          load_store(@compiled_content_cache)
+          load_store(@dependency_store)
+          load_store(@action_sequence_store)
+          load_store(@outdatedness_store)
+        end
+
+        contract Nanoc::Core::Store => C::Any
+        def load_store(store)
+          Nanoc::Core::Instrumentor.call(:store_loaded, store.class) do
+            store.load
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/compilation_stages/postprocess.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CompilationStages
+      class Postprocess < Nanoc::Core::CompilationStage
+        include Nanoc::Core::ContractsSupport
+
+        def initialize(action_provider:, site:)
+          @action_provider = action_provider
+          @site = site
+        end
+
+        contract Nanoc::Core::Compiler => C::Any
+        def run(compiler)
+          @action_provider.postprocess(@site, compiler)
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/compilation_stages/preprocess.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CompilationStages
+      class Preprocess < Nanoc::Core::CompilationStage
+        def initialize(action_provider:, site:, dependency_store:, checksum_store:)
+          @action_provider = action_provider
+          @site = site
+          @dependency_store = dependency_store
+          @checksum_store = checksum_store
+        end
+
+        def run
+          return if @site.preprocessed?
+
+          if @action_provider.need_preprocessing?
+            @site.data_source = Nanoc::Core::InMemoryDataSource.new(@site.items, @site.layouts, @site.data_source)
+            @action_provider.preprocess(@site)
+
+            @dependency_store.items = @site.items
+            @dependency_store.layouts = @site.layouts
+            @checksum_store.objects = @site.items.to_a + @site.layouts.to_a + @site.code_snippets + [@site.config]
+          end
+
+          @site.mark_as_preprocessed
+          @site.freeze
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/compilation_stages/prune.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CompilationStages
+      class Prune < Nanoc::Core::CompilationStage
+        def initialize(config:, reps:)
+          @config = config
+          @reps = reps
+        end
+
+        def run
+          if @config[:prune][:auto_prune]
+            Nanoc::Core::Pruner.new(@config, @reps, exclude: prune_config_exclude).run
+          end
+        end
+
+        private
+
+        def prune_config
+          @config[:prune] || {}
+        end
+
+        def prune_config_exclude
+          prune_config[:exclude] || {}
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/compilation_stages/store_post_compilation_state.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CompilationStages
+      class StorePostCompilationState < Nanoc::Core::CompilationStage
+        include Nanoc::Core::ContractsSupport
+
+        def initialize(dependency_store:)
+          @dependency_store = dependency_store
+        end
+
+        contract C::None => C::Any
+        def run
+          @dependency_store.store
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/compilation_stages/store_pre_compilation_state.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CompilationStages
+      class StorePreCompilationState < Nanoc::Core::CompilationStage
+        include Nanoc::Core::ContractsSupport
+
+        def initialize(reps:, layouts:, checksum_store:, action_sequence_store:, action_sequences:)
+          @reps = reps
+          @layouts = layouts
+          @checksum_store = checksum_store
+          @action_sequence_store = action_sequence_store
+          @action_sequences = action_sequences
+        end
+
+        contract Nanoc::Core::ChecksumCollection => C::Any
+        def run(checksums)
+          # Calculate action sequence
+          (@reps.to_a + @layouts.to_a).each do |obj|
+            @action_sequence_store[obj] = @action_sequences[obj].serialize
+          end
+          @action_sequence_store.store
+
+          # Set checksums
+          @checksum_store.checksums = checksums.to_h
+          @checksum_store.store
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/compiled_content_cache.rb

@@ -46,8 +46,8 @@ module Nanoc
         @binary_cache[rep] = content.select { |_key, c| c.binary? }
       end
 
-      def prune(*args)
-        @wrapped_caches.each { |w| w.prune(*args) }
+      def prune(items:)
+        @wrapped_caches.each { |w| w.prune(items: items) }
       end
 
       # True if there is cached compiled content available for this item, and

data/lib/nanoc/core/compiler.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class Compiler
+      include Nanoc::Core::ContractsSupport
+
+      def initialize(site, compiled_content_cache:, checksum_store:, action_sequence_store:, action_provider:, dependency_store:, outdatedness_store:)
+        @site = site
+
+        # Needed because configuration is mutable :(
+        @output_dirs = @site.config.output_dirs
+
+        @compiled_content_cache = compiled_content_cache
+        @checksum_store         = checksum_store
+        @action_sequence_store  = action_sequence_store
+        @dependency_store       = dependency_store
+        @action_provider        = action_provider
+        @outdatedness_store     = outdatedness_store
+
+        @compiled_content_store = Nanoc::Core::CompiledContentStore.new
+      end
+
+      contract Nanoc::Core::Site => C::Any
+      def self.compile(site)
+        new_for(site).run_until_end
+      end
+
+      contract Nanoc::Core::Site => Nanoc::Core::Compiler
+      def self.new_for(site)
+        Nanoc::Core::CompilerLoader.new.load(site)
+      end
+
+      def run_until_preprocessed
+        @_res_preprocessed ||= begin
+          preprocess_stage.call
+          {}
+        end
+      end
+
+      def run_until_reps_built
+        @_res_reps_built ||= begin
+          prev = run_until_preprocessed
+
+          res = build_reps_stage.call
+
+          prev.merge(
+            reps: res.fetch(:reps),
+            action_sequences: res.fetch(:action_sequences),
+          )
+        end
+      end
+
+      def run_until_precompiled
+        @_res_precompiled ||= begin
+          prev = run_until_reps_built
+          action_sequences = prev.fetch(:action_sequences)
+          reps = prev.fetch(:reps)
+
+          load_stores_stage.call
+          checksums = calculate_checksums_stage.call
+          outdatedness_checker = create_outdatedness_checker(
+            checksums: checksums,
+            action_sequences: action_sequences,
+            reps: reps,
+          )
+          outdated_items = determine_outdatedness_stage(outdatedness_checker, reps).call
+
+          prev.merge(
+            checksums: checksums,
+            dependency_store: @dependency_store,
+            outdatedness_checker: outdatedness_checker,
+            outdated_items: outdated_items,
+          )
+        end
+      end
+
+      def run_until_end
+        res = run_until_precompiled
+        action_sequences = res.fetch(:action_sequences)
+        reps = res.fetch(:reps)
+        checksums = res.fetch(:checksums)
+        outdated_items = res.fetch(:outdated_items)
+
+        forget_outdated_dependencies_stage.call(outdated_items)
+        store_pre_compilation_state_stage(action_sequences, reps).call(checksums)
+        prune_stage(reps).call
+        compile_reps_stage(action_sequences, reps).call
+        store_post_compilation_state_stage.call
+        postprocess_stage.call(self)
+      ensure
+        cleanup_stage.call
+      end
+
+      def compilation_context(reps:)
+        Nanoc::Core::CompilationContext.new(
+          action_provider: @action_provider,
+          reps: reps,
+          site: @site,
+          compiled_content_cache: @compiled_content_cache,
+          compiled_content_store: @compiled_content_store,
+        )
+      end
+
+      private
+
+      def create_outdatedness_checker(checksums:, action_sequences:, reps:)
+        Nanoc::Core::OutdatednessChecker.new(
+          site: @site,
+          checksum_store: @checksum_store,
+          dependency_store: @dependency_store,
+          action_sequence_store: @action_sequence_store,
+          action_sequences: action_sequences,
+          checksums: checksums,
+          reps: reps,
+        )
+      end
+
+      def preprocess_stage
+        @_preprocess_stage ||= ::Nanoc::Core::CompilationStages::Preprocess.new(
+          action_provider: @action_provider,
+          site: @site,
+          dependency_store: @dependency_store,
+          checksum_store: @checksum_store,
+        )
+      end
+
+      def build_reps_stage
+        @_build_reps_stage ||= ::Nanoc::Core::CompilationStages::BuildReps.new(
+          site: @site,
+          action_provider: @action_provider,
+        )
+      end
+
+      def prune_stage(reps)
+        @_prune_stage ||= ::Nanoc::Core::CompilationStages::Prune.new(
+          config: @site.config,
+          reps: reps,
+        )
+      end
+
+      def load_stores_stage
+        @_load_stores_stage ||= ::Nanoc::Core::CompilationStages::LoadStores.new(
+          checksum_store: @checksum_store,
+          compiled_content_cache: @compiled_content_cache,
+          dependency_store: @dependency_store,
+          action_sequence_store: @action_sequence_store,
+          outdatedness_store: @outdatedness_store,
+        )
+      end
+
+      def calculate_checksums_stage
+        @_calculate_checksums_stage ||= ::Nanoc::Core::CompilationStages::CalculateChecksums.new(
+          items: @site.items,
+          layouts: @site.layouts,
+          code_snippets: @site.code_snippets,
+          config: @site.config,
+        )
+      end
+
+      def determine_outdatedness_stage(outdatedness_checker, reps)
+        @_determine_outdatedness_stage ||= ::Nanoc::Core::CompilationStages::DetermineOutdatedness.new(
+          reps: reps,
+          outdatedness_checker: outdatedness_checker,
+          outdatedness_store: @outdatedness_store,
+        )
+      end
+
+      def store_pre_compilation_state_stage(action_sequences, reps)
+        @_store_pre_compilation_state_stage ||= ::Nanoc::Core::CompilationStages::StorePreCompilationState.new(
+          reps: reps,
+          layouts: @site.layouts,
+          checksum_store: @checksum_store,
+          action_sequence_store: @action_sequence_store,
+          action_sequences: action_sequences,
+        )
+      end
+
+      def compile_reps_stage(action_sequences, reps)
+        @_compile_reps_stage ||= ::Nanoc::Core::CompilationStages::CompileReps.new(
+          reps: reps,
+          outdatedness_store: @outdatedness_store,
+          dependency_store: @dependency_store,
+          action_sequences: action_sequences,
+          compilation_context: compilation_context(reps: reps),
+          compiled_content_cache: @compiled_content_cache,
+        )
+      end
+
+      def store_post_compilation_state_stage
+        @_store_post_compilation_state_stage ||= ::Nanoc::Core::CompilationStages::StorePostCompilationState.new(
+          dependency_store: @dependency_store,
+        )
+      end
+
+      def postprocess_stage
+        @_postprocess_stage ||= ::Nanoc::Core::CompilationStages::Postprocess.new(
+          action_provider: @action_provider,
+          site: @site,
+        )
+      end
+
+      def cleanup_stage
+        @_cleanup_stage ||= ::Nanoc::Core::CompilationStages::Cleanup.new(@output_dirs)
+      end
+
+      def forget_outdated_dependencies_stage
+        @_forget_outdated_dependencies_stage ||= ::Nanoc::Core::CompilationStages::ForgetOutdatedDependencies.new(
+          dependency_store: @dependency_store,
+        )
+      end
+    end
+  end
+end