nanoc-core 4.11.12 → 4.11.17

data/lib/nanoc/core/compilation_item_view.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class CompilationItemView < ::Nanoc::Core::BasicItemView
+      # Returns the compiled content.
+      #
+      # @param [String] rep The name of the representation
+      #   from which the compiled content should be fetched. By default, the
+      #   compiled content will be fetched from the default representation.
+      #
+      # @param [String] snapshot The name of the snapshot from which to
+      #   fetch the compiled content. By default, the returned compiled content
+      #   will be the content compiled right before the first layout call (if
+      #   any).
+      #
+      # @return [String] The content of the given rep at the given snapshot.
+      def compiled_content(rep: :default, snapshot: nil)
+        reps.fetch(rep).compiled_content(snapshot: snapshot)
+      end
+
+      # Returns the item path, as used when being linked to. It starts
+      # with a slash and it is relative to the output directory. It does not
+      # include the path to the output directory. It will not include the
+      # filename if the filename is an index filename.
+      #
+      # @param [String] rep The name of the representation
+      #   from which the path should be fetched. By default, the path will be
+      #   fetched from the default representation.
+      #
+      # @param [Symbol] snapshot The snapshot for which the
+      #   path should be returned.
+      #
+      # @return [String] The item’s path.
+      def path(rep: :default, snapshot: :last)
+        reps.fetch(rep).path(snapshot: snapshot)
+      end
+
+      # Returns the representations of this item.
+      #
+      # @return [Nanoc::Core::BasicItemRepCollectionView]
+      def reps
+        Nanoc::Core::CompilationItemRepCollectionView.new(@context.reps[_unwrap], @context)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CompilationPhases
+      class Abstract
+        include Nanoc::Core::ContractsSupport
+
+        def initialize(wrapped:)
+          @wrapped = wrapped
+        end
+
+        def start
+          @wrapped&.start
+        end
+
+        def stop
+          @wrapped&.stop
+        end
+
+        def call(rep, is_outdated:)
+          notify(:phase_started, rep)
+          run(rep, is_outdated: is_outdated) do
+            notify(:phase_yielded, rep)
+            @wrapped.call(rep, is_outdated: is_outdated)
+            notify(:phase_resumed, rep)
+          end
+          notify(:phase_ended, rep)
+        rescue
+          notify(:phase_aborted, rep)
+          raise
+        end
+
+        contract Nanoc::Core::ItemRep, C::KeywordArgs[is_outdated: C::Bool], C::Func[C::None => C::Any] => C::Any
+        def run(_rep, is_outdated:)
+          raise NotImplementedError
+        end
+
+        private
+
+        def notify(sym, rep)
+          name = self.class.to_s.sub(/^.*::/, '')
+          Nanoc::Core::NotificationCenter.post(sym, name, rep)
+        end
+      end
+    end
+  end
+end

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
+              # 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