nanoc 3.2.4 → 3.3.0

data/test/extra/test_file_proxy.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+class Nanoc::Extra::FileProxyTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_create_many
+    if_implemented do
+      # Create test file
+      File.open('test.txt', 'w') { |io| }
+
+      # Create lots of file proxies
+      count = Process.getrlimit(Process::RLIMIT_NOFILE)[0] + 5
+      file_proxies = []
+      count.times { file_proxies << Nanoc::Extra::FileProxy.new('test.txt') }
+    end
+  end
+
+end

data/test/extra/test_vcs.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+class Nanoc::Extra::VCSTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_named
+    assert_nil(Nanoc::Extra::VCS.named(:lkasjdlkfjlkasdfkj))
+
+    refute_nil(Nanoc::Extra::VCS.named(:svn))
+    refute_nil(Nanoc::Extra::VCS.named(:subversion))
+  end
+
+  def test_not_implemented
+    vcs = Nanoc::Extra::VCS.new
+
+    assert_raises(NotImplementedError) { vcs.add('x')       }
+    assert_raises(NotImplementedError) { vcs.remove('x')    }
+    assert_raises(NotImplementedError) { vcs.move('x', 'y') }
+  end
+
+end

data/test/extra/validators/test_links.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+class Nanoc::Extra::Validators::LinksTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_is_external_href?
+    # Create validator
+    validator = Nanoc::Extra::Validators::Links.new(nil, nil)
+
+    # Test
+    assert  validator.send(:is_external_href?, 'http://example.com/')
+    assert  validator.send(:is_external_href?, 'https://example.com/')
+    assert  validator.send(:is_external_href?, 'mailto:bob@example.com')
+    assert !validator.send(:is_external_href?, '../stuff')
+    assert !validator.send(:is_external_href?, '/stuff')
+  end
+
+  def test_is_valid_internal_href?
+    # Create files
+    FileUtils.mkdir_p('output')
+    FileUtils.mkdir_p('output/stuff')
+    File.open('output/origin',     'w') { |io| io.write('hi') }
+    File.open('output/foo',        'w') { |io| io.write('hi') }
+    File.open('output/stuff/blah', 'w') { |io| io.write('hi') }
+
+    # Create validator
+    validator = Nanoc::Extra::Validators::Links.new('output', [ 'index.html' ])
+
+    # Test
+    assert validator.send(:is_valid_internal_href?, 'foo',         'output/origin')
+    assert validator.send(:is_valid_internal_href?, 'origin',      'output/origin')
+    assert validator.send(:is_valid_internal_href?, 'stuff/blah',  'output/origin')
+    assert validator.send(:is_valid_internal_href?, '/foo',        'output/origin')
+    assert validator.send(:is_valid_internal_href?, '/origin',     'output/origin')
+    assert validator.send(:is_valid_internal_href?, '/stuff/blah', 'output/origin')
+  end
+
+  def test_is_valid_external_href?
+    # Create validator
+    validator = Nanoc::Extra::Validators::Links.new('output', [ 'index.html' ])
+    validator.stubs(:fetch_http_status_for).returns(200)
+
+    # Test
+    assert validator.send(:is_valid_external_href?, 'http://example.com/')
+    assert validator.send(:is_valid_external_href?, 'https://example.com/')
+    assert validator.send(:is_valid_external_href?, 'foo://example.com/')
+    refute validator.send(:is_valid_external_href?, 'http://example.com/">')
+  end
+
+  def test_fetch_http_status_for
+    # Create validator
+    validator = Nanoc::Extra::Validators::Links.new('output', [ 'index.html' ])
+
+    # Test
+    assert validator.send(:fetch_http_status_for, URI.parse('http://heise.de/'), 200)
+    assert validator.send(:fetch_http_status_for, URI.parse('https://www.google.com/'), 200)
+    assert validator.send(:fetch_http_status_for, URI.parse('https://google.com/'), 200)
+    assert validator.send(:fetch_http_status_for, URI.parse('http://google.com/foo/bar'), 404)
+  end
+
+end

