nanoc 4.11.0 → 4.11.1

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

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 
-module Nanoc::Int::Compiler::Phases
+module Nanoc
+  module Int
+    class Compiler
+      module Phases
+      end
+    end
+  end
 end
 
 require_relative 'phases/abstract'
@@ -10,3 +16,4 @@ require_relative 'phases/cache'
 require_relative 'phases/resume'
 require_relative 'phases/write'
 require_relative 'phases/mark_done'
+require_relative 'phases/notify'

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

@@ -1,44 +1,50 @@
 # frozen_string_literal: true
 
-module Nanoc::Int::Compiler::Phases
-  class Abstract
-    include Nanoc::Int::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)
+module Nanoc
+  module Int
+    class Compiler
+      module Phases
+        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:) # rubocop:disable Lint/UnusedMethodArgument
+            raise NotImplementedError
+          end
+
+          private
+
+          def notify(sym, rep)
+            name = self.class.to_s.sub(/^.*::/, '')
+            Nanoc::Core::NotificationCenter.post(sym, name, rep)
+          end
+        end
       end
-      notify(:phase_ended, rep)
-    rescue
-      notify(:phase_aborted, rep)
-      raise
-    end
-
-    contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool], C::Func[C::None => C::Any] => C::Any
-    def run(_rep, is_outdated:) # rubocop:disable Lint/UnusedMethodArgument
-      raise NotImplementedError
-    end
-
-    private
-
-    def notify(sym, rep)
-      name = self.class.to_s.sub(/^.*::/, '')
-      Nanoc::Int::NotificationCenter.post(sym, name, rep)
     end
   end
 end

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

@@ -1,39 +1,45 @@
 # frozen_string_literal: true
 
-module Nanoc::Int::Compiler::Phases
-  # 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::Int::ContractsSupport
+module Nanoc
+  module Int
+    class Compiler
+      module Phases
+        # 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:, snapshot_repo:)
-      super(wrapped: wrapped)
+          def initialize(wrapped:, compiled_content_cache:, compiled_content_store:)
+            super(wrapped: wrapped)
 
-      @compiled_content_cache = compiled_content_cache
-      @snapshot_repo = snapshot_repo
-    end
+            @compiled_content_cache = compiled_content_cache
+            @compiled_content_store = compiled_content_store
+          end
 
-    contract Nanoc::Int::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::Int::NotificationCenter.post(:cached_content_used, rep)
+          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)
 
-        @snapshot_repo.set_all(rep, @compiled_content_cache[rep])
-      else
-        yield
-      end
+              @compiled_content_store.set_all(rep, @compiled_content_cache[rep])
+            else
+              yield
+            end
 
-      rep.compiled = true
-      @compiled_content_cache[rep] = @snapshot_repo.get_all(rep)
-    end
+            rep.compiled = true
+            @compiled_content_cache[rep] = @compiled_content_store.get_all(rep)
+          end
 
-    contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => C::Bool
-    def can_reuse_content_for_rep?(rep, is_outdated:)
-      if is_outdated
-        false
-      else
-        cache = @compiled_content_cache[rep]
-        cache ? cache.none? { |_snapshot_name, content| content.binary? } : false
+          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
+              cache = @compiled_content_cache[rep]
+              cache ? cache.none? { |_snapshot_name, content| content.binary? } : false
+            end
+          end
+        end
       end
     end
   end

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

@@ -1,19 +1,25 @@
 # frozen_string_literal: true
 
-module Nanoc::Int::Compiler::Phases
-  class MarkDone < Abstract
-    include Nanoc::Int::ContractsSupport
+module Nanoc
+  module Int
+    class Compiler
+      module Phases
+        class MarkDone < Abstract
+          include Nanoc::Core::ContractsSupport
 
-    def initialize(wrapped:, outdatedness_store:)
-      super(wrapped: wrapped)
+          def initialize(wrapped:, outdatedness_store:)
+            super(wrapped: wrapped)
 
-      @outdatedness_store = outdatedness_store
-    end
+            @outdatedness_store = outdatedness_store
+          end
 
-    contract Nanoc::Int::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)
+          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
 end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Int
+    class Compiler
+      module Phases
+        # 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
+end

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

@@ -1,45 +1,51 @@
 # frozen_string_literal: true
 
-module Nanoc::Int::Compiler::Phases
-  # Provides functionality for (re)calculating the content of an item rep, without caching or
-  # outdatedness checking.
-  class Recalculate < Abstract
-    include Nanoc::Int::ContractsSupport
+module Nanoc
+  module Int
+    class Compiler
+      module Phases
+        # 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)
+          def initialize(action_sequences:, dependency_store:, compilation_context:)
+            super(wrapped: nil)
 
-      @action_sequences = action_sequences
-      @dependency_store = dependency_store
-      @compilation_context = compilation_context
-    end
+            @action_sequences = action_sequences
+            @dependency_store = dependency_store
+            @compilation_context = compilation_context
+          end
 
