nanoc 4.8.11 → 4.8.12

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

@@ -56,4 +56,38 @@ describe Nanoc::Int::Store do
       end
     end
   end
+
+  let(:test_store_klass) do
+    Class.new(Nanoc::Int::Store) do
+      def data
+        @data
+      end
+
+      def data=(new_data)
+        @data = new_data
+      end
+    end
+  end
+
+  it 'deletes and reloads on error' do
+    store = test_store_klass.new('test.db', 1)
+
+    # Create
+    store.load
+    store.data = { fun: 'sure' }
+    store.store
+
+    # Test stored values
+    store = test_store_klass.new('test.db', 1)
+    store.load
+    expect(store.data).to eq(fun: 'sure')
+
+    # Mess up
+    File.write('test.db', 'Damn {}#}%@}$^)@&$&*^#@ broken stores!!!')
+
+    # Reload
+    store = test_store_klass.new('test.db', 1)
+    store.load
+    expect(store.data).to be_nil
+  end
 end

data/spec/nanoc/base/services/compiler/phases/cache_spec.rb

@@ -10,7 +10,7 @@ describe Nanoc::Int::Compiler::Phases::Cache do
   end
 
   let(:compiled_content_cache) do
-    Nanoc::Int::CompiledContentCache.new(items: [item])
+    Nanoc::Int::CompiledContentCache.new(items: [item], site: site)
   end
 
   let(:snapshot_repo) { Nanoc::Int::SnapshotRepo.new }
@@ -32,6 +32,14 @@ describe Nanoc::Int::Compiler::Phases::Cache do
   let(:item) { Nanoc::Int::Item.new('item content', {}, '/donkey.md') }
   let(:rep) { Nanoc::Int::ItemRep.new(item, :latex) }
 
+  let(:site) do
+    Nanoc::Int::Site.new(
+      config: Nanoc::Int::Configuration.new.with_defaults,
+      code_snippets: [],
+      data_source: Nanoc::Int::InMemDataSource.new([item], []),
+    )
+  end
+
   describe '#run' do
     subject { phase.call(rep, is_outdated: is_outdated) }
 

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 describe Nanoc::Int::Compiler::Stages::Cleanup do
-  let(:stage) { described_class.new(config) }
+  let(:stage) { described_class.new(config.output_dirs) }
 
   let(:config) do
     Nanoc::Int::Configuration.new.with_defaults

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

@@ -25,7 +25,7 @@ describe Nanoc::Int::Compiler::Stages::CompileReps do
   let(:action_provider) { double(:action_provider) }
   let(:action_sequences) { double(:action_sequences) }
   let(:reps) { Nanoc::Int::ItemRepRepo.new }
-  let(:compiled_content_cache) { Nanoc::Int::CompiledContentCache.new(items: items) }
+  let(:compiled_content_cache) { Nanoc::Int::CompiledContentCache.new(items: items, site: site) }
   let(:snapshot_repo) { Nanoc::Int::SnapshotRepo.new }
 
   let(:outdatedness_store) { Nanoc::Int::OutdatednessStore.new(site: site) }

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+describe Nanoc::Int::NotificationCenter do
+  it 'receives notification after subscribing' do
+    ping_received = false
+    Nanoc::Int::NotificationCenter.on :ping_received, :test do
+      ping_received = true
+    end
+
+    Nanoc::Int::NotificationCenter.post :ping_received
+    expect(ping_received).to be
+  end
+
+  it 'does not receive notification after unsubscribing' do
+    ping_received = false
+    Nanoc::Int::NotificationCenter.on :ping_received, :test do
+      ping_received = true
+    end
+
+    Nanoc::Int::NotificationCenter.remove :ping_received, :test
+
+    Nanoc::Int::NotificationCenter.post :ping_received
+    expect(ping_received).not_to be
+  end
+end

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

@@ -42,7 +42,7 @@ describe Nanoc::Int::OutdatednessChecker do
   end
 
   let(:action_sequence_store) do
-    Nanoc::Int::ActionSequenceStore.new
+    Nanoc::Int::ActionSequenceStore.new(site: site)
   end
 
   let(:old_action_sequence_for_item_rep) do
