nanoc 4.6.1 → 4.6.2

data/spec/nanoc/base/entities/rule_memory_spec.rb

@@ -64,8 +64,8 @@ describe Nanoc::Int::RuleMemory do
 
         expect(rule_memory.size).to eql(1)
         expect(rule_memory[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
-        expect(rule_memory[0].snapshot_name).to eql(:before_layout)
-        expect(rule_memory[0].path).to eql('/foo.md')
+        expect(rule_memory[0].snapshot_names).to eql([:before_layout])
+        expect(rule_memory[0].paths).to eql(['/foo.md'])
       end
     end
 
@@ -122,10 +122,46 @@ describe Nanoc::Int::RuleMemory do
       expect(subject).to eql(
         [
           [:filter, :erb, 'PeWUm2PtXYtqeHJdTqnY7kkwAow='],
-          [:snapshot, :bar, true, '/foo.md'],
+          [:snapshot, [:bar], true, ['/foo.md']],
           [:layout, '/default.erb', '97LAe1pYTLKczxBsu+x4MmvqdkU='],
         ],
       )
     end
   end
+
+  describe '#compact_snapshots' do
+    subject { rule_memory.compact_snapshots }
+
+    before do
+      rule_memory.add_snapshot(:a1, nil)
+      rule_memory.add_snapshot(:a2, '/a2.md')
+      rule_memory.add_snapshot(:a3, nil)
+      rule_memory.add_filter(:erb, awesomeness: 'high')
+      rule_memory.add_snapshot(:b1, '/b1.md')
+      rule_memory.add_snapshot(:b2, nil)
+      rule_memory.add_snapshot(:b3, '/b3.md')
+      rule_memory.add_filter(:erb, awesomeness: 'high')
+      rule_memory.add_snapshot(:c, nil)
+    end
+
+    example do
+      expect(subject[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
+      expect(subject[0].snapshot_names).to eql([:a1, :a2, :a3])
+      expect(subject[0].paths).to eql(['/a2.md'])
+
+      expect(subject[1]).to be_a(Nanoc::Int::ProcessingActions::Filter)
+
+      expect(subject[2]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
+      expect(subject[2].snapshot_names).to eql([:b1, :b2, :b3])
+      expect(subject[2].paths).to eql(['/b1.md', '/b3.md'])
+
+      expect(subject[3]).to be_a(Nanoc::Int::ProcessingActions::Filter)
+
+      expect(subject[4]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
+      expect(subject[4].snapshot_names).to eql([:c])
+      expect(subject[4].paths).to be_empty
+
+      expect(subject.size).to eql(5)
+    end
+  end
 end

data/spec/nanoc/base/entities/site_spec.rb

@@ -4,8 +4,7 @@ describe Nanoc::Int::Site do
       described_class.new(
         config: config,
         code_snippets: code_snippets,
-        items: items,
-        layouts: layouts,
+        data_source: Nanoc::Int::InMemDataSource.new(items, layouts),
       )
     end
 
@@ -21,17 +20,23 @@ describe Nanoc::Int::Site do
     end
 
     let(:items) do
-      Nanoc::Int::IdentifiableCollection.new(config).tap do |coll|
-        coll << Nanoc::Int::Item.new('foo', {}, '/foo.md')
-        coll << Nanoc::Int::Item.new('bar', {}, '/bar.md')
-      end
+      Nanoc::Int::IdentifiableCollection.new(
+        config,
+        [
+          Nanoc::Int::Item.new('foo', {}, '/foo.md'),
+          Nanoc::Int::Item.new('bar', {}, '/bar.md'),
+        ],
+      )
     end
 
     let(:layouts) do
-      Nanoc::Int::IdentifiableCollection.new(config).tap do |coll|
-        coll << Nanoc::Int::Layout.new('foo', {}, '/foo.md')
-        coll << Nanoc::Int::Layout.new('bar', {}, '/bar.md')
-      end
+      Nanoc::Int::IdentifiableCollection.new(
+        config,
+        [
+          Nanoc::Int::Layout.new('foo', {}, '/foo.md'),
+          Nanoc::Int::Layout.new('bar', {}, '/bar.md'),
+        ],
+      )
     end
 
     before do

data/spec/nanoc/base/filter_spec.rb

@@ -70,7 +70,7 @@ describe Nanoc::Filter do
     before do
       reps << rep
 
-      expect(dependency_tracker).to receive(:bounce).with(item, compiled_content: true)
+      expect(dependency_tracker).to receive(:bounce).with(item, compiled_content: true).at_least(:once)
     end
 
     context 'rep is compiled' do
@@ -96,5 +96,32 @@ describe Nanoc::Filter do
         expect(fiber.resume).not_to be_a(Nanoc::Int::Errors::UnmetDependency)
       end
     end
+
+    context 'multiple reps exist' do
+      let(:other_rep) { Nanoc::Int::ItemRep.new(item, :default) }
+
+      before do
+        reps << other_rep
+        rep.compiled = false
+        other_rep.compiled = false
+      end
+
+      it 'yields an unmet dependency error twice' do
+        fiber = Fiber.new { subject }
+
+        # resume 1
+        res = fiber.resume
+        expect(res).to be_a(Nanoc::Int::Errors::UnmetDependency)
+        expect(res.rep).to eql(rep)
+
+        # resume 2
+        res = fiber.resume
+        expect(res).to be_a(Nanoc::Int::Errors::UnmetDependency)
+        expect(res.rep).to eql(other_rep)
+
+        # resume 3
+        expect(fiber.resume).not_to be_a(Nanoc::Int::Errors::UnmetDependency)
+      end
+    end
   end
 end

data/spec/nanoc/base/item_rep_writer_spec.rb

@@ -20,12 +20,14 @@ describe Nanoc::Int::ItemRepWriter do
     let(:snapshot_name) { :donkey }
 
     let(:raw_paths) do
-      { snapshot_name => raw_path }
+      { snapshot_name => [raw_path] }
     end
 
     let(:snapshot_repo) { Nanoc::Int::SnapshotRepo.new }
 
-    subject { described_class.new.write(item_rep, snapshot_repo, snapshot_name) }
+    let(:written_paths) { [] }
+
+    subject { described_class.new.write(item_rep, snapshot_repo, snapshot_name, written_paths) }
 
     before do
       expect(File.directory?('output')).to be_falsy

data/spec/nanoc/base/repos/outdatedness_store_spec.rb

@@ -11,8 +11,7 @@ describe Nanoc::Int::OutdatednessStore do
     Nanoc::Int::Site.new(
       config: config,
       code_snippets: code_snippets,
-      items: items,
-      layouts: layouts,
+      data_source: Nanoc::Int::InMemDataSource.new(items, layouts),
     )
   end
 

data/spec/nanoc/base/repos/snapshot_repo_spec.rb

@@ -103,7 +103,7 @@ describe Nanoc::Int::SnapshotRepo do
 
       context 'snapshot def exists' do
         before do
-          rep.snapshot_defs = [Nanoc::Int::SnapshotDef.new(snapshot_name)]
+          rep.snapshot_defs = [Nanoc::Int::SnapshotDef.new(snapshot_name, binary: false)]
           repo.set_all(rep, snapshot_name => content)
         end
 
@@ -128,7 +128,7 @@ describe Nanoc::Int::SnapshotRepo do
 
       context 'snapshot def exists, but not content' do
         before do
-          rep.snapshot_defs = [Nanoc::Int::SnapshotDef.new(snapshot_name)]
+          rep.snapshot_defs = [Nanoc::Int::SnapshotDef.new(snapshot_name, binary: false)]
           repo.set_all(rep, {})
         end
 
@@ -148,7 +148,7 @@ describe Nanoc::Int::SnapshotRepo do
       context 'snapshot exists' do
         context 'snapshot is not final' do
           before do
-            rep.snapshot_defs = [Nanoc::Int::SnapshotDef.new(snapshot_name)]
+            rep.snapshot_defs = [Nanoc::Int::SnapshotDef.new(snapshot_name, binary: false)]
           end
 
           context 'snapshot content does not exist' do
@@ -209,7 +209,7 @@ describe Nanoc::Int::SnapshotRepo do
 
         context 'snapshot is final' do
           before do
-            rep.snapshot_defs = [Nanoc::Int::SnapshotDef.new(snapshot_name)]
+            rep.snapshot_defs = [Nanoc::Int::SnapshotDef.new(snapshot_name, binary: false)]
           end
 
           context 'snapshot content does not exist' do

data/spec/nanoc/base/repos/store_spec.rb

@@ -4,7 +4,11 @@ describe Nanoc::Int::Store do
       subject { described_class.tmp_path_for(site: site, store_name: 'giraffes') }
 
       let(:site) do
-        Nanoc::Int::Site.new(config: config, code_snippets: code_snippets, items: items, layouts: layouts)
+        Nanoc::Int::Site.new(
+          config: config,
+          code_snippets: code_snippets,
+          data_source: Nanoc::Int::InMemDataSource.new(items, layouts),
+        )
       end
 
       let(:code_snippets) { [] }

data/spec/nanoc/base/services/compiler/stages/compile_reps_spec.rb

@@ -37,8 +37,7 @@ describe Nanoc::Int::Compiler::Stages::CompileReps do
     Nanoc::Int::Site.new(
       config: config,
       code_snippets: code_snippets,
-      items: items,
-      layouts: layouts,
+      data_source: Nanoc::Int::InMemDataSource.new(items, layouts),
     )
   end
 
@@ -47,17 +46,17 @@ describe Nanoc::Int::Compiler::Stages::CompileReps do
   let(:code_snippets) { [] }
 
   let(:items) do
-    Nanoc::Int::IdentifiableCollection.new(config).tap do |col|
-      col << item
-      col << other_item
-    end
+    Nanoc::Int::IdentifiableCollection.new(
+      config,
+      [item, other_item],
+    )
   end
 
   let(:memory) do
     actions =
       [
         Nanoc::Int::ProcessingActions::Filter.new(:erb, {}),
-        Nanoc::Int::ProcessingActions::Snapshot.new(:last, nil),
+        Nanoc::Int::ProcessingActions::Snapshot.new([:last], []),
       ]
 
     Nanoc::Int::RuleMemory.new(nil, actions: actions)
@@ -68,7 +67,7 @@ describe Nanoc::Int::Compiler::Stages::CompileReps do
     reps << other_rep
 
     reps.each do |rep|
-      rep.snapshot_defs << Nanoc::Int::SnapshotDef.new(:last)
+      rep.snapshot_defs << Nanoc::Int::SnapshotDef.new(:last, binary: false)
     end
 
     allow(action_provider).to receive(:memory_for).with(rep).and_return(memory)
@@ -84,11 +83,11 @@ describe Nanoc::Int::Compiler::Stages::CompileReps do
     end
 
     let(:snapshot_defs_for_rep) do
-      [Nanoc::Int::SnapshotDef.new(:last)]
+      [Nanoc::Int::SnapshotDef.new(:last, binary: false)]
     end
 
     let(:snapshot_defs_for_other_rep) do
-      [Nanoc::Int::SnapshotDef.new(:last)]
+      [Nanoc::Int::SnapshotDef.new(:last, binary: false)]
     end
 
     context 'rep not in outdatedness store' do

data/spec/nanoc/base/services/executor_spec.rb

@@ -414,7 +414,7 @@ describe Nanoc::Int::Executor do
     end
 
     before do
-      rep.snapshot_defs = [Nanoc::Int::SnapshotDef.new(:pre)]
+      rep.snapshot_defs = [Nanoc::Int::SnapshotDef.new(:pre, binary: false)]
 
       snapshot_repo.set(rep, :last, content)
 
@@ -616,7 +616,7 @@ describe Nanoc::Int::Executor do
 
       context 'raw path' do
         before do
-          rep.raw_paths = { something: 'output/donkey.md' }
+          rep.raw_paths = { something: ['output/donkey.md'] }
         end
 
         it 'does not write' do

data/spec/nanoc/base/services/item_rep_router_spec.rb

@@ -19,46 +19,68 @@ describe(Nanoc::Int::ItemRepRouter) do
     end
 
     let(:paths_0) do
-      { last: '/foo/index.html' }
+      [
+        [[:last], ['/foo/index.html']],
+      ]
     end
 
     let(:paths_1) do
-      { last: '/bar.html' }
+      [
+        [[:last], ['/bar.html']],
+      ]
     end
 
     example do
-      expect(action_provider).to receive(:paths_for).with(reps[0]).and_return(paths_0)
-      expect(action_provider).to receive(:paths_for).with(reps[1]).and_return(paths_1)
+      allow(action_provider).to receive(:paths_for).with(reps[0]).and_return(paths_0)
+      allow(action_provider).to receive(:paths_for).with(reps[1]).and_return(paths_1)
+
+      subject
+
+      expect(reps[0].raw_paths).to eql(last: ['output/foo/index.html'])
+      expect(reps[0].paths).to eql(last: ['/foo/'])
+
+      expect(reps[1].raw_paths).to eql(last: ['output/bar.html'])
+      expect(reps[1].paths).to eql(last: ['/bar.html'])
+    end
+
+    it 'picks the paths last returned' do
+      expect(action_provider).to receive(:paths_for).with(reps[0]).and_return([[[:last], []]]).ordered
+      expect(action_provider).to receive(:paths_for).with(reps[0]).and_return(paths_0).ordered
+      expect(action_provider).to receive(:paths_for).with(reps[1]).and_return([[[:last], []]]).ordered
+      expect(action_provider).to receive(:paths_for).with(reps[1]).and_return(paths_1).ordered
 
       subject
 
-      expect(reps[0].raw_paths).to eql(last: 'output/foo/index.html')
-      expect(reps[0].paths).to eql(last: '/foo/')
+      expect(reps[0].raw_paths).to eql(last: ['output/foo/index.html'])
+      expect(reps[0].paths).to eql(last: ['/foo/'])
 
-      expect(reps[1].raw_paths).to eql(last: 'output/bar.html')
-      expect(reps[1].paths).to eql(last: '/bar.html')
+      expect(reps[1].raw_paths).to eql(last: ['output/bar.html'])
+      expect(reps[1].paths).to eql(last: ['/bar.html'])
     end
   end
 
   describe '#route_rep' do
-    subject { item_rep_router.route_rep(rep, path, snapshot_name, paths_to_reps) }
+    subject { item_rep_router.route_rep(rep, paths, snapshot_names, paths_to_reps) }
 
-    let(:path) { basic_path }
-    let(:snapshot_name) { :foo }
+    let(:snapshot_names) { [:foo] }
     let(:rep) { Nanoc::Int::ItemRep.new(item, :default) }
     let(:item) { Nanoc::Int::Item.new('content', {}, '/foo.md') }
     let(:paths_to_reps) { {} }
 
     context 'basic path is nil' do
-      let(:basic_path) { nil }
-      it { is_expected.to be_nil }
+      let(:paths) { [] }
+
+      it 'assigns no paths' do
+        subject
+        expect(rep.raw_paths[:foo]).to be_empty
+      end
     end
 
     context 'basic path is not nil' do
-      let(:basic_path) { '/foo/index.html' }
+      let(:paths) { ['/foo/index.html'] }
 
       context 'other snapshot with this path already exists' do
-        let(:paths_to_reps) { { '/foo/index.html' => double(:other_rep) } }
+        let(:paths_to_reps) { { '/foo/index.html' => Nanoc::Int::ItemRep.new(item, :other) } }
 
         it 'errors' do
           expect { subject }.to raise_error(Nanoc::Int::ItemRepRouter::IdenticalRoutesError)
@@ -66,42 +88,64 @@ describe(Nanoc::Int::ItemRepRouter) do
       end
 
       context 'path is unique' do
-        it 'sets the raw path' do
-          subject
-          expect(rep.raw_paths).to eql(foo: 'output/foo/index.html')
-        end
+        context 'single path' do
+          it 'sets the raw path' do
+            subject
+            expect(rep.raw_paths).to eql(foo: ['output/foo/index.html'])
+          end
 
-        it 'sets the path' do
-          subject
-          expect(rep.paths).to eql(foo: '/foo/')
-        end
+          it 'sets the path' do
+            subject
+            expect(rep.paths).to eql(foo: ['/foo/'])
+          end
 
-        it 'adds to paths_to_reps' do
-          subject
-          expect(paths_to_reps).to have_key('/foo/index.html')
-        end
+          it 'adds to paths_to_reps' do
+            subject
+            expect(paths_to_reps).to have_key('/foo/index.html')
+          end
 
-        context 'path does not start with a slash' do
-          let(:basic_path) { 'foo/index.html' }
+          context 'path does not start with a slash' do
+            let(:paths) { ['foo/index.html'] }
 
-          it 'errors' do
-            expect { subject }.to raise_error(Nanoc::Int::ItemRepRouter::RouteWithoutSlashError)
+            it 'errors' do
+              expect { subject }.to raise_error(Nanoc::Int::ItemRepRouter::RouteWithoutSlashError)
+            end
+          end
+
+          context 'path is not UTF-8' do
+            let(:paths) { ['/foo/index.html'.encode('ISO-8859-1')] }
+
+            it 'sets the path as UTF-8' do
+              subject
+              expect(rep.paths).to eql(foo: ['/foo/'])
+              expect(rep.paths[:foo].first.encoding.to_s).to eql('UTF-8')
+            end
+
+            it 'sets the raw path as UTF-8' do
+              subject
+              expect(rep.raw_paths).to eql(foo: ['output/foo/index.html'])
+              expect(rep.raw_paths[:foo].first.encoding.to_s).to eql('UTF-8')
+            end
           end
         end
 
-        context 'path is not UTF-8' do
-          let(:basic_path) { '/foo/index.html'.encode('ISO-8859-1') }
+        context 'multiple paths' do
+          let(:paths) { ['/foo/index.html', '/bar/index.html'] }
+
+          it 'sets the raw paths' do
+            subject
+            expect(rep.raw_paths).to eql(foo: ['output/foo/index.html', 'output/bar/index.html'])
+          end
 
-          it 'sets the path as UTF-8' do
+          it 'sets the paths' do
             subject
-            expect(rep.paths).to eql(foo: '/foo/')
-            expect(rep.paths[:foo].encoding.to_s).to eql('UTF-8')
+            expect(rep.paths).to eql(foo: ['/foo/', '/bar/'])
           end
 
-          it 'sets the raw path as UTF-8' do
+          it 'adds to paths_to_reps' do
             subject
-            expect(rep.raw_paths).to eql(foo: 'output/foo/index.html')
-            expect(rep.raw_paths[:foo].encoding.to_s).to eql('UTF-8')
+            expect(paths_to_reps).to have_key('/foo/index.html')
+            expect(paths_to_reps).to have_key('/bar/index.html')
           end
         end
       end