Prioritise recompiling dependent reps

lib/nanoc/base/services/item_rep_selector.rb

@@ -7,18 +7,21 @@ def initialize(reps)
       @reps = reps
     end
 
+    NONE = Object.new
+
     def each
       graph = Nanoc::Int::DirectedGraph.new(@reps)
 
+      prioritised = Set.new
       loop do
-        break if graph.roots.empty?
-        rep = graph.roots.each { |e| break e }
+        rep = find(graph, prioritised)
+        break if NONE.equal?(rep)
 
         begin
           yield(rep)
           graph.delete_vertex(rep)
         rescue => e
-          handle_error(e, rep, graph)
+          handle_error(e, rep, graph, prioritised)
         end
       end
 
@@ -28,7 +31,26 @@ def each
       end
     end
 
-    def handle_error(e, rep, graph)
+    def find(graph, prioritised)
+      if graph.roots.empty?
+        NONE
+      elsif prioritised.any?
+        until prioritised.empty?
+          rep = prioritised.each { |e| break e }
+          if graph.roots.include?(rep)
+            return rep
+          else
+            prioritised.delete(rep)
+          end
+        end
+
+        find(graph, prioritised)
+      else
+        graph.roots.each { |e| break e }
+      end
+    end
+
+    def handle_error(e, rep, graph, prioritised)
       actual_error =
         if e.is_a?(Nanoc::Int::Errors::CompilationError)
           e.unwrap
@@ -37,14 +59,15 @@ def handle_error(e, rep, graph)
         end
 
       if actual_error.is_a?(Nanoc::Int::Errors::UnmetDependency)
-        handle_dependency_error(actual_error, rep, graph)
+        handle_dependency_error(actual_error, rep, graph, prioritised)
       else
         raise(e)
       end
     end
 
-    def handle_dependency_error(e, rep, graph)
+    def handle_dependency_error(e, rep, graph, prioritised)
       other_rep = e.rep
+      prioritised << other_rep
       graph.add_edge(other_rep, rep)
       unless graph.vertices.include?(other_rep)
         graph.add_vertex(other_rep)

spec/nanoc/base/services/item_rep_selector_spec.rb

@@ -165,5 +165,20 @@
         expect(tentatively_yielded).to eq [:a, :b, :a, :c, :a, :d, :a, :e, :a]
       end
     end
+
+    context 'unrelated roots' do
+      let(:dependencies) do
+        {
+          a: [:d],
+          b: [:e],
+          c: [],
+        }
+      end
+
+      it 'picks prioritised roots' do
+        expect(successfully_yielded).to eq [:d, :e, :c, :a, :b]
+        expect(tentatively_yielded).to eq [:a, :d, :b, :e, :c, :a, :b]
+      end
+    end
   end
 end