data/test/extra/validators/test_w3c.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+class Nanoc::Extra::Validators::W3CTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_simple
+    if_have 'w3c_validators' do
+      # Create some sample files
+      %w{ foo bar baz }.each do |filename|
+        %w{ xxx yyy }.each do |extension|
+          File.open("#{filename}.#{extension}", 'w') { |io| io.write("hello") }
+        end
+      end
+
+      # Create validator
+      w3c = Nanoc::Extra::Validators::W3C.new('.', [ :xxx ])
+
+      # Configure expectations
+      validator_result = mock
+      validator_result.expects(:errors).times(3)
+      validator = mock
+      validator.expects(:validate_file).times(3).returns(validator_result)
+      w3c.expects(:types_to_extensions).with([ :xxx ]).returns([ 'xxx' ])
+      w3c.expects(:validator_for).with('xxx').times(3).returns(validator)
+      w3c.expects(:validation_started).times(3)
+      w3c.expects(:validation_ended).times(3)
+
+      # Run
+      w3c.run
+    end
+  end
+
+  def test_with_unknown_types
+    if_have 'w3c_validators' do
+      # Create validator
+      w3c = Nanoc::Extra::Validators::W3C.new('.', [ :foo ])
+
+      # Test
+      exception = assert_raises RuntimeError do
+        w3c.run
+      end
+      assert_equal 'unknown type: foo', exception.message
+    end
+  end
+
+end

data/test/filters/test_asciidoc.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+class Nanoc::Filters::AsciiDocTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_filter
+    if_have 'systemu' do
+      if `which asciidoc`.strip.empty?
+        skip "could not find asciidoc"
+      end
+
+      # Create filter
+      filter = ::Nanoc::Filters::AsciiDoc.new
+
+      # Run filter
+      result = filter.run("== Blah blah")
+      assert_match %r{<h2 id="_blah_blah">Blah blah</h2>}, result
+    end
+  end
+
+end

data/test/filters/test_bluecloth.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+class Nanoc::Filters::BlueClothTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_filter
+    if_have 'bluecloth' do
+      # Create filter
+      filter = ::Nanoc::Filters::BlueCloth.new
+
+      # Run filter
+      result = filter.run("> Quote")
+      assert_match %r{<blockquote>\s*<p>Quote</p>\s*</blockquote>}, result
+    end
+  end
+
+end

data/test/filters/test_coderay.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+class Nanoc::Filters::CodeRayTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_filter_without_language
+    if_have 'coderay' do
+      # Get filter
+      filter = ::Nanoc::Filters::CodeRay.new
+
+      # Run filter
+      code = "def some_function ; x = blah.foo ; x.bar 'xyzzy' ; end"
+      assert_raises(ArgumentError) do
+        filter.run(code)
+      end
+    end
+  end
+
+  def test_filter_with_known_language
+    if_have 'coderay' do
+      # Get filter
+      filter = ::Nanoc::Filters::CodeRay.new
+
+      # Run filter
+      code = "def some_function ; x = blah.foo ; x.bar 'xyzzy' ; end"
+      result = filter.run(code, :language => 'ruby')
+      assert_match %r{^<span class="keyword">def</span> <span class="function">some_function</span>}, result
+    end
+  end
+
+  def test_filter_with_unknown_language
+    if_have 'coderay' do
+      # Get filter
+      filter = ::Nanoc::Filters::CodeRay.new
+
+      # Run filter
+      code = "def some_function ; x = blah.foo ; x.bar 'xyzzy' ; end"
+      result = filter.run(code, :language => 'skldfhjsdhfjszfnocmluhfixfmersumulh')
+      assert_equal code, result
+    end
+  end
+
+end

data/test/filters/test_coffeescript.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+class Nanoc::Filters::CoffeeScriptTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_filter
+    if_have 'coffee-script' do
+      # Create filter
+      filter = ::Nanoc::Filters::CoffeeScript.new
+
+      # Run filter (no assigns)
+      result = filter.run('alert 42')
+      assert_equal("(function() { alert(42); }).call(this); ", result.gsub(/\s+/, ' '))
+    end
+  end
+
+end

data/test/filters/test_colorize_syntax.rb

