nanoc 4.11.0 → 4.11.1

data/lib/nanoc/base/services/executor.rb

@@ -13,24 +13,24 @@ module Nanoc
         filter = filter_for_filtering(@rep, filter_name)
 
         begin
-          Nanoc::Int::NotificationCenter.post(:filtering_started, @rep, filter_name)
+          Nanoc::Core::NotificationCenter.post(:filtering_started, @rep, filter_name)
 
           # Run filter
-          last = @compilation_context.snapshot_repo.get(@rep, :last)
+          last = @compilation_context.compiled_content_store.get_current(@rep)
           source = last.binary? ? last.filename : last.string
           filter_args.freeze
           result = filter.setup_and_run(source, filter_args)
           last =
             if filter.class.to_binary?
-              Nanoc::Int::BinaryContent.new(filter.output_filename).tap(&:freeze)
+              Nanoc::Core::BinaryContent.new(filter.output_filename).tap(&:freeze)
             else
-              Nanoc::Int::TextualContent.new(result).tap(&:freeze)
+              Nanoc::Core::TextualContent.new(result).tap(&:freeze)
             end
 
           # Store
-          @compilation_context.snapshot_repo.set(@rep, :last, last)
+          @compilation_context.compiled_content_store.set_current(@rep, last)
         ensure
-          Nanoc::Int::NotificationCenter.post(:filtering_ended, @rep, filter_name)
+          Nanoc::Core::NotificationCenter.post(:filtering_ended, @rep, filter_name)
         end
       end
 
@@ -45,7 +45,7 @@ module Nanoc
         filter_args.freeze
 
         # Check whether item can be laid out
-        last = @compilation_context.snapshot_repo.get(@rep, :last)
+        last = @compilation_context.compiled_content_store.get_current(@rep)
         raise Nanoc::Int::Errors::CannotLayoutBinaryItem.new(@rep) if last.binary?
 
         # Create filter
@@ -58,7 +58,7 @@ module Nanoc
         @dependency_tracker.bounce(layout, raw_content: true)
 
         begin
-          Nanoc::Int::NotificationCenter.post(:filtering_started, @rep, filter_name)
+          Nanoc::Core::NotificationCenter.post(:filtering_started, @rep, filter_name)
 
           # Layout
           content = layout.content
@@ -66,16 +66,17 @@ module Nanoc
           res = filter.setup_and_run(arg, filter_args)
 
           # Store
-          last = Nanoc::Int::TextualContent.new(res).tap(&:freeze)
-          @compilation_context.snapshot_repo.set(@rep, :last, last)
+          last = Nanoc::Core::TextualContent.new(res).tap(&:freeze)
+          @compilation_context.compiled_content_store.set_current(@rep, last)
         ensure
-          Nanoc::Int::NotificationCenter.post(:filtering_ended, @rep, filter_name)
+          Nanoc::Core::NotificationCenter.post(:filtering_ended, @rep, filter_name)
         end
       end
 
       def snapshot(snapshot_name)
-        last = @compilation_context.snapshot_repo.get(@rep, :last)
-        @compilation_context.snapshot_repo.set(@rep, snapshot_name, last)
+        last = @compilation_context.compiled_content_store.get_current(@rep)
+        @compilation_context.compiled_content_store.set(@rep, snapshot_name, last)
+        Nanoc::Core::NotificationCenter.post(:snapshot_created, @rep, snapshot_name)
       end
 
       def assigns_for(rep)
@@ -92,7 +93,7 @@ module Nanoc
         return layout if layout
 
         if use_globs?
-          pat = Nanoc::Int::Pattern.from(arg)
+          pat = Nanoc::Core::Pattern.from(arg)
           layout = layouts.find { |l| pat.match?(l.identifier) }
           return layout if layout
         end
@@ -103,7 +104,7 @@ module Nanoc
       def filter_for_filtering(rep, filter_name)
         klass = Nanoc::Filter.named!(filter_name)
 
