nanoc 4.7.10 → 4.7.11

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

@@ -5,7 +5,7 @@ module Nanoc::Int
   class DependencyTracker
     include Nanoc::Int::ContractsSupport
 
-    C_OBJ = C::Or[Nanoc::Int::Item, Nanoc::Int::Layout]
+    C_OBJ = C::Or[Nanoc::Int::Item, Nanoc::Int::Layout, Nanoc::Int::Configuration]
     C_ATTR = C::Or[C::IterOf[Symbol], C::Bool]
     C_ARGS = C::KeywordArgs[raw_content: C::Optional[C::Bool], attributes: C::Optional[C_ATTR], compiled_content: C::Optional[C::Bool], path: C::Optional[C::Bool]]
 

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

@@ -18,6 +18,7 @@ module Nanoc
 
     # @see Hash#fetch
     def fetch(key, fallback = NONE, &_block)
+      @context.dependency_tracker.bounce(unwrap, attributes: [key])
       @config.fetch(key) do
         if !fallback.equal?(NONE)
           fallback
@@ -31,16 +32,19 @@ module Nanoc
 
     # @see Hash#key?
     def key?(key)
+      @context.dependency_tracker.bounce(unwrap, attributes: [key])
       @config.key?(key)
     end
 
     # @see Hash#[]
     def [](key)
+      @context.dependency_tracker.bounce(unwrap, attributes: [key])
       @config[key]
     end
 
     # @see Hash#each
     def each(&block)
+      @context.dependency_tracker.bounce(unwrap, attributes: true)
       @config.each(&block)
     end
   end

data/lib/nanoc/checking/checks/external_links.rb

@@ -69,13 +69,10 @@ module ::Nanoc::Checking::Checks
         begin
           Timeout.timeout(timeouts[i]) do
             res = request_url_once(url)
-            if res.code == '405'
-              res = request_url_once(url, Net::HTTP::Get)
-            end
           end
         rescue => e
           last_err = e
-          next # can not allow
+          next
         end
 
         if res.code =~ /^3..$/
@@ -122,8 +119,8 @@ module ::Nanoc::Checking::Checks
       path
     end
 
-    def request_url_once(url, req_method = Net::HTTP::Head)
-      req = req_method.new(path_for_url(url))
+    def request_url_once(url)
+      req = Net::HTTP::Get.new(path_for_url(url))
       http = Net::HTTP.new(url.host, url.port)
       if url.instance_of? URI::HTTPS
         http.use_ssl = true

data/lib/nanoc/cli.rb

@@ -78,8 +78,6 @@ module Nanoc::CLI
     add_after_setup_proc(block)
   end
 
-  protected
-
   # Makes the command-line interface ready for use.
   #
   # @return [void]

data/lib/nanoc/cli/commands/shell.rb

@@ -6,19 +6,18 @@ aliases 'console'
 description "
 Open an IRB shell on a context that contains @items, @layouts, and @config.
 "
+flag :p, :preprocess, 'run preprocessor'
 
 module Nanoc::CLI::Commands
   class Shell < ::Nanoc::CLI::CommandRunner
     def run
       require 'pry'
 
-      load_site
+      load_site(preprocess: options[:preprocess])
 
       Nanoc::Int::Context.new(env).pry
     end
 
-    protected
-
     def env
       self.class.env_for_site(site)
     end

data/lib/nanoc/filters/colorize_syntax/colorizers.rb

@@ -166,7 +166,10 @@ module Nanoc::Filters::ColorizeSyntax::Colorizers
       code1 = element.xpath('code').first
       return if code1.nil?
 
-      pre = code1.xpath('pre').first
+      div = code1.xpath('div').first
+
+      # For Rouge 2.x and 1.x, respectively
+      pre = (div || code1).xpath('pre').first
       return if pre.nil?
 
       code2 = pre.xpath('code').first

data/lib/nanoc/telemetry/table.rb

@@ -13,7 +13,7 @@ module Nanoc::Telemetry
       [].tap do |lines|
         lines << row_to_s(@rows[0], column_lengths)
         lines << separator(column_lengths)