-    contract Nanoc::Int::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::Int::DependencyTracker.new(@dependency_store)
-      dependency_tracker.enter(rep.item)
+          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::Int::DependencyTracker.new(@dependency_store)
+            dependency_tracker.enter(rep.item)
 
-      executor = Nanoc::Int::Executor.new(rep, @compilation_context, dependency_tracker)
+            executor = Nanoc::Int::Executor.new(rep, @compilation_context, dependency_tracker)
 
-      @compilation_context.snapshot_repo.set(rep, :last, rep.item.content)
+            @compilation_context.compiled_content_store.set_current(rep, rep.item.content)
 
-      actions = @action_sequences[rep]
-      actions.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
-          action.snapshot_names.each do |snapshot_name|
-            executor.snapshot(snapshot_name)
+            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::Int::Errors::InternalInconsistency, "unknown action #{action.inspect}"
+              end
+            end
+          ensure
+            dependency_tracker.exit
           end
-        else
-          raise Nanoc::Int::Errors::InternalInconsistency, "unknown action #{action.inspect}"
         end
       end
-    ensure
-      dependency_tracker.exit
     end
   end
 end

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

@@ -1,55 +1,54 @@
 # frozen_string_literal: true
 
-module Nanoc::Int::Compiler::Phases
-  # Provides functionality for suspending and resuming item rep compilation (using fibers).
-  class Resume < Abstract
-    include Nanoc::Int::ContractsSupport
-
-    DONE = Object.new
-
-    def initialize(wrapped:)
-      super(wrapped: wrapped)
-    end
-
-    contract Nanoc::Int::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?
-        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)
-        when DONE # rubocop:disable Lint/EmptyWhen
-          # ignore
-        else
-          raise Nanoc::Int::Errors::InternalInconsistency.new(
-            "Fiber yielded object of unexpected type #{res.class}",
-          )
+module Nanoc
+  module Int
+    class Compiler
+      module Phases
+        # 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::Int::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::Int::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
-
-      Nanoc::Int::NotificationCenter.post(:compilation_ended, rep)
-    end
-
-    private
-
-    contract Nanoc::Int::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

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

@@ -1,77 +1,83 @@
 # frozen_string_literal: true
 
-module Nanoc::Int::Compiler::Phases
-  class Write < Abstract
-    include Nanoc::Int::ContractsSupport
-
-    class Worker
-      def initialize(queue:, snapshot_repo:)
-        @queue = queue
-        @snapshot_repo = snapshot_repo
-      end
-
-      def start
-        @thread = Thread.new do
-          Thread.current.abort_on_exception = true
-          Thread.current.priority = -1 # schedule I/O work ASAP
-
-          writer = Nanoc::Int::ItemRepWriter.new
-
-          while rep = @queue.pop # rubocop:disable Lint/AssignmentInCondition
-            writer.write_all(rep, @snapshot_repo)
+module Nanoc
+  module Int
+    class Compiler
+      module Phases
+        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::Int::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
-        end
-      end
 
-      def join
-        @thread.join
-      end
-    end
-
-    class WorkerPool
-      def initialize(queue:, size:, snapshot_repo:)
-        @workers = Array.new(size) { Worker.new(queue: queue, snapshot_repo: snapshot_repo) }
-      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 start
+              @workers.each(&:start)
+            end
 
-      def join
-        @workers.each(&:join)
-      end
-    end
+            def join
+              @workers.each(&:join)
+            end
+          end
 
-    QUEUE_SIZE = 40
-    WORKER_POOL_SIZE = 5
+          QUEUE_SIZE = 40
+          WORKER_POOL_SIZE = 5
 
-    def initialize(snapshot_repo:, wrapped:)
-      super(wrapped: wrapped)
+          def initialize(compiled_content_store:, wrapped:)
+            super(wrapped: wrapped)
 
-      @snapshot_repo = snapshot_repo
+            @compiled_content_store = compiled_content_store
 
-      @queue = SizedQueue.new(QUEUE_SIZE)
-      @worker_pool = WorkerPool.new(queue: @queue, size: WORKER_POOL_SIZE, snapshot_repo: @snapshot_repo)
-    end
+            @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 start
+            super
+            @worker_pool.start
+          end
 
-    def stop
-      super
-      @queue.close
-      @worker_pool.join
-    end
+          def stop
+            super
+            @queue.close
+            @worker_pool.join
+          end
 
-    contract Nanoc::Int::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
+          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
 
-      @queue << rep
+            @queue << rep
 
-      Nanoc::Int::NotificationCenter.post(:rep_write_enqueued, rep)
+            Nanoc::Core::NotificationCenter.post(:rep_write_enqueued, rep)
+          end
+        end
+      end
     end
   end
 end