nanoc 4.6.1 → 4.6.2

data/lib/nanoc/base/entities/snapshot_def.rb

@@ -4,10 +4,16 @@ module Nanoc
       include Nanoc::Int::ContractsSupport
 
       attr_reader :name
+      attr_reader :binary
 
-      contract Symbol => C::Any
-      def initialize(name)
+      contract Symbol, C::KeywordArgs[binary: C::Optional[C::Bool]] => C::Any
+      def initialize(name, binary:)
         @name = name
+        @binary = binary
+      end
+
+      def binary?
+        @binary
       end
     end
   end

data/lib/nanoc/base/repos.rb

@@ -10,3 +10,6 @@ require_relative 'repos/outdatedness_store'
 require_relative 'repos/rule_memory_store'
 require_relative 'repos/site_loader'
 require_relative 'repos/snapshot_repo'
+require_relative 'repos/in_mem_data_source'
+require_relative 'repos/aggregate_data_source'
+require_relative 'repos/prefixed_data_source'

data/lib/nanoc/base/repos/aggregate_data_source.rb

@@ -0,0 +1,20 @@
+module Nanoc::Int
+  class AggregateDataSource < Nanoc::DataSource
+    def initialize(data_sources, config)
+      super({}, '/', '/', {})
+
+      @data_sources = data_sources
+      @config = config
+    end
+
+    def items
+      objs = @data_sources.flat_map(&:items)
+      @_items ||= Nanoc::Int::IdentifiableCollection.from(objs, @config)
+    end
+
+    def layouts
+      objs = @data_sources.flat_map(&:layouts)
+      @_layouts ||= Nanoc::Int::IdentifiableCollection.from(objs, @config)
+    end
+  end
+end

data/lib/nanoc/base/repos/in_mem_data_source.rb

@@ -0,0 +1,13 @@
+module Nanoc::Int
+  class InMemDataSource < Nanoc::DataSource
+    attr_reader :items
+    attr_reader :layouts
+
+    def initialize(items, layouts)
+      super({}, '/', '/', {})
+
+      @items = items
+      @layouts = layouts
+    end
+  end
+end

data/lib/nanoc/base/repos/prefixed_data_source.rb

@@ -0,0 +1,19 @@
+module Nanoc::Int
+  class PrefixedDataSource < Nanoc::DataSource
+    def initialize(data_source, items_prefix, layouts_prefix)
+      super({}, '/', '/', {})
+
+      @data_source = data_source
+      @items_prefix = items_prefix
+      @layouts_prefix = layouts_prefix
+    end
+
+    def items
+      @data_source.items.map { |d| d.with_identifier_prefix(@items_prefix) }
+    end
+
+    def layouts
+      @data_source.layouts.map { |d| d.with_identifier_prefix(@layouts_prefix) }
+    end
+  end
+end

data/lib/nanoc/base/repos/site_loader.rb

@@ -23,27 +23,19 @@ module Nanoc::Int
       code_snippets = code_snippets_from_config(config)
       code_snippets.each(&:load)
 
-      items = Nanoc::Int::IdentifiableCollection.new(config)
-      layouts = Nanoc::Int::IdentifiableCollection.new(config)
-
-      with_data_sources(config) do |data_sources|
-        data_sources.each do |ds|
-          items_in_ds = ds.items
-          layouts_in_ds = ds.layouts
-
-          items_in_ds.each { |i| i.identifier = i.identifier.prefix(ds.items_root) }
-          layouts_in_ds.each { |l| l.identifier = l.identifier.prefix(ds.layouts_root) }
-
-          items.concat(items_in_ds)
-          layouts.concat(layouts_in_ds)
+      data_sources_to_aggregate =
+        with_data_sources(config) do |data_sources|
+          data_sources.map do |ds|
+            Nanoc::Int::PrefixedDataSource.new(ds, ds.items_root, ds.layouts_root)
+          end
         end
-      end
+
+      data_source = Nanoc::Int::AggregateDataSource.new(data_sources_to_aggregate, config)
 
       Nanoc::Int::Site.new(
         config: config,
         code_snippets: code_snippets,
-        items: items,
-        layouts: layouts,
+        data_source: data_source,
       )
     end
 