-        last = @compilation_context.snapshot_repo.get(@rep, :last)
+        last = @compilation_context.compiled_content_store.get_current(@rep)
         if klass.from_binary? && !last.binary?
           raise Nanoc::Int::Errors::CannotUseBinaryFilter.new(rep, klass)
         elsif !klass.from_binary? && last.binary?

data/lib/nanoc/base/services/filter.rb

@@ -25,12 +25,41 @@ module Nanoc
   #     # => 'bar'
   #
   # @abstract Subclass and override {#run} to implement a custom filter.
-  class Filter < Nanoc::Int::Context
+  class Filter < Nanoc::Core::Context
     # @api private
     TMP_BINARY_ITEMS_DIR = 'binary_items'
 
     extend DDPlugin::Plugin
 
+    include Nanoc::Core::ContractsSupport
+
+    class UnknownFilterError < Nanoc::Core::Error
+      include Nanoc::Core::ContractsSupport
+
+      contract C::Or[String, Symbol] => self
+      def initialize(filter_name)
+        super("The requested filter, “#{filter_name}”, does not exist.")
+      end
+    end
+
+    class OutputNotWrittenError < Nanoc::Core::Error
+      include Nanoc::Core::ContractsSupport
+
+      contract C::Or[String, Symbol], String => self
+      def initialize(filter_name, output_filename)
+        super("The #{filter_name.inspect} filter did not write anything to the required output file, #{output_filename}.")
+      end
+    end
+
+    class FilterReturnedNilError < Nanoc::Core::Error
+      include Nanoc::Core::ContractsSupport
+
+      contract C::Or[String, Symbol] => self
+      def initialize(filter_name)
+        super("The #{filter_name.inspect} filter returned nil, but is required to return a String.")
+      end
+    end
+
     class << self
       def define(ident, &block)
         filter_class = Class.new(::Nanoc::Filter) { identifier(ident) }
@@ -41,7 +70,7 @@ module Nanoc
 
       def named!(name)
         klass = named(name)
-        raise Nanoc::Int::Errors::UnknownFilter.new(name) if klass.nil?
+        raise UnknownFilterError.new(name) if klass.nil?
 
         klass
       end
@@ -179,15 +208,16 @@ module Nanoc
     def verify(res)
       if self.class.to_binary?
         unless File.file?(output_filename)
-          raise Nanoc::Int::Errors::OutputNotWritten.new(self.class.identifier, output_filename)
+          raise Nanoc::Filter::OutputNotWrittenError.new(self.class.identifier, output_filename)
         end
       elsif self.class.to_text?
         unless res
-          raise Nanoc::Int::Errors::FilterReturnedNil.new(self.class.identifier)
+          raise Nanoc::Filter::FilterReturnedNilError.new(self.class.identifier)
         end
       end
     end
 
+    contract C::None => String
     # Returns a filename that is used to write data to. This method is only
     #   used on binary items. When running a binary filter on a file, the
     #   resulting file must end up in the location returned by this method.
@@ -198,9 +228,10 @@ module Nanoc
     # @return [String] The output filename
     def output_filename
       @output_filename ||=
-        Nanoc::Int::TempFilenameFactory.instance.create(TMP_BINARY_ITEMS_DIR)
+        Nanoc::Core::TempFilenameFactory.instance.create(TMP_BINARY_ITEMS_DIR)
     end
 
+    contract C::None => String
     # Returns the filename associated with the item that is being filtered.
     #   It is in the format `item <identifier> (rep <name>)`.
     #
@@ -222,6 +253,7 @@ module Nanoc
       Fiber.yield(block)
     end
 
+    contract C::ArrayOf[C::Named['Nanoc::BasicItemView']] => C::Any
     # Creates a dependency from the item that is currently being filtered onto
     # the given collection of items. In other words, require the given items
     # to be compiled first before this items is processed.

