nanoc 4.8.12 → 4.8.13

data/test/deploying/test_rsync.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-
-class Nanoc::Deploying::Deployers::RsyncTest < Nanoc::TestCase
-  def test_run_without_dst
-    # Create deployer
-    rsync = Nanoc::Deploying::Deployers::Rsync.new(
-      'output/',
-      {},
-    )
-
-    # Mock run_shell_cmd
-    def rsync.run_shell_cmd(args)
-      @shell_cms_args = args
-    end
-
-    # Try running
-    error = assert_raises(RuntimeError) do
-      rsync.run
-    end
-
-    # Check error message
-    assert_equal 'No dst found in deployment configuration', error.message
-  end
-
-  def test_run_with_erroneous_dst
-    # Create deployer
-    rsync = Nanoc::Deploying::Deployers::Rsync.new(
-      'output/',
-      dst: 'asdf/',
-    )
-
-    # Mock run_shell_cmd
-    def rsync.run_shell_cmd(args)
-      @shell_cms_args = args
-    end
-
-    # Try running
-    error = assert_raises(RuntimeError) do
-      rsync.run
-    end
-
-    # Check error message
-    assert_equal 'dst requires no trailing slash', error.message
-  end
-
-  def test_run_everything_okay
-    # Create deployer
-    rsync = Nanoc::Deploying::Deployers::Rsync.new(
-      'output',
-      dst: 'asdf',
-    )
-
-    # Mock run_shell_cmd
-    def rsync.run_shell_cmd(args)
-      @shell_cms_args = args
-    end
-
-    # Run
-    rsync.run
-
-    # Check args
-    opts = Nanoc::Deploying::Deployers::Rsync::DEFAULT_OPTIONS
-    assert_equal(
-      ['rsync', opts, 'output/', 'asdf'].flatten,
-      rsync.instance_eval { @shell_cms_args },
-    )
-  end
-
-  def test_run_everything_okay_dry
-    # Create deployer
-    rsync = Nanoc::Deploying::Deployers::Rsync.new(
-      'output',
-      { dst: 'asdf' },
-      dry_run: true,
-    )
-
-    # Mock run_shell_cmd
-    def rsync.run_shell_cmd(args)
-      @shell_cms_args = args
-    end
-
-    # Run
-    rsync.run
-
-    # Check args
-    opts = Nanoc::Deploying::Deployers::Rsync::DEFAULT_OPTIONS
-    assert_equal(
-      ['echo', 'rsync', opts, 'output/', 'asdf'].flatten,
-      rsync.instance_eval { @shell_cms_args },
-    )
-  end
-end

data/test/extra/core_ext/test_time.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-
-class Nanoc::ExtraCoreExtTimeTest < Nanoc::TestCase
-  def test___nanoc_to_iso8601_date_utc
-    assert_equal('2008-05-19', Time.utc(2008, 5, 19, 14, 20, 0, 0).__nanoc_to_iso8601_date)
-  end
-
-  def test___nanoc_to_iso8601_date_non_utc
-    assert_equal('2008-05-18', Time.new(2008, 5, 19, 0, 0, 0, '+02:00').__nanoc_to_iso8601_date)
-  end
-
-  def test___nanoc_to_iso8601_time
-    assert_equal('2008-05-19T14:20:00Z', Time.utc(2008, 5, 19, 14, 20, 0, 0).__nanoc_to_iso8601_time)
-  end
-end