data/lib/nanoc/base/repos/snapshot_repo.rb

@@ -29,8 +29,8 @@ module Nanoc::Int
       @contents[rep] = contents_per_snapshot
     end
 
-    contract C::KeywordArgs[rep: Nanoc::Int::ItemRep, snapshot: C::Optional[C::Maybe[Symbol]]] => String
-    def compiled_content(rep:, snapshot: nil)
+    contract C::KeywordArgs[rep: Nanoc::Int::ItemRep, snapshot: C::Optional[C::Maybe[Symbol]]] => Nanoc::Int::Content
+    def raw_compiled_content(rep:, snapshot: nil)
       # Get name of last pre-layout snapshot
       snapshot_name = snapshot || (get(rep, :pre) ? :pre : :last)
 
@@ -45,11 +45,16 @@ module Nanoc::Int
       is_usable_snapshot = get(rep, snapshot_name) && stopped_moving
       unless is_usable_snapshot
         Fiber.yield(Nanoc::Int::Errors::UnmetDependency.new(rep))
-        return compiled_content(rep: rep, snapshot: snapshot)
+        return raw_compiled_content(rep: rep, snapshot: snapshot)
       end
 
-      # Verify snapshot is not binary
-      snapshot_content = get(rep, snapshot_name)
+      get(rep, snapshot_name)
+    end
+
+    contract C::KeywordArgs[rep: Nanoc::Int::ItemRep, snapshot: C::Optional[C::Maybe[Symbol]]] => String
+    def compiled_content(rep:, snapshot: nil)
+      snapshot_content = raw_compiled_content(rep: rep, snapshot: snapshot)
+
       if snapshot_content.binary?
         raise Nanoc::Int::Errors::CannotGetCompiledContentOfBinaryItem.new(rep)
       end

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

@@ -22,5 +22,17 @@ module Nanoc::Int
     def paths_for(rep)
       memory_for(rep).paths
     end
+
+    def need_preprocessing?
+      raise NotImplementedError
+    end
+
+    def preprocess(_site)
+      raise NotImplementedError
+    end
+
+    def postprocess(_site, _reps)
+      raise NotImplementedError
+    end
   end
 end

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

@@ -19,14 +19,17 @@ module Nanoc::Int::Compiler::Phases
 
       @compilation_context.snapshot_repo.set(rep, :last, rep.item.content)
 