@@ -74,7 +74,7 @@ describe Nanoc::Int::OutdatednessChecker do
 
     let(:checksum_store) { Nanoc::Int::ChecksumStore.new(objects: items.to_a + layouts.to_a) }
 
-    let(:config) { Nanoc::Int::Configuration.new }
+    let(:config) { Nanoc::Int::Configuration.new.with_defaults }
 
     before do
       checksum_store.add(item)
@@ -182,7 +182,7 @@ describe Nanoc::Int::OutdatednessChecker do
     let(:other_item) { Nanoc::Int::Item.new('other stuff', {}, '/other.md') }
     let(:other_item_rep) { Nanoc::Int::ItemRep.new(other_item, :default) }
 
-    let(:config) { Nanoc::Int::Configuration.new }
+    let(:config) { Nanoc::Int::Configuration.new.with_defaults }
 
     let(:items) { Nanoc::Int::ItemCollection.new(config, [item, other_item]) }
 

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

@@ -21,7 +21,7 @@ describe Nanoc::Int::OutdatednessRules do
     let(:item_rep) { Nanoc::Int::ItemRep.new(item, :default) }
     let(:item) { Nanoc::Int::Item.new('stuff', {}, '/foo.md') }
 
-    let(:config) { Nanoc::Int::Configuration.new }
+    let(:config) { Nanoc::Int::Configuration.new.with_defaults }
     let(:code_snippets) { [] }
     let(:objects) { [config] + code_snippets + [item] }
 
@@ -36,7 +36,7 @@ describe Nanoc::Int::OutdatednessRules do
     let(:action_sequences) { {} }
     let(:reps) { Nanoc::Int::ItemRepRepo.new }
     let(:dependency_store) { Nanoc::Int::DependencyStore.new(items, layouts, config) }
-    let(:action_sequence_store) { Nanoc::Int::ActionSequenceStore.new }
+    let(:action_sequence_store) { Nanoc::Int::ActionSequenceStore.new(site: site) }
     let(:checksum_store) { Nanoc::Int::ChecksumStore.new(objects: objects) }
 
     let(:checksums) do

data/spec/nanoc/base/views/post_compile_item_rep_view_spec.rb

@@ -23,7 +23,7 @@ describe Nanoc::PostCompileItemRepView do
 
   let(:reps) { double(:reps) }
   let(:items) { Nanoc::Int::ItemCollection.new(config) }
-  let(:config) { Nanoc::Int::Configuration.new }
+  let(:config) { Nanoc::Int::Configuration.new.with_defaults }
   let(:dependency_tracker) { Nanoc::Int::DependencyTracker.new(double(:dependency_store)) }
   let(:compilation_context) { double(:compilation_context, compiled_content_cache: compiled_content_cache) }
   let(:snapshot_repo) { double(:snapshot_repo) }
@@ -36,8 +36,16 @@ describe Nanoc::PostCompileItemRepView do
     }
   end
 
+  let(:site) do
+    Nanoc::Int::Site.new(
+      config: config,
+      code_snippets: [],
+      data_source: Nanoc::Int::InMemDataSource.new(items, []),
+    )
+  end
+
   let(:compiled_content_cache) do
-    Nanoc::Int::CompiledContentCache.new(items: items).tap do |ccc|
+    Nanoc::Int::CompiledContentCache.new(items: items, site: site).tap do |ccc|
       ccc[item_rep] = snapshot_contents
     end
   end

data/spec/nanoc/filters/colorize_syntax/rouge_spec.rb

@@ -2,7 +2,7 @@
 
 require 'rouge'
 
-describe Nanoc::Filters::ColorizeSyntax, filter: true, rouge: true do
+describe Nanoc::Filters::ColorizeSyntax, filter: true do
   subject { filter.setup_and_run(input, default_colorizer: :rouge, rouge: params) }
   let(:filter) { ::Nanoc::Filters::ColorizeSyntax.new }
   let(:params) { {} }
@@ -28,10 +28,15 @@ describe Nanoc::Filters::ColorizeSyntax, filter: true, rouge: true do
   end
 
   context 'with Rouge' do