-        lines.concat(@rows.map { |r| row_to_s(r, column_lengths) })
+        lines.concat(@rows.drop(1).map { |r| row_to_s(r, column_lengths) })
       end.join("\n")
     end
 

data/lib/nanoc/version.rb

@@ -2,5 +2,5 @@
 
 module Nanoc
   # The current Nanoc version.
-  VERSION = '4.7.10'
+  VERSION = '4.7.11'
 end

data/nanoc.gemspec

@@ -13,11 +13,7 @@ Gem::Specification.new do |s|
   s.email   = 'denis.defreyne@stoneship.org'
   s.license = 'MIT'
 
-  s.files =
-    Dir['[A-Z]*'] +
-    Dir['doc/yardoc_{templates,handlers}/**/*'] +
-    Dir['{bin,lib,tasks,test,spec}/**/*'] +
-    ['nanoc.gemspec']
+  s.files              = `git ls-files -z`.split("\x0")
   s.executables        = ['nanoc']
   s.require_paths      = ['lib']
 

data/scripts/release

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'octokit'
+
+def run(*args)
+  puts 'I will execute the following:'
+  puts '    ' + args.map { |a| a =~ /\s/ ? a.inspect : a }.join(' ')
+  print 'Is this correct? [y/N] '
+  res = gets
+  unless res.strip.casecmp('y').zero?
+    $stderr.puts 'Answer was not Y; release aborted.'
+    exit 1
+  end
+
+  system('echo', *args)
+  system(*args)
+
+  print 'Continue? [y/N] '
+  res = gets
+  unless res.strip.casecmp('y').zero?
+    $stderr.puts 'Answer was not Y; release aborted.'
+    exit 1
+  end
+end
+
+puts '=== Logging in to GitHub’s API…'
+client = Octokit::Client.new(netrc: true)
+puts
+
+puts '=== Deleting old *.gem files…'
+Dir['*.gem'].each do |fn|
+  puts "  #{fn}…"
+  FileUtils.rm_f(fn)
+end
+puts
+
+puts '=== Verifying presence of release date…'
+unless File.readlines('NEWS.md').drop(2).first =~ / \(\d{4}-\d{2}-\d{2}\)$/
+  $stderr.puts 'No proper release date found!'
+  exit 1
+end
+puts
+
+puts '=== Building new gem…'
+run('gem', 'build', 'nanoc.gemspec')
+puts
+
+puts '=== Reading version…'
+require './lib/nanoc/version'
+puts "Version = #{Nanoc::VERSION}"
+puts
+
+puts '=== Verifying that release does not yet exist…'
+releases = client.releases('nanoc/nanoc')
+release = releases.find { |r| r.tag_name == Nanoc::VERSION }
+if release
+  $stderr.puts 'Release already exists!'
+  $stderr.puts 'ABORTED!'
+  exit 1
+end
+puts
+
+puts '=== Creating Git tag…'
+run('git', 'tag', '--sign', '--annotate', Nanoc::VERSION, '--message', "Version #{Nanoc::VERSION}")
+puts
+
+puts '=== Pushing Git data…'
+run('git', 'push', 'origin', '--tags')
+puts
+
+puts '=== Pushing gem…'
+run('gem', 'push', "nanoc-#{Nanoc::VERSION}.gem")
+puts
+
+puts '=== Reading release notes…'
+release_notes =
+  File.readlines('NEWS.md')
+      .drop(4)
+      .take_while { |l| l !~ /^## / }
+      .join
+puts
+
+puts '=== Creating release on GitHub…'
+sleep 3 # Give GitHub some time to detect the new tag
+is_prerelease = Nanoc::VERSION =~ /a|b|rc/ || Nanoc::VERSION =~ /^0/
+client.create_release(
+  'nanoc/nanoc', Nanoc::VERSION,
+  prerelease: !is_prerelease.nil?,
+  body: release_notes
+)
+puts
+
+puts 'DONE!'

data/{test → spec/nanoc}/base/core_ext/array_spec.rb

@@ -1,34 +1,26 @@
 # frozen_string_literal: true
 
-require 'helper'
-
 describe 'Array#__nanoc_symbolize_keys_recursively' do
   it 'should convert keys to symbols' do
     array_old = [:abc, 'xyz', { 'foo' => 'bar', :baz => :qux }]
     array_new = [:abc, 'xyz', { foo: 'bar', baz: :qux }]
-    array_old.__nanoc_symbolize_keys_recursively.must_equal array_new
+    expect(array_old.__nanoc_symbolize_keys_recursively).to eql(array_new)
   end
 end
 
 describe 'Array#__nanoc_freeze_recursively' do
-  include Nanoc::TestHelpers
-
   it 'should prevent first-level elements from being modified' do
     array = [:a, %i[b c], :d]
     array.__nanoc_freeze_recursively
 
-    assert_raises_frozen_error do
-      array[0] = 123
-    end
+    expect { array[0] = 123 }.to raise_frozen_error
   end
 
   it 'should prevent second-level elements from being modified' do
     array = [:a, %i[b c], :d]
     array.__nanoc_freeze_recursively
 
-    assert_raises_frozen_error do
-      array[1][0] = 123
-    end
+    expect { array[1][0] = 123 }.to raise_frozen_error
   end
 
   it 'should not freeze infinitely' do
@@ -37,8 +29,7 @@ describe 'Array#__nanoc_freeze_recursively' do
 
     a.__nanoc_freeze_recursively
 
-    assert a.frozen?
-    assert a[0].frozen?
-    assert_equal a, a[0]
+    expect(a).to be_frozen
+    expect(a[0]).to be_frozen
   end
 end

data/{test → spec/nanoc}/base/core_ext/hash_spec.rb

@@ -1,40 +1,32 @@
 # frozen_string_literal: true
 
-require 'helper'
-
 describe 'Hash#__nanoc_symbolize_keys_recursively' do
   it 'should convert keys to symbols' do
     hash_old = { 'foo' => 'bar' }
     hash_new = { foo: 'bar' }
-    hash_old.__nanoc_symbolize_keys_recursively.must_equal hash_new
+    expect(hash_old.__nanoc_symbolize_keys_recursively).to eql(hash_new)
   end
 
   it 'should not require string keys' do
     hash_old = { Time.now => 'abc' }
     hash_new = hash_old
-    hash_old.__nanoc_symbolize_keys_recursively.must_equal hash_new
+    expect(hash_old.__nanoc_symbolize_keys_recursively).to eql(hash_new)
   end
 end
 
 describe 'Hash#__nanoc_freeze_recursively' do
-  include Nanoc::TestHelpers
-
   it 'should prevent first-level elements from being modified' do
     hash = { a: { b: :c } }
     hash.__nanoc_freeze_recursively
 
-    assert_raises_frozen_error do
-      hash[:a] = 123
-    end
+    expect { hash[:a] = 123 }.to raise_frozen_error
   end
 
   it 'should prevent second-level elements from being modified' do
     hash = { a: { b: :c } }
     hash.__nanoc_freeze_recursively
 
-    assert_raises_frozen_error do
-      hash[:a][:b] = 123
-    end
+    expect { hash[:a][:b] = 123 }.to raise_frozen_error
   end
 
   it 'should not freeze infinitely' do
@@ -43,8 +35,7 @@ describe 'Hash#__nanoc_freeze_recursively' do
 
     a.__nanoc_freeze_recursively
 
-    assert a.frozen?
-    assert a[:x].frozen?
-    assert_equal a, a[:x]
+    expect(a).to be_frozen
+    expect(a[0]).to be_frozen
   end
 end

data/spec/nanoc/base/core_ext/string_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+describe 'String#__nanoc_cleaned_identifier' do
+  it 'should not convert already clean paths' do
+    expect('/foo/bar/'.__nanoc_cleaned_identifier).to eql('/foo/bar/')
+  end
+
+  it 'should prepend slash if necessary' do
+    expect('foo/bar/'.__nanoc_cleaned_identifier).to eql('/foo/bar/')
+  end
+
+  it 'should append slash if necessary' do
+    expect('/foo/bar'.__nanoc_cleaned_identifier).to eql('/foo/bar/')
+  end
+
+  it 'should remove double slashes at start' do
+    expect('//foo/bar/'.__nanoc_cleaned_identifier).to eql('/foo/bar/')
+  end
+
+  it 'should remove double slashes at end' do
+    expect('/foo/bar//'.__nanoc_cleaned_identifier).to eql('/foo/bar/')
+  end
+end

data/spec/nanoc/base/directed_graph_spec.rb

@@ -65,4 +65,295 @@ describe Nanoc::Int::DirectedGraph do
       it { is_expected.to eq([2, 3, 4, 5]) }
     end
   end
+
+  describe '#all_paths' do
+    subject { graph.all_paths.to_a }
+
+    context 'no cycles' do
+      example do
+        expect(subject).to contain_exactly(
+          [1],
+          [2],
+          [3],
+        )
+      end
+    end
+
+    context 'one cycle without head' do
+      before do
+        graph.add_edge(1, 2)
+        graph.add_edge(2, 1)
+      end
+
+      example do
+        expect(subject).to contain_exactly(
+          [1],
+          [1, 2],
+          [1, 2, 1],
+          [2],
+          [2, 1],
+          [2, 1, 2],
+          [3],
+        )
+      end
+    end
+
+    context 'one cycle with head' do
+      before do
+        graph.add_edge(1, 2)
+        graph.add_edge(2, 3)
+        graph.add_edge(3, 2)
+      end
+
+      example do
+        expect(subject).to contain_exactly(
+          [1],
+          [1, 2],
+          [1, 2, 3],
+          [1, 2, 3, 2],
+          [2],
+          [2, 3],
+          [2, 3, 2],
+          [3],
+          [3, 2],
+          [3, 2, 3],
+        )
+      end
+    end
+
+    context 'one cycle with tail' do
+      before do
+        graph.add_edge(1, 2)
+        graph.add_edge(2, 20)
+        graph.add_edge(20, 21)
+        graph.add_edge(2, 3)
+        graph.add_edge(3, 1)
+      end
+
+      example do
+        expect(subject).to contain_exactly(
+          [1],
+          [1, 2],
+          [1, 2, 20],
+          [1, 2, 20, 21],
+          [1, 2, 3],
+          [1, 2, 3, 1],
+          [2],
+          [2, 20],
+          [2, 20, 21],
+          [2, 3],
+          [2, 3, 1],
+          [2, 3, 1, 2],
+          [3],
+          [3, 1],
+          [3, 1, 2],
+          [3, 1, 2, 20],
+          [3, 1, 2, 20, 21],
+          [3, 1, 2, 3],
+          [20],
+          [20, 21],
+          [21],
+        )
+      end
+    end
+
+    context 'large cycle' do
+      before do
+        graph.add_edge(1, 2)
+        graph.add_edge(2, 3)
+        graph.add_edge(3, 4)
+        graph.add_edge(4, 5)
+        graph.add_edge(5, 1)
+      end
+
+      example do
+        expect(subject).to contain_exactly(
+          [1],
+          [1, 2],
+          [1, 2, 3],
+          [1, 2, 3, 4],
+          [1, 2, 3, 4, 5],
+          [1, 2, 3, 4, 5, 1],
+          [2],
+          [2, 3],
+          [2, 3, 4],
+          [2, 3, 4, 5],
+          [2, 3, 4, 5, 1],
+          [2, 3, 4, 5, 1, 2],
+          [3],
+          [3, 4],
+          [3, 4, 5],
+          [3, 4, 5, 1],
+          [3, 4, 5, 1, 2],
+          [3, 4, 5, 1, 2, 3],
+          [4],
+          [4, 5],
+          [4, 5, 1],
+          [4, 5, 1, 2],
+          [4, 5, 1, 2, 3],
+          [4, 5, 1, 2, 3, 4],
+          [5],
+          [5, 1],
+          [5, 1, 2],
+          [5, 1, 2, 3],
+          [5, 1, 2, 3, 4],
+          [5, 1, 2, 3, 4, 5],
+        )
+      end
+    end
+
+    context 'large cycle with head' do
+      before do
+        graph.add_edge(1, 2)
+        graph.add_edge(2, 3)
+        graph.add_edge(3, 4)
+        graph.add_edge(4, 5)
+        graph.add_edge(5, 2)
+      end
+
+      example do
+        expect(subject).to contain_exactly(
+          [1],
+          [1, 2],
+          [1, 2, 3],
+          [1, 2, 3, 4],
+          [1, 2, 3, 4, 5],
+          [1, 2, 3, 4, 5, 2],
+          [2],
+          [2, 3],
+          [2, 3, 4],
+          [2, 3, 4, 5],
+          [2, 3, 4, 5, 2],
+          [3],
+          [3, 4],
+          [3, 4, 5],
+          [3, 4, 5, 2],
+          [3, 4, 5, 2, 3],
+          [4],
+          [4, 5],
+          [4, 5, 2],
+          [4, 5, 2, 3],
+          [4, 5, 2, 3, 4],
+          [5],
+          [5, 2],
+          [5, 2, 3],
+          [5, 2, 3, 4],
+          [5, 2, 3, 4, 5],
+        )
+      end
+    end
+  end
+
+  describe '#dfs_from' do
+    subject do
+      [].tap do |ps|
+        graph.dfs_from(1) do |p|
+          ps << p
+        end
+      end
+    end
+
+    context 'no cycles' do
+      example do
+        expect(subject).to contain_exactly(
+          [1],
+        )
+      end
+    end
+
+    context 'one cycle without head' do
+      before do
+        graph.add_edge(1, 2)
+        graph.add_edge(2, 1)
+      end
+
+      example do
+        expect(subject).to contain_exactly(
+          [1],
+          [1, 2],
+          [1, 2, 1],
+        )
+      end
+    end
+
+    context 'one cycle with head' do
+      before do
+        graph.add_edge(1, 2)
+        graph.add_edge(2, 3)
+        graph.add_edge(3, 2)
+      end
+
+      example do
+        expect(subject).to contain_exactly(
+          [1],
+          [1, 2],
+          [1, 2, 3],
+          [1, 2, 3, 2],
+        )
+      end
+    end
+
+    context 'one cycle with tail' do
+      before do
+        graph.add_edge(1, 2)
+        graph.add_edge(2, 20)
+        graph.add_edge(20, 21)
+        graph.add_edge(2, 3)
+        graph.add_edge(3, 1)
+      end
+
+      example do
+        expect(subject).to contain_exactly(
+          [1],
+          [1, 2],
+          [1, 2, 20],
+          [1, 2, 20, 21],
+          [1, 2, 3],
+          [1, 2, 3, 1],
+        )
+      end
+    end
+
+    context 'large cycle' do
+      before do
+        graph.add_edge(1, 2)
+        graph.add_edge(2, 3)
+        graph.add_edge(3, 4)
+        graph.add_edge(4, 5)
+        graph.add_edge(5, 1)
+      end
+
+      example do
+        expect(subject).to contain_exactly(
+          [1],
+          [1, 2],
+          [1, 2, 3],
+          [1, 2, 3, 4],
+          [1, 2, 3, 4, 5],
+          [1, 2, 3, 4, 5, 1],
+        )
+      end
+    end
+
+    context 'large cycle with head' do
+      before do
+        graph.add_edge(1, 2)
+        graph.add_edge(2, 3)
+        graph.add_edge(3, 4)
+        graph.add_edge(4, 5)
+        graph.add_edge(5, 2)
+      end
+
+      example do
+        expect(subject).to contain_exactly(
+          [1],
+          [1, 2],
+          [1, 2, 3],
+          [1, 2, 3, 4],
+          [1, 2, 3, 4, 5],
+          [1, 2, 3, 4, 5, 2],
+        )
+      end
+    end
+  end
 end