data/test/extra/test_link_collector.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-
-class Nanoc::Extra::LinkCollectorTest < Nanoc::TestCase
-  def test_all
-    # Create dummy data
-    File.open('file-a.html', 'w') do |io|
-      io << %(<a href="http://example.com/">A 1</a>
-)
-      io << %(<a href="https://example.com/">A 2</a>
-)
-      io << %(<a href="stuff/"A 3></a>
-)
-      io << %(<a name="href-less-anchor">A 4</a>)
-      io << %(<a href="https://example.com/with-fragment#moo">A 5</a>
-)
-    end
-    File.open('file-b.html', 'w') do |io|
-      io << %(<a href="mailto:bob@example.com">B 1</a>
-)
-      io << %(<a href="../stuff">B 2</a>
-)
-      io << %(<a href="/stuff">B 3</a>
-)
-    end
-
-    # Create validator
-    collector = Nanoc::Extra::LinkCollector.new(%w[file-a.html file-b.html])
-
-    # Test
-    hrefs_with_filenames = collector.filenames_per_href
-    hrefs = hrefs_with_filenames.keys
-    assert_includes hrefs, 'http://example.com/'
-    assert_includes hrefs, 'https://example.com/'
-    assert_includes hrefs, 'stuff/'
-    refute_includes hrefs, nil
-    assert_includes hrefs, 'mailto:bob@example.com'
-    assert_includes hrefs, '../stuff'
-    assert_includes hrefs, '/stuff'
-    refute_includes hrefs, 'https://example.com/with-fragment#moo'
-    assert_includes hrefs, 'https://example.com/with-fragment'
-  end
-
-  def test_external
-    # Create dummy data
-    File.open('file-a.html', 'w') do |io|
-      io << %(<a href="http://example.com/">A 1</a>
-)
-      io << %(<a href="https://example.com/">A 2</a>
-)
-      io << %(<a href="stuff/"A 3></a>
-)
-    end
-    File.open('file-b.html', 'w') do |io|
-      io << %(<a href="mailto:bob@example.com">B 1</a>
-)
-      io << %(<a href="../stuff">B 2</a>
-)
-      io << %(<a href="/stuff">B 3</a>
-)
-    end
-
-    # Create validator
-    collector = Nanoc::Extra::LinkCollector.new(%w[file-a.html file-b.html], :external)
-
-    # Test
-    hrefs_with_filenames = collector.filenames_per_href
-    hrefs = hrefs_with_filenames.keys
-    assert_includes hrefs, 'http://example.com/'
-    assert_includes hrefs, 'https://example.com/'
-    refute_includes hrefs, 'stuff/'
-    assert_includes hrefs, 'mailto:bob@example.com'
-    refute_includes hrefs, '../stuff'
-    refute_includes hrefs, '/stuff'
-  end
-
-  def test_internal
-    # Create dummy data
-    File.open('file-a.html', 'w') do |io|
-      io << %(<a href="http://example.com/">A 1</a>
-)
-      io << %(<a href="https://example.com/">A 2</a>
-)
-      io << %(<a href="stuff/"A 3></a>
-)
-    end
-    File.open('file-b.html', 'w') do |io|
-      io << %(<a href="mailto:bob@example.com">B 1</a>
-)
-      io << %(<a href="../stuff">B 2</a>
-)
-      io << %(<a href="/stuff">B 3</a>
-)
-    end
-
-    # Create validator
-    collector = Nanoc::Extra::LinkCollector.new(%w[file-a.html file-b.html], :internal)
-
-    # Test
-    hrefs_with_filenames = collector.filenames_per_href
-    hrefs = hrefs_with_filenames.keys
-    refute_includes hrefs, 'http://example.com/'
-    refute_includes hrefs, 'https://example.com/'
-    assert_includes hrefs, 'stuff/'
-    refute_includes hrefs, 'mailto:bob@example.com'
-    assert_includes hrefs, '../stuff'
-    assert_includes hrefs, '/stuff'
-  end
-end

data/test/extra/test_piper.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-
-class Nanoc::Extra::PiperTest < Nanoc::TestCase
-  def test_basic
-    stdout = StringIO.new
-    stderr = StringIO.new
-
-    cmd = %w[ls -l]
-
-    File.open('foo.txt', 'w') { |io| io.write('hi') }
-    File.open('bar.txt', 'w') { |io| io.write('ho') }
-
-    piper = Nanoc::Extra::Piper.new(stdout: stdout, stderr: stderr)
-    piper.run(cmd, nil)
-
-    assert_match(/foo\.txt/, stdout.string)
-    assert_match(/bar\.txt/, stdout.string)
-    assert stderr.string.empty?
-  end
-
-  def test_stdin
-    stdout = StringIO.new
-    stderr = StringIO.new
-
-    input = 'Hello World!'
-    cmd = %w[cat]
-
-    piper = Nanoc::Extra::Piper.new(stdout: stdout, stderr: stderr)
-    piper.run(cmd, input)
-
-    assert_equal(input, stdout.string)
-    assert_equal('', stderr.string)
-  end
-
-  def test_no_such_command
-    stdout = StringIO.new
-    stderr = StringIO.new
-
-    cmd = %w[cat kafhawilgoiwaejagoualjdsfilofiewaguihaifeowuiga]
-
-    piper = Nanoc::Extra::Piper.new(stdout: stdout, stderr: stderr)
-    assert_raises(Nanoc::Extra::Piper::Error) do
-      piper.run(cmd, nil)
-    end
-  end
-end