-    context 'with 1.x', if: Rouge.version < '2' do
-      context 'with default options' do
-        it { is_expected.to eql output }
-      end
+    context 'with default options' do
+      it { is_expected.to eql output }
+    end
+
+    context 'with legacy' do
+      let(:legacy) { true }
+      let(:params) { super().merge(legacy: legacy) }
+
+      it { is_expected.to eql output }
 
       context 'with pygments wrapper' do
         let(:wrap) { true }
@@ -53,12 +58,12 @@ describe Nanoc::Filters::ColorizeSyntax, filter: true, rouge: true do
         let(:output) do
           <<~EOS
             before
-            <pre><code class="language-ruby"><table style="border-spacing: 0"><tbody><tr>
-            <td class="gutter gl" style="text-align: right"><pre class="lineno">1
-            2</pre></td>
-            <td class="code"><pre>  <span class="k">def</span> <span class="nf">foo</span>
-              <span class="k">end</span><span class="w">
-            </span></pre></td>
+            <pre><code class="language-ruby"><table class="rouge-table"><tbody><tr>
+            <td class="rouge-gutter gl"><pre class="lineno">1
+            2
+            </pre></td>
+            <td class="rouge-code"><pre>  <span class="k">def</span> <span class="nf">foo</span>
+              <span class="k">end</span></pre></td>
             </tr></tbody></table></code></pre>
             after
           EOS
@@ -68,129 +73,82 @@ describe Nanoc::Filters::ColorizeSyntax, filter: true, rouge: true do
       end
     end
 
-    context 'with 2.x', if: Rouge.version >= '2' do
-      context 'with default options' do
-        it { is_expected.to eql output }
-      end
-
-      context 'with legacy' do
-        let(:legacy) { true }
-        let(:params) { super().merge(legacy: legacy) }
-
-        it { is_expected.to eql output }
-
-        context 'with pygments wrapper' do
-          let(:wrap) { true }
-          let(:params) { super().merge(wrap: wrap) }
-
-          it { is_expected.to eql output }
-
-          context 'with css_class' do
-            let(:css_class) { 'nanoc' }
-            let(:params) { super().merge(css_class: css_class) }
+    context 'with formater' do
+      let(:params) { super().merge(formatter: formatter) }
 
-            it { is_expected.to eql output }
-          end
-        end
+      context 'with inline' do
+        let(:formatter) { Rouge::Formatters::HTMLInline.new(theme) }
 
-        context 'with line number' do
-          let(:line_numbers) { true }
-          let(:params) { super().merge(line_numbers: line_numbers) }
+        context 'with github theme' do
+          let(:theme) { Rouge::Themes::Github.new }
           let(:output) do
             <<~EOS
               before
-              <pre><code class="language-ruby"><table class="rouge-table"><tbody><tr>
-              <td class="rouge-gutter gl"><pre class="lineno">1
-              2
-              </pre></td>
-              <td class="rouge-code"><pre>  <span class="k">def</span> <span class="nf">foo</span>
-                <span class="k">end</span></pre></td>
-              </tr></tbody></table></code></pre>
+              <pre><code class="language-ruby">  <span style="color: #000000;font-weight: bold">def</span> <span style="color: #990000;font-weight: bold">foo</span>
+                <span style="color: #000000;font-weight: bold">end</span></code></pre>
               after
             EOS
           end
 
           it { is_expected.to eql output }
         end
-      end
-
-      context 'with formater' do
-        let(:params) { super().merge(formatter: formatter) }
-
-        context 'with inline' do
-          let(:formatter) { Rouge::Formatters::HTMLInline.new(theme) }
-
-          context 'with github theme' do
-            let(:theme) { Rouge::Themes::Github.new }
-            let(:output) do
-              <<~EOS
-                before
-                <pre><code class="language-ruby">  <span style="color: #000000;font-weight: bold">def</span> <span style="color: #990000;font-weight: bold">foo</span>
-                  <span style="color: #000000;font-weight: bold">end</span></code></pre>
-                after
-              EOS
-            end
-
-            it { is_expected.to eql output }
-          end
-
-          context 'with colorful theme' do
-            let(:theme) { Rouge::Themes::Colorful.new }
-            let(:output) do
-              <<~EOS
-                before
-                <pre><code class="language-ruby">  <span style="color: #080;font-weight: bold">def</span> <span style="color: #06B;font-weight: bold">foo</span>
-                  <span style="color: #080;font-weight: bold">end</span></code></pre>
-                after
-              EOS
-            end
-
-            it { is_expected.to eql output }
-          end
-        end
 