-      @action_provider.memory_for(rep).each do |action|
+      actions = @action_provider.memory_for(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
-          executor.snapshot(action.snapshot_name)
+          action.snapshot_names.each do |snapshot_name|
+            executor.snapshot(snapshot_name)
+          end
         else
           raise Nanoc::Int::Errors::InternalInconsistency, "unknown action #{action.inspect}"
         end

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

@@ -11,9 +11,7 @@ module Nanoc::Int::Compiler::Phases
     def run(rep, is_outdated:)
       @wrapped.run(rep, is_outdated: is_outdated)
 
-      rep.snapshot_defs.each do |sdef|
-        Nanoc::Int::ItemRepWriter.new.write(rep, @snapshot_repo, sdef.name)
-      end
+      Nanoc::Int::ItemRepWriter.new.write_all(rep, @snapshot_repo)
     end
   end
 end

data/lib/nanoc/base/services/compiler/stages/preprocess.rb

@@ -8,10 +8,13 @@ module Nanoc::Int::Compiler::Stages
     end
 
     def run
-      @action_provider.preprocess(@site)
+      if @action_provider.need_preprocessing?
+        @site.data_source = Nanoc::Int::InMemDataSource.new(@site.items, @site.layouts)
+        @action_provider.preprocess(@site)
 
-      @dependency_store.objects = @site.items.to_a + @site.layouts.to_a
-      @checksum_store.objects = @site.items.to_a + @site.layouts.to_a + @site.code_snippets + [@site.config]
+        @dependency_store.objects = @site.items.to_a + @site.layouts.to_a
+        @checksum_store.objects = @site.items.to_a + @site.layouts.to_a + @site.code_snippets + [@site.config]
+      end
 
       @site.freeze
     end

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

@@ -57,8 +57,7 @@ module Nanoc
         raise Nanoc::Int::Errors::CannotLayoutBinaryItem.new(@rep) if last.binary?
 
         # Create filter
-        klass = Nanoc::Filter.named(filter_name)
-        raise Nanoc::Int::Errors::UnknownFilter.new(filter_name) if klass.nil?
+        klass = Nanoc::Filter.named!(filter_name)
         view_context = @compilation_context.create_view_context(@dependency_tracker)
         layout_view = Nanoc::LayoutView.new(layout, view_context)
         filter = klass.new(assigns_for(@rep).merge(layout: layout_view))
@@ -110,8 +109,7 @@ module Nanoc
       end
 
       def filter_for_filtering(rep, filter_name)
-        klass = Nanoc::Filter.named(filter_name)
-        raise Nanoc::Int::Errors::UnknownFilter.new(filter_name) if klass.nil?
+        klass = Nanoc::Filter.named!(filter_name)
 
         last = @compilation_context.snapshot_repo.get(@rep, :last)
         if klass.from_binary? && !last.binary?

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

@@ -45,6 +45,12 @@ module Nanoc
         end
       end
 
+      def named!(name)
+        klass = named(name)
+        raise Nanoc::Int::Errors::UnknownFilter.new(name) if klass.nil?
+        klass
+      end
+
       # Sets the new type for the filter. The type can be `:binary` (default)
       # or `:text`. The given argument can either be a symbol indicating both
       # “from” and “to” types, or a hash where the only key is the “from” type
@@ -195,18 +201,7 @@ module Nanoc
     #
     # @return [void]
     def depend_on(items)
-      orig_items = items
-      items = items.map { |i| i.is_a?(Nanoc::ItemWithRepsView) ? i.unwrap : i }
-
-      # Notify
-      dependency_tracker = @assigns[:item]._context.dependency_tracker
-      items.each { |item| dependency_tracker.bounce(item, compiled_content: true) }
-
-      # Raise unmet dependency error if necessary
-      items.each do |item|
-        rep = orig_items.sample._context.reps[item].find { |r| !r.compiled? }
-        Fiber.yield(Nanoc::Int::Errors::UnmetDependency.new(rep)) if rep
-      end
+      items.flat_map(&:reps).flat_map(&:raw_path)
     end
   end
 end

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

@@ -3,6 +3,8 @@ module Nanoc::Int
   #
   # @api private
   class ItemRepRouter
+    include Nanoc::Int::ContractsSupport
+
     class IdenticalRoutesError < ::Nanoc::Error
       def initialize(output_path, rep_a, rep_b)
         super("The item representations #{rep_a.inspect} and #{rep_b.inspect} are both routed to #{output_path}.")
@@ -22,34 +24,56 @@ module Nanoc::Int
     end
 
     def run
-      paths_to_reps = {}
+      assigned_paths = {}
       @reps.each do |rep|
-        @action_provider.paths_for(rep).each do |snapshot_name, path|
-          route_rep(rep, path, snapshot_name, paths_to_reps)
+        # 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.paths_for(rep).each do |(snapshot_names, paths)|
+          route_rep(rep, paths, snapshot_names, {})
         end
+
+        @action_provider.paths_for(rep).each do |(snapshot_names, paths)|
+          route_rep(rep, paths, snapshot_names, assigned_paths)
+        end
+
+        # TODO: verify that paths converge
       end
     end
 
-    def route_rep(rep, path, snapshot_name, paths_to_reps)
-      basic_path = path
-      return if basic_path.nil?
-      basic_path = basic_path.encode('UTF-8')
+    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') }
 
-      unless basic_path.start_with?('/')
-        raise RouteWithoutSlashError.new(basic_path, rep)
+      # Validate format
+      paths.each do |path|
+        unless path.start_with?('/')
+          raise RouteWithoutSlashError.new(path, rep)
+        end
       end
 
-      # Check for duplicate paths
-      if paths_to_reps.key?(basic_path)
-        raise IdenticalRoutesError.new(basic_path, paths_to_reps[basic_path], rep)
-      else
-        paths_to_reps[basic_path] = rep
+      # Validate uniqueness
+      paths.each do |path|
+        if assigned_paths.include?(path)
+          # TODO: Include snapshot names in error message
+          raise IdenticalRoutesError.new(path, assigned_paths[path], rep)
+        end
+      end
+      paths.each do |path|
+        assigned_paths[path] = rep
       end
 
-      rep.raw_paths[snapshot_name] = @site.config[:output_dir] + basic_path
-      rep.paths[snapshot_name] = strip_index_filename(basic_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
 
+    contract String => String
     def strip_index_filename(basic_path)
       @site.config[:index_filenames].each do |index_filename|
         slashed_index_filename = '/' + index_filename

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

@@ -3,9 +3,25 @@ module Nanoc::Int
   class ItemRepWriter
     TMP_TEXT_ITEMS_DIR = 'text_items'.freeze
 
-    def write(item_rep, snapshot_repo, snapshot_name)
-      raw_path = item_rep.raw_path(snapshot: snapshot_name)
-      return unless raw_path
+    def write_all(item_rep, snapshot_repo)
+      written_paths = Set.new
+
+      item_rep.snapshot_defs.map(&:name).each do |snapshot_name|
+        write(item_rep, snapshot_repo, snapshot_name, written_paths)
+      end
+    end
+
+    def write(item_rep, snapshot_repo, snapshot_name, written_paths)
+      item_rep.raw_paths.fetch(snapshot_name, []).each do |raw_path|
+        write_single(item_rep, snapshot_repo, snapshot_name, raw_path, written_paths)
+      end
+    end
+
+    def write_single(item_rep, snapshot_repo, snapshot_name, raw_path, written_paths)
+      # Don’t write twice
+      # TODO: test written_paths behavior
+      return if written_paths.include?(raw_path)
+      written_paths << raw_path
 
       # Create parent directory
       FileUtils.mkdir_p(File.dirname(raw_path))

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

@@ -28,7 +28,7 @@ module Nanoc
     def run
       return unless File.directory?(@config[:output_dir])
 
-      compiled_files = @reps.flat_map { |r| r.raw_paths.values }.compact
+      compiled_files = @reps.flat_map { |r| r.raw_paths.values.flatten }.compact
       present_files, present_dirs = files_and_dirs_in(@config[:output_dir] + '/')
 
       remove_stray_files(present_files, compiled_files)

data/lib/nanoc/base/views/item_rep_view.rb

@@ -74,13 +74,22 @@ module Nanoc
 
     # @api private
     def raw_path(snapshot: :last)
-      @context.dependency_tracker.bounce(unwrap.item, path: true)
-      @item_rep.raw_path(snapshot: snapshot)
+      @context.dependency_tracker.bounce(unwrap.item, compiled_content: true)
+
+      res = @item_rep.raw_path(snapshot: snapshot)
+
+      unless @item_rep.compiled?
+        Fiber.yield(Nanoc::Int::Errors::UnmetDependency.new(@item_rep))
+      end
+
+      res
     end
 
     # @api private
     def binary?
-      @context.snapshot_repo.get(unwrap, :last).binary?
+      snapshot_def = unwrap.snapshot_defs.find { |sd| sd.name == :last }
+      raise Nanoc::Int::Errors::NoSuchSnapshot.new(unwrap, :last) if snapshot_def.nil?
+      snapshot_def.binary?
     end
 
     def inspect

data/lib/nanoc/base/views/mutable_identifiable_collection_view.rb

@@ -8,7 +8,7 @@ module Nanoc
     #
     # @return [self]
     def delete_if(&_block)
-      @objects.delete_if { |o| yield(view_class.new(o, @context)) }
+      @objects = @objects.reject { |o| yield(view_class.new(o, @context)) }
       self
     end
   end

data/lib/nanoc/base/views/mutable_item_collection_view.rb

@@ -23,7 +23,7 @@ module Nanoc
     # @return [self]
     def create(content, attributes, identifier, binary: false, filename: nil)
       content = Nanoc::Int::Content.create(content, binary: binary, filename: filename)
-      @objects << Nanoc::Int::Item.new(content, attributes, identifier)
+      @objects = @objects.add(Nanoc::Int::Item.new(content, attributes, identifier))
       self
     end
   end