@@ -0,0 +1,379 @@
+# encoding: utf-8
+
+class Nanoc::Filters::ColorizeSyntaxTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  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 = '<pre title="moo"><code class="language-ruby"><span class="comment"># comment</span></code></pre>'
+
+      # Run filter
+      actual_output = filter.run(input)
+      assert_equal(expected_output, actual_output)
+    end
+  end
+
+  def test_dummy
+    if_have '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 = input # because we are using a dummy
+
+      # Run filter
+      actual_output = filter.run(input, :default_colorizer => :dummy)
+      assert_equal(expected_output, actual_output)
+    end
+  end
+
+  def test_full_page
+    if_have 'nokogiri' do
+      # Create filter
+      filter = ::Nanoc::Filters::ColorizeSyntax.new
+
+      # Get input and expected output
+      input = <<EOS
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Foo</title>
+  </head>
+  <body>
+    <pre title="moo"><code class="language-ruby"># comment</code></pre>
+  </body>
+</html>
+EOS
+      expected_output = <<EOS
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">
+<title>Foo</title>
+</head>
+<body>
+    <pre title="moo"><code class="language-ruby"># comment</code></pre>
+  </body>
+</html>
+EOS
+
+      # Run filter
+      actual_output = filter.run(input, :default_colorizer => :dummy, :is_fullpage => true)
+      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\n# comment</code></pre>]
+      expected_output = '<pre title="moo"><code class="language-ruby"><span class="comment"># comment</span></code></pre>'
+
+      # Run filter
+      actual_output = filter.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\n# comment</code></pre>]
+      expected_output = %[<pre title="moo"><code class="language-ruby"><span class="doctype">#!ruby</span>\n<span class="comment"># comment</span></code></pre>]
+
+      # Run filter
+      actual_output = filter.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 = '<pre title="moo"><code class="abc language-ruby xyz"><span class="comment"># comment</span></code></pre>'
+
+      # Run filter
+      actual_output = filter.run(input)
+      assert_equal(expected_output, actual_output)
+    end
+  end
+
+  def test_pygmentize
+    if_have 'nokogiri', 'systemu' do
+      if `which pygmentize`.strip.empty?
+        skip "could not find pygmentize"
+      end
+
+      # 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 = '<pre title="moo"><code class="language-ruby"><span class="c1"># comment</span></code></pre>'
+
+      # Run filter
+      actual_output = filter.run(input, :colorizers => { :ruby => :pygmentize })
+      assert_equal(expected_output, actual_output)
+    end
+  end
+
+  def test_pygmentsrb
+    if_have 'pygments', '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 = '<pre title="moo"><code class="language-ruby"><span class="c1"># comment…</span></code></pre>'
+
+      # Run filter
+      actual_output = filter.run(input, :colorizers => { :ruby => :pygmentsrb })
+      assert_equal(expected_output, actual_output)
+    end
+  end
+
+  def test_simon_highlight
+    if_have 'nokogiri', 'systemu' do
+      if `which highlight`.strip.empty?
+        skip "could not find `highlight`"
+      end
+
+      # Create filter
+      filter = ::Nanoc::Filters::ColorizeSyntax.new
+
+      # Get input and expected output
+      input = %Q[<pre title="moo"><code class="language-ruby">\n# comment\n</code></pre>]
+      expected_output = '<pre title="moo"><code class="language-ruby"><span class="hl slc"># comment</span></code></pre>'
+
+      # Run filter
+      actual_output = filter.run(input, :default_colorizer => :simon_highlight)
+      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.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.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.run(input, :syntax => :xhtml)
+      assert_equal(expected_output, actual_output)
+    end
+  end
+
+  def test_colorize_syntax_with_default_colorizer
+    if `which pygmentize`.strip.empty?
+      skip 'no pygmentize found, which is required for this test'
+      return
+    end
+
+    if_have 'nokogiri', 'systemu' do
+      # Create filter
+      filter = ::Nanoc::Filters::ColorizeSyntax.new
+
+      # Get input and expected output
+      input = '<pre><code class="language-ruby">puts "foo"</code></pre>'
+      expected_output = '<pre><code class="language-ruby"><span class="nb">puts</span> <span class="s2">"foo"</span></code></pre>'
+
+      # Run filter
+      actual_output = filter.run(input, :default_colorizer => :pygmentize)
+      assert_equal(expected_output, actual_output)
+    end
+  end
+
+  def test_colorize_syntax_with_missing_executables
+    if_have 'nokogiri', 'systemu' do
+      begin
+        original_path = ENV['PATH']
+        ENV['PATH'] = './blooblooblah'
+
+        # Create filter
+        filter = ::Nanoc::Filters::ColorizeSyntax.new
+
+        # Get input and expected output
+        input = '<pre><code class="language-ruby">puts "foo"</code></pre>'
+
+        # Run filter
+        [ :albino, :pygmentize, :simon_highlight ].each do |colorizer|
+          begin
+            input = '<pre><code class="language-ruby">puts "foo"</code></pre>'
+            actual_output = filter.run(
+              input,
+              :colorizers => { :ruby => colorizer })
+            flunk "expected colorizer to raise if no executable is available"
+          rescue => e
+          end
+        end
+      ensure
+        ENV['PATH'] = original_path
+      end
+    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
+before
+<pre><code>
+#!/usr/bin/env ruby
+puts 'hi!'
+</code></pre>
+after
+EOS
+
+      # Run filter
+      actual_output = filter.run(input)
+      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
+before
+<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>
+after
+EOS
+
+      # Run filter
+      actual_output = filter.run(input)
+      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.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.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
+before
+<pre><code class="language-ruby">  <span class=\"keyword\">def</span> <span class=\"function\">foo</span>
+  <span class=\"keyword\">end</span></code></pre>
+after
+EOS
+
+      # Run filter
+      actual_output = filter.run(input)
+      assert_equal(expected_output, actual_output)
+    end
+  end
+
+end