-        context 'with linewise' do
-          let(:formatter) { Rouge::Formatters::HTMLLinewise.new(Rouge::Formatters::HTML.new) }
+        context 'with colorful theme' do
+          let(:theme) { Rouge::Themes::Colorful.new }
           let(:output) do
             <<~EOS
               before
-              <pre><code class="language-ruby"><div class="line-1">  <span class="k">def</span> <span class="nf">foo</span>
-              </div>
-              <div class="line-2">  <span class="k">end</span>
-              </div></code></pre>
+              <pre><code class="language-ruby">  <span style="color: #080;font-weight: bold">def</span> <span style="color: #06B;font-weight: bold">foo</span>
+                <span style="color: #080;font-weight: bold">end</span></code></pre>
               after
             EOS
           end
 
           it { is_expected.to eql output }
         end
+      end
 
-        context 'with pygments' do
-          let(:wrap) { true }
-          let(:css_class) { 'codehilite' }
-          let(:formatter) { Rouge::Formatters::HTMLPygments.new(Rouge::Formatters::HTML.new) }
-
-          it { is_expected.to eql output }
+      context 'with linewise' do
+        let(:formatter) { Rouge::Formatters::HTMLLinewise.new(Rouge::Formatters::HTML.new) }
+        let(:output) do
+          <<~EOS
+            before
+            <pre><code class="language-ruby"><div class="line-1">  <span class="k">def</span> <span class="nf">foo</span>
+            </div>
+            <div class="line-2">  <span class="k">end</span>
+            </div></code></pre>
+            after
+          EOS
         end
 
-        context 'with table' do
-          let(:formatter) { Rouge::Formatters::HTMLTable.new(Rouge::Formatters::HTML.new) }
-          let(:output) do
-            <<~EOS
-              before
-              <pre><code class="language-ruby"><table class="rouge-table"><tbody><tr>
-              <td class="rouge-gutter gl"><pre class="lineno">1
-              2
-              </pre></td>
-              <td class="rouge-code"><pre>  <span class="k">def</span> <span class="nf">foo</span>
-                <span class="k">end</span></pre></td>
-              </tr></tbody></table></code></pre>
-              after
-            EOS
-          end
+        it { is_expected.to eql output }
+      end
 
-          it { is_expected.to eql output }
+      context 'with pygments' do
+        let(:wrap) { true }
+        let(:css_class) { 'codehilite' }
+        let(:formatter) { Rouge::Formatters::HTMLPygments.new(Rouge::Formatters::HTML.new) }
+
+        it { is_expected.to eql output }
+      end
+
+      context 'with table' do
+        let(:formatter) { Rouge::Formatters::HTMLTable.new(Rouge::Formatters::HTML.new) }
+        let(:output) do
+          <<~EOS
+            before
+            <pre><code class="language-ruby"><table class="rouge-table"><tbody><tr>
+            <td class="rouge-gutter gl"><pre class="lineno">1
+            2
+            </pre></td>
+            <td class="rouge-code"><pre>  <span class="k">def</span> <span class="nf">foo</span>
+              <span class="k">end</span></pre></td>
+            </tr></tbody></table></code></pre>
+            after
+          EOS
         end
+
+        it { is_expected.to eql output }
       end
     end
   end

data/spec/nanoc/regressions/gh_1248_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+describe 'GH-1248', site: true, stdio: true do
+  before do
+    File.write('content/stuff.html', 'hi')
+
+    File.write('Rules', <<~EOS)
+      preprocess do
+        @config[:output_dir] = 'ootpoot'
+      end
+
+      passthrough '/**/*'
+    EOS
+  end
+
+  before do
+    Nanoc::CLI.run(%w[compile])
+  end
+
+  example do
+    expect { Nanoc::CLI.run(%w[compile --verbose]) }
+      .not_to output(/identical .* ootpoot\/stuff.html/).to_stdout
+  end
+end