data/lib/nanoc/base/services/instrumentor.rb

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
 
-module Nanoc::Int
-  # @api private
-  class Instrumentor
-    def self.call(key, *args)
-      stopwatch = DDMetrics::Stopwatch.new
-      stopwatch.start
-      yield
-    ensure
-      stopwatch.stop
-      Nanoc::Int::NotificationCenter.post(key, stopwatch.duration, *args)
+module Nanoc
+  module Int
+    # @api private
+    class Instrumentor
+      def self.call(key, *args)
+        stopwatch = DDMetrics::Stopwatch.new
+        stopwatch.start
+        yield
+      ensure
+        stopwatch.stop
+        Nanoc::Core::NotificationCenter.post(key, stopwatch.duration, *args)
+      end
     end
   end
 end

data/lib/nanoc/base/services/item_rep_builder.rb

@@ -1,30 +1,32 @@
 # frozen_string_literal: true
 
-module Nanoc::Int
-  # @api private
-  class ItemRepBuilder
-    attr_reader :reps
+module Nanoc
+  module Int
+    # @api private
+    class ItemRepBuilder
+      attr_reader :reps
 
-    def initialize(site, action_provider, reps)
-      @site = site
-      @action_provider = action_provider
-      @reps = reps
-    end
+      def initialize(site, action_provider, reps)
+        @site = site
+        @action_provider = action_provider
+        @reps = reps
+      end
 
-    def run
-      @site.items.each do |item|
-        @action_provider.rep_names_for(item).each do |rep_name|
-          @reps << Nanoc::Int::ItemRep.new(item, rep_name)
+      def run
+        @site.items.each do |item|
+          @action_provider.rep_names_for(item).each do |rep_name|
+            @reps << Nanoc::Core::ItemRep.new(item, rep_name)
+          end
         end
-      end
 
-      action_sequences = Nanoc::Int::ItemRepRouter.new(@reps, @action_provider, @site).run
+        action_sequences = Nanoc::Int::ItemRepRouter.new(@reps, @action_provider, @site).run
 
-      @reps.each do |rep|
-        rep.snapshot_defs = action_sequences[rep].snapshots_defs
-      end
+        @reps.each do |rep|
+          rep.snapshot_defs = action_sequences[rep].snapshots_defs
+        end
 
-      action_sequences
+        action_sequences
+      end
     end
   end
 end

data/lib/nanoc/base/services/item_rep_router.rb

@@ -1,96 +1,98 @@
 # frozen_string_literal: true
 
-module Nanoc::Int
-  # Assigns paths to reps.
-  #
-  # @api private
-  class ItemRepRouter
-    include Nanoc::Int::ContractsSupport
+module Nanoc
+  module Int
+    # Assigns paths to reps.
+    #
+    # @api private
+    class ItemRepRouter
+      include Nanoc::Core::ContractsSupport
 
-    class IdenticalRoutesError < ::Nanoc::Error
-      def initialize(output_path, rep_a, rep_b)
-        super("The item representations #{rep_a} and #{rep_b} are both routed to #{output_path}.")
+      class IdenticalRoutesError < ::Nanoc::Error
+        def initialize(output_path, rep_a, rep_b)
+          super("The item representations #{rep_a} and #{rep_b} are both routed to #{output_path}.")
+        end
       end
-    end
 
-    class RouteWithoutSlashError < ::Nanoc::Error
-      def initialize(output_path, rep)
-        super("The item representation #{rep} is routed to #{output_path}, which does not start with a slash, as required.")
+      class RouteWithoutSlashError < ::Nanoc::Error
+        def initialize(output_path, rep)
+          super("The item representation #{rep} is routed to #{output_path}, which does not start with a slash, as required.")
+        end
       end
-    end
 