data/test/filters/colorize_syntax/test_coderay.rb

@@ -1,247 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-
-class Nanoc::Filters::ColorizeSyntax::CoderayTest < Nanoc::TestCase
-  CODERAY_PRE  = '<div class="CodeRay"><div class="code">'
-  CODERAY_POST = '</div></div>'
-
-  def test_coderay_simple
-    if_have 'coderay', 'nokogiri' do
-      # Create filter
-      filter = ::Nanoc::Filters::ColorizeSyntax.new
-
-      # Get input and expected output
-      input = '<pre title="moo"><code class="language-ruby"># comment</code></pre>'
-      expected_output = CODERAY_PRE + '<pre title="moo"><code class="language-ruby"><span class="comment"># comment</span></code></pre>' + CODERAY_POST
-
-      # Run filter
-      actual_output = filter.setup_and_run(input)
-      assert_equal(expected_output, actual_output)
-    end
-  end
-
-  def test_coderay_with_comment
-    if_have 'coderay', 'nokogiri' do
-      # Create filter
-      filter = ::Nanoc::Filters::ColorizeSyntax.new
-
-      # Get input and expected output
-      input = %(<pre title="moo"><code>#!ruby
-# comment</code></pre>)
-      expected_output = CODERAY_PRE + '<pre title="moo"><code class="language-ruby"><span class="comment"># comment</span></code></pre>' + CODERAY_POST
-
-      # Run filter
-      actual_output = filter.setup_and_run(input)
-      assert_equal(expected_output, actual_output)
-    end
-  end
-
-  def test_coderay_with_comment_in_middle
-    if_have 'coderay', 'nokogiri' do
-      # Create filter
-      filter = ::Nanoc::Filters::ColorizeSyntax.new
-
-      # Get input and expected output
-      input = %(<pre title="moo"><code>def moo ; end
-#!ruby
-# comment</code></pre>)
-      expected_output = "<pre title=\"moo\"><code>def moo ; end\n#!ruby\n# comment</code></pre>"
-
-      # Run filter
-      actual_output = filter.setup_and_run(input)
-      assert_equal(expected_output, actual_output)
-    end
-  end
-
-  def test_coderay_with_comment_and_class
-    if_have 'coderay', 'nokogiri' do
-      # Create filter
-      filter = ::Nanoc::Filters::ColorizeSyntax.new
-
-      # Get input and expected output
-      input = %(<pre title="moo"><code class="language-ruby">#!ruby
-# comment</code></pre>)
-      expected_output = CODERAY_PRE + %(<pre title="moo"><code class="language-ruby"><span class="doctype">#!ruby</span>
-<span class="comment"># comment</span></code></pre>) + CODERAY_POST
-
-      # Run filter
-      actual_output = filter.setup_and_run(input)
-      assert_equal(expected_output, actual_output)
-    end
-  end
-
-  def test_coderay_with_more_classes
-    if_have 'coderay', 'nokogiri' do
-      # Create filter
-      filter = ::Nanoc::Filters::ColorizeSyntax.new
-
-      # Get input and expected output
-      input = '<pre title="moo"><code class="abc language-ruby xyz"># comment</code></pre>'
-      expected_output = CODERAY_PRE + '<pre title="moo"><code class="abc language-ruby xyz"><span class="comment"># comment</span></code></pre>' + CODERAY_POST
-
-      # Run filter
-      actual_output = filter.setup_and_run(input)
-      assert_equal(expected_output, actual_output)
-    end
-  end
-
-  def test_colorize_syntax_with_unknown_syntax
-    if_have 'coderay', 'nokogiri' do
-      # Create filter
-      filter = ::Nanoc::Filters::ColorizeSyntax.new
-
-      # Run filter
-      assert_raises RuntimeError do
-        filter.setup_and_run('<p>whatever</p>', syntax: :kasflwafhaweoineurl)
-      end
-    end
-  end
-
-  def test_colorize_syntax_with_xml
-    if_have 'coderay', 'nokogiri' do
-      # Create filter
-      filter = ::Nanoc::Filters::ColorizeSyntax.new
-
-      # Get input and expected output
-      input = '<p>foo<br/>bar</p>'
-      expected_output = '<p>foo<br/>bar</p>'
-
-      # Run filter
-      actual_output = filter.setup_and_run(input, syntax: :xml)
-      assert_equal(expected_output, actual_output)
-    end
-  end
-
-  def test_colorize_syntax_with_xhtml
-    if_have 'coderay', 'nokogiri' do
-      # Create filter
-      filter = ::Nanoc::Filters::ColorizeSyntax.new
-
-      # Get input and expected output
-      input = '<p>foo<br/>bar</p>'
-      expected_output = '<p>foo<br />bar</p>'
-
-      # Run filter
-      actual_output = filter.setup_and_run(input, syntax: :xhtml)
-      assert_equal(expected_output, actual_output)
-    end
-  end
-
-  def test_colorize_syntax_with_non_language_shebang_line
-    if_have 'coderay', 'nokogiri' do
-      # Create filter
-      filter = ::Nanoc::Filters::ColorizeSyntax.new
-
-      # Get input and expected output
-      input = <<~EOS
-        before
-        <pre><code>
-        #!/usr/bin/env ruby
-        puts 'hi!'
-        </code></pre>
-        after
-EOS
-      expected_output = <<~EOS.sub(/\s*\Z/m, '')
-        before
-        <pre><code>
-        #!/usr/bin/env ruby
-        puts 'hi!'
-        </code></pre>
-        after
-EOS
-
-      # Run filter
-      actual_output = filter.setup_and_run(input).sub(/\s*\Z/m, '')
-      assert_equal(expected_output, actual_output)
-    end
-  end
-
-  def test_colorize_syntax_with_non_language_shebang_line_and_language_line
-    if_have 'coderay', 'nokogiri' do
-      # Create filter
-      filter = ::Nanoc::Filters::ColorizeSyntax.new
-
-      # Get input and expected output
-      input = <<~EOS
-        before
-        <pre><code>
-        #!ruby
-        #!/usr/bin/env ruby
-        puts 'hi!'
-        </code></pre>
-        after
-EOS
-      expected_output = <<~EOS.sub(/\s*\Z/m, '')
-        before
-        #{CODERAY_PRE}<pre><code class=\"language-ruby\"><span class=\"doctype\">#!/usr/bin/env ruby</span>
-        puts <span class=\"string\"><span class=\"delimiter\">'</span><span class=\"content\">hi!</span><span class=\"delimiter\">'</span></span></code></pre>#{CODERAY_POST}
-        after
-EOS
-
-      # Run filter
-      actual_output = filter.setup_and_run(input).sub(/\s*\Z/m, '')
-      assert_equal(expected_output, actual_output)
-    end
-  end
-
-  def test_not_outside_pre
-    if_have 'coderay', 'nokogiri' do
-      # Create filter
-      filter = ::Nanoc::Filters::ColorizeSyntax.new
-
-      # Get input and expected output
-      input           = '<code class="language-ruby"># comment</code>'
-      expected_output = '<code class="language-ruby"># comment</code>'
-
-      # Run filter
-      actual_output = filter.setup_and_run(input, outside_pre: false)
-      assert_equal(expected_output, actual_output)
-    end
-  end
-
-  def test_outside_pre
-    if_have 'coderay', 'nokogiri' do
-      # Create filter
-      filter = ::Nanoc::Filters::ColorizeSyntax.new
-
-      # Get input and expected output
-      input           = '<code class="language-ruby"># comment</code>'
-      expected_output = '<code class="language-ruby"><span class="comment"># comment</span></code>'
-
-      # Run filter
-      actual_output = filter.setup_and_run(input, outside_pre: true)
-      assert_equal(expected_output, actual_output)
-    end
-  end
-
-  def test_strip
-    if_have 'coderay', 'nokogiri' do
-      # Create filter
-      filter = ::Nanoc::Filters::ColorizeSyntax.new
-
-      # Simple test
-      assert_equal '  bar', filter.send(:strip, "\n  bar")
-
-      # Get input and expected output
-      input = <<~EOS
-        before
-        <pre><code class="language-ruby">
-          def foo
-          end
-        </code></pre>
-        after
-EOS
-      expected_output = <<~EOS.sub(/\s*\Z/m, '')
-        before
-        #{CODERAY_PRE}<pre><code class="language-ruby">  <span class=\"keyword\">def</span> <span class=\"function\">foo</span>
-          <span class=\"keyword\">end</span></code></pre>#{CODERAY_POST}
-        after
-EOS
-
-      # Run filter
-      actual_output = filter.setup_and_run(input).sub(/\s*\Z/m, '')
-      assert_equal(expected_output, actual_output)
-    end
-  end
-end