data/spec/nanoc/rule_dsl/rule_spec.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+describe Nanoc::RuleDSL::Rule do
+  subject(:rule) do
+    Nanoc::RuleDSL::Rule.new(pattern, :xml, block)
+  end
+
+  let(:pattern) { Nanoc::Int::Pattern.from(%r{/(.*)/(.*)/}) }
+  let(:block) { proc {} }
+
+  describe '#matches' do
+    subject { rule.send(:matches, identifier) }
+
+    context 'does not match' do
+      let(:identifier) { '/moo/' }
+      it { is_expected.to be_nil }
+    end
+
+    context 'matches' do
+      let(:identifier) { '/anything/else/' }
+      it { is_expected.to eql(%w[anything else]) }
+    end
+  end
+
+  describe '#initialize' do
+    context 'with snapshot_name' do
+      subject { Nanoc::RuleDSL::Rule.new(pattern, :xml, proc {}, snapshot_name: :donkey) }
+
+      its(:rep_name) { is_expected.to eql(:xml) }
+      its(:pattern) { is_expected.to eql(pattern) }
+      its(:snapshot_name) { is_expected.to eql(:donkey) }
+    end
+
+    context 'without snapshot_name' do
+      subject { Nanoc::RuleDSL::Rule.new(pattern, :xml, proc {}) }
+
+      its(:rep_name) { is_expected.to eql(:xml) }
+      its(:pattern) { is_expected.to eql(pattern) }
+      its(:snapshot_name) { is_expected.to be_nil }
+    end
+  end
+
+  describe '#applicable_to?' do
+    subject { rule.applicable_to?(item) }
+
+    let(:item) { Nanoc::Int::Item.new('', {}, '/foo.md') }
+
+    context 'pattern matches' do
+      let(:pattern) { Nanoc::Int::Pattern.from(%r{^/foo.*}) }
+      it { is_expected.to be }
+    end
+
+    context 'pattern does not match' do
+      let(:pattern) { Nanoc::Int::Pattern.from(%r{^/bar.*}) }
+      it { is_expected.not_to be }
+    end
+  end
+
+  describe '#apply_to' do
+    subject { rule.apply_to(rep, site: site, executor: executor, view_context: view_context) }
+
+    let(:block) do
+      proc { self }
+    end
+
+    let(:item) { Nanoc::Int::Item.new('', {}, '/foo.md') }
+    let(:rep) { Nanoc::Int::ItemRep.new(item, :amazings) }
+
+    let(:site) { Nanoc::Int::Site.new(config: config, data_source: data_source, code_snippets: []) }
+    let(:data_source) { Nanoc::Int::InMemDataSource.new(items, layouts) }
+    let(:config) { Nanoc::Int::Configuration.new }
+    let(:executor) { nil }
+    let(:view_context) { Nanoc::ViewContextForPreCompilation.new(items: items) }
+    let(:items) { Nanoc::Int::ItemCollection.new(config, []) }
+    let(:layouts) { Nanoc::Int::LayoutCollection.new(config, []) }
+
+    it 'returns a rule context' do
+      expect(subject).to be_a(Nanoc::RuleDSL::RuleContext)
+    end
+
+    it 'makes rep accessible' do
+      expect(subject.instance_eval { rep }.unwrap).to eql(rep)
+      expect(subject.instance_eval { @rep }.unwrap).to eql(rep)
+    end
+
+    it 'makes item_rep accessible' do
+      expect(subject.instance_eval { item_rep }.unwrap).to eql(rep)
+      expect(subject.instance_eval { @item_rep }.unwrap).to eql(rep)
+    end
+
+    it 'makes item accessible' do
+      expect(subject.instance_eval { item }.unwrap).to eql(item)
+      expect(subject.instance_eval { @item }.unwrap).to eql(item)
+    end
+
+    it 'makes items accessible' do
+      expect(subject.instance_eval { items }.unwrap).to eql(items)
+      expect(subject.instance_eval { @items }.unwrap).to eql(items)
+    end
+
+    it 'makes layouts accessible' do
+      expect(subject.instance_eval { layouts }.unwrap).to eql(layouts)
+      expect(subject.instance_eval { @layouts }.unwrap).to eql(layouts)
+    end
+
+    it 'makes config accessible' do
+      expect(subject.instance_eval { config }.unwrap).to eql(config)
+      expect(subject.instance_eval { @config }.unwrap).to eql(config)
+    end
+  end
+end