-    def initialize(reps, action_provider, site)
-      @reps = reps
-      @action_provider = action_provider
-      @site = site
-    end
+      def initialize(reps, action_provider, site)
+        @reps = reps
+        @action_provider = action_provider
+        @site = site
+      end
 
-    def run
-      action_sequences = {}
-      assigned_paths = {}
-      @reps.each do |rep|
-        # Sigh. We route reps twice, because the first time, the paths might not have converged
-        # yet. This isn’t ideal, but it’s the only way to work around the divergence issues that
-        # I can think of. For details, see
-        # https://github.com/nanoc/nanoc/pull/1085#issuecomment-280628426.
+      def run
+        action_sequences = {}
+        assigned_paths = {}
+        @reps.each do |rep|
+          # Sigh. We route reps twice, because the first time, the paths might not have converged
+          # yet. This isn’t ideal, but it’s the only way to work around the divergence issues that
+          # I can think of. For details, see
+          # https://github.com/nanoc/nanoc/pull/1085#issuecomment-280628426.
 
-        @action_provider.action_sequence_for(rep).paths.each do |(snapshot_names, paths)|
-          route_rep(rep, paths, snapshot_names, {})
-        end
+          @action_provider.action_sequence_for(rep).paths.each do |(snapshot_names, paths)|
+            route_rep(rep, paths, snapshot_names, {})
+          end
 
-        seq = @action_provider.action_sequence_for(rep)
-        action_sequences[rep] = seq
-        seq.paths.each do |(snapshot_names, paths)|
-          route_rep(rep, paths, snapshot_names, assigned_paths)
+          seq = @action_provider.action_sequence_for(rep)
+          action_sequences[rep] = seq
+          seq.paths.each do |(snapshot_names, paths)|
+            route_rep(rep, paths, snapshot_names, assigned_paths)
+          end
+
+          # TODO: verify that paths converge
         end
 
-        # TODO: verify that paths converge
+        action_sequences
       end
 
-      action_sequences
-    end
-
-    contract Nanoc::Int::ItemRep, C::IterOf[String], C::IterOf[Symbol], C::HashOf[String => Nanoc::Int::ItemRep] => C::Any
-    def route_rep(rep, paths, snapshot_names, assigned_paths)
-      # Encode
-      paths = paths.map { |path| path.encode('UTF-8') }
+      contract Nanoc::Core::ItemRep, C::IterOf[String], C::IterOf[Symbol], C::HashOf[String => Nanoc::Core::ItemRep] => C::Any
+      def route_rep(rep, paths, snapshot_names, assigned_paths)
+        # Encode
+        paths = paths.map { |path| path.encode('UTF-8') }
 
-      # Validate format
-      paths.each do |path|
-        unless path.start_with?('/')
-          raise RouteWithoutSlashError.new(path, rep)
+        # Validate format
+        paths.each do |path|
+          unless path.start_with?('/')
+            raise RouteWithoutSlashError.new(path, rep)
+          end
         end
-      end
 
-      # Validate uniqueness
-      paths.each do |path|
-        if assigned_paths.include?(path)
-          # TODO: Include snapshot names in error message
-          reps = [assigned_paths[path], rep].sort_by { |r| [r.item.identifier, r.name] }
-          raise IdenticalRoutesError.new(path, *reps)
+        # Validate uniqueness
+        paths.each do |path|
+          if assigned_paths.include?(path)
+            # TODO: Include snapshot names in error message
+            reps = [assigned_paths[path], rep].sort_by { |r| [r.item.identifier, r.name] }
+            raise IdenticalRoutesError.new(path, *reps)
+          end
+        end
+        paths.each do |path|
+          assigned_paths[path] = rep
         end
-      end
-      paths.each do |path|
-        assigned_paths[path] = rep
-      end
 
