nanoc-core 4.11.12 → 4.11.13

data/lib/nanoc/core/compilation_phases/cache.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CompilationPhases
+      # Provides functionality for (re)calculating the content of an item rep, with caching or
+      # outdatedness checking. Delegates to s::Recalculate if outdated or no cache available.
+      class Cache < Abstract
+        include Nanoc::Core::ContractsSupport
+
+        def initialize(wrapped:, compiled_content_cache:, compiled_content_store:)
+          super(wrapped: wrapped)
+
+          @compiled_content_cache = compiled_content_cache
+          @compiled_content_store = compiled_content_store
+        end
+
+        contract Nanoc::Core::ItemRep, C::KeywordArgs[is_outdated: C::Bool], C::Func[C::None => C::Any] => C::Any
+        def run(rep, is_outdated:)
+          if can_reuse_content_for_rep?(rep, is_outdated: is_outdated)
+            Nanoc::Core::NotificationCenter.post(:cached_content_used, rep)
+
+            @compiled_content_store.set_all(rep, @compiled_content_cache[rep])
+          else
+            yield
+          end
+
+          rep.compiled = true
+          @compiled_content_cache[rep] = @compiled_content_store.get_all(rep)
+        end
+
+        contract Nanoc::Core::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => C::Bool
+        def can_reuse_content_for_rep?(rep, is_outdated:)
+          if is_outdated
+            false
+          else
+            @compiled_content_cache.full_cache_available?(rep)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/compilation_phases/mark_done.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CompilationPhases
+      class MarkDone < Abstract
+        include Nanoc::Core::ContractsSupport
+
+        def initialize(wrapped:, outdatedness_store:)
+          super(wrapped: wrapped)
+
+          @outdatedness_store = outdatedness_store
+        end
+
+        contract Nanoc::Core::ItemRep, C::KeywordArgs[is_outdated: C::Bool], C::Func[C::None => C::Any] => C::Any
+        def run(rep, is_outdated:) # rubocop:disable Lint/UnusedMethodArgument
+          yield
+          @outdatedness_store.remove(rep)
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/compilation_phases/notify.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CompilationPhases
+      # Provides functionality for notifying start and end of compilation.
+      class Notify < Abstract
+        include Nanoc::Core::ContractsSupport
+
+        contract Nanoc::Core::ItemRep, C::KeywordArgs[is_outdated: C::Bool], C::Func[C::None => C::Any] => C::Any
+        def run(rep, is_outdated:) # rubocop:disable Lint/UnusedMethodArgument
+          Nanoc::Core::NotificationCenter.post(:compilation_started, rep)
+          yield
+          Nanoc::Core::NotificationCenter.post(:compilation_ended, rep)
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/compilation_phases/recalculate.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CompilationPhases
+      # Provides functionality for (re)calculating the content of an item rep, without caching or
+      # outdatedness checking.
+      class Recalculate < Abstract
+        include Nanoc::Core::ContractsSupport
+
+        def initialize(action_sequences:, dependency_store:, compilation_context:)
+          super(wrapped: nil)
+
+          @action_sequences = action_sequences
+          @dependency_store = dependency_store
+          @compilation_context = compilation_context
+        end
+
+        contract Nanoc::Core::ItemRep, C::KeywordArgs[is_outdated: C::Bool], C::Func[C::None => C::Any] => C::Any
+        def run(rep, is_outdated:) # rubocop:disable Lint/UnusedMethodArgument
+          dependency_tracker = Nanoc::Core::DependencyTracker.new(@dependency_store)
+          dependency_tracker.enter(rep.item)
+
+          executor = Nanoc::Core::Executor.new(rep, @compilation_context, dependency_tracker)
+
+          @compilation_context.compiled_content_store.set_current(rep, rep.item.content)
+
+          actions = @action_sequences[rep]
+          actions.each do |action|
+            case action
+            when Nanoc::Core::ProcessingActions::Filter
+              executor.filter(action.filter_name, action.params)
+            when Nanoc::Core::ProcessingActions::Layout
+              executor.layout(action.layout_identifier, action.params)
+            when Nanoc::Core::ProcessingActions::Snapshot
+              action.snapshot_names.each do |snapshot_name|
+                executor.snapshot(snapshot_name)
+              end
+            else
+              raise Nanoc::Core::Errors::InternalInconsistency, "unknown action #{action.inspect}"
+            end
+          end
+        ensure
+          dependency_tracker.exit
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/compilation_phases/resume.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CompilationPhases
+      # Provides functionality for suspending and resuming item rep compilation (using fibers).
+      class Resume < Abstract
+        include Nanoc::Core::ContractsSupport
+
+        DONE = Object.new
+
+        contract Nanoc::Core::ItemRep, C::KeywordArgs[is_outdated: C::Bool], C::Func[C::None => C::Any] => C::Any
+        def run(rep, is_outdated:)
+          fiber = fiber_for(rep, is_outdated: is_outdated) { yield }
+          while fiber.alive?
+            res = fiber.resume
+
+            case res
+            when Nanoc::Core::Errors::UnmetDependency
+              Nanoc::Core::NotificationCenter.post(:compilation_suspended, rep, res.rep, res.snapshot_name)
+              raise(res)
+            when Proc
+              fiber.resume(res.call)
+            when DONE # rubocop:disable Lint/EmptyWhen
+              # ignore
+            else
+              raise Nanoc::Core::Errors::InternalInconsistency.new(
+                "Fiber yielded object of unexpected type #{res.class}",
+              )
+            end
+          end
+        end
+
+        private
+
+        contract Nanoc::Core::ItemRep, C::KeywordArgs[is_outdated: C::Bool], C::Func[C::None => C::Any] => Fiber
+        def fiber_for(rep, is_outdated:) # rubocop:disable Lint/UnusedMethodArgument
+          @fibers ||= {}
+
+          @fibers[rep] ||=
+            Fiber.new do
+              yield
+              @fibers.delete(rep)
+              DONE
+            end
+
+          @fibers[rep]
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/compilation_phases/write.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CompilationPhases
+      class Write < Abstract
+        include Nanoc::Core::ContractsSupport
+
+        class Worker
+          def initialize(queue:, compiled_content_store:)
+            @queue = queue
+            @compiled_content_store = compiled_content_store
+          end
+
+          def start
+            @thread = Thread.new do
+              Thread.current.abort_on_exception = true
+              Thread.current.priority = -1 # schedule I/O work ASAP
+
+              writer = Nanoc::Core::ItemRepWriter.new
+
+              while rep = @queue.pop # rubocop:disable Lint/AssignmentInCondition
+                writer.write_all(rep, @compiled_content_store)
+              end
+            end
+          end
+
+          def join
+            @thread.join
+          end
+        end
+
+        class WorkerPool
+          def initialize(queue:, size:, compiled_content_store:)
+            @workers = Array.new(size) { Worker.new(queue: queue, compiled_content_store: compiled_content_store) }
+          end
+
+          def start
+            @workers.each(&:start)
+          end
+
+          def join
+            @workers.each(&:join)
+          end
+        end
+
+        QUEUE_SIZE = 40
+        WORKER_POOL_SIZE = 5
+
+        def initialize(compiled_content_store:, wrapped:)
+          super(wrapped: wrapped)
+
+          @compiled_content_store = compiled_content_store
+
+          @queue = SizedQueue.new(QUEUE_SIZE)
+          @worker_pool = WorkerPool.new(queue: @queue, size: WORKER_POOL_SIZE, compiled_content_store: @compiled_content_store)
+        end
+
+        def start
+          super
+          @worker_pool.start
+        end
+
+        def stop
+          super
+          @queue.close
+          @worker_pool.join
+        end
+
+        contract Nanoc::Core::ItemRep, C::KeywordArgs[is_outdated: C::Bool], C::Func[C::None => C::Any] => C::Any
+        def run(rep, is_outdated:) # rubocop:disable Lint/UnusedMethodArgument
+          yield
+
+          # Caution: Notification must be posted before enqueueing the rep,
+          # or we risk a race condition where the :rep_write_ended
+          # notification happens before the :rep_write_enqueued one.
+          Nanoc::Core::NotificationCenter.post(:rep_write_enqueued, rep)
+
+          @queue << rep
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CompilationStages
+      class BuildReps < Nanoc::Core::CompilationStage
+        include Nanoc::Core::ContractsSupport
+
+        contract C::KeywordArgs[site: Nanoc::Core::Site, action_provider: Nanoc::Core::ActionProvider] => C::Any
+        def initialize(site:, action_provider:)
+          @site = site
+          @action_provider = action_provider
+        end
+
+        def run
+          reps = Nanoc::Core::ItemRepRepo.new
+
+          builder = Nanoc::Core::ItemRepBuilder.new(
+            @site, @action_provider, reps
+          )
+
+          action_sequences = builder.run
+
+          @site.layouts.each do |layout|
+            action_sequences[layout] = @action_provider.action_sequence_for(layout)
+          end
+
+          {
+            reps: reps,
+            action_sequences: action_sequences,
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CompilationStages
+      class CalculateChecksums < Nanoc::Core::CompilationStage
+        def initialize(items:, layouts:, code_snippets:, config:)
+          @items = items
+          @layouts = layouts
+          @code_snippets = code_snippets
+          @config = config
+        end
+
+        def run
+          checksums = {}
+
+          [@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::Core::Checksummer.calc(obj)
+            end
+          end
+
+          checksums[@config.reference] =
+            Nanoc::Core::Checksummer.calc(@config)
+          checksums[[@config.reference, :each_attribute]] =
+            Nanoc::Core::Checksummer.calc_for_each_attribute_of(@config)
+
+          Nanoc::Core::ChecksumCollection.new(checksums)
+        end
+      end
+    end
+  end
+end

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