-      # Assign
-      snapshot_names.each do |snapshot_name|
-        rep.raw_paths[snapshot_name] = paths.map { |path| @site.config.output_dir + path }
-        rep.paths[snapshot_name] = paths.map { |path| strip_index_filename(path) }
+        # Assign
+        snapshot_names.each do |snapshot_name|
+          rep.raw_paths[snapshot_name] = paths.map { |path| @site.config.output_dir + path }
+          rep.paths[snapshot_name] = paths.map { |path| strip_index_filename(path) }
+        end
       end
-    end
 
-    contract String => String
-    def strip_index_filename(basic_path)
-      @site.config[:index_filenames].each do |index_filename|
-        slashed_index_filename = '/' + index_filename
-        if basic_path.end_with?(slashed_index_filename)
-          return basic_path[0..-index_filename.length - 1]
+      contract String => String
+      def strip_index_filename(basic_path)
+        @site.config[:index_filenames].each do |index_filename|
+          slashed_index_filename = '/' + index_filename
+          if basic_path.end_with?(slashed_index_filename)
+            return basic_path[0..-index_filename.length - 1]
+          end
         end
-      end
 
-      basic_path
+        basic_path
+      end
     end
   end
 end

data/lib/nanoc/base/services/item_rep_selector.rb

@@ -1,64 +1,66 @@
 # frozen_string_literal: true
 
-module Nanoc::Int
-  # Yields item reps to compile.
-  #
-  # @api private
-  class ItemRepSelector
-    def initialize(reps)
-      @reps = reps
-    end
-
-    class MicroGraph
+module Nanoc
+  module Int
+    # Yields item reps to compile.
+    #
+    # @api private
+    class ItemRepSelector
       def initialize(reps)
-        @reps = Set.new(reps)
-        @stack = []
+        @reps = reps
       end
 
-      def next
-        if @stack.any?
-          @stack.last
-        elsif @reps.any?
-          @reps.each { |rep| break rep }.tap do |rep|
-            @reps.delete(rep)
-            @stack.push(rep)
-          end
-        else
-          nil
+      class MicroGraph
+        def initialize(reps)
+          @reps = Set.new(reps)
+          @stack = []
         end
-      end
 
-      def mark_ok
-        @stack.pop
-      end
+        def next
+          if @stack.any?
+            @stack.last
+          elsif @reps.any?
+            @reps.each { |rep| break rep }.tap do |rep|
+              @reps.delete(rep)
+              @stack.push(rep)
+            end
+          else
+            nil
+          end
+        end
 
-      def mark_failed(dep)
-        if @stack.include?(dep)
-          raise Nanoc::Int::Errors::DependencyCycle.new(@stack + [dep])
+        def mark_ok
+          @stack.pop
         end
 
-        @reps.delete(dep)
-        @stack.push(dep)
+        def mark_failed(dep)
+          if @stack.include?(dep)
+            raise Nanoc::Int::Errors::DependencyCycle.new(@stack + [dep])
+          end
+
+          @reps.delete(dep)
+          @stack.push(dep)
+        end
       end
-    end
 
-    def each
-      mg = MicroGraph.new(@reps)
+      def each
+        mg = MicroGraph.new(@reps)
 
-      loop do
-        rep = mg.next
-        break if rep.nil?
+        loop do
+          rep = mg.next
+          break if rep.nil?
 
-        begin
-          yield(rep)
-          mg.mark_ok
-        rescue => e
-          actual_error = e.is_a?(Nanoc::Int::Errors::CompilationError) ? e.unwrap : e
+          begin
+            yield(rep)
+            mg.mark_ok
+          rescue => e
+            actual_error = e.is_a?(Nanoc::Int::Errors::CompilationError) ? e.unwrap : e
 
-          if actual_error.is_a?(Nanoc::Int::Errors::UnmetDependency)
-            mg.mark_failed(actual_error.rep)
-          else
-            raise(e)
+            if actual_error.is_a?(Nanoc::Int::Errors::UnmetDependency)
+              mg.mark_failed(actual_error.rep)
+            else
+              raise(e)
+            end
           end
         end
       end