nanoc3 3.2.4 → 3.3.0

data/test/extra/validators/test_links.rb

@@ -1,51 +0,0 @@
-# encoding: utf-8
-
-class Nanoc3::Extra::Validators::LinksTest < MiniTest::Unit::TestCase
-
-  include Nanoc3::TestHelpers
-
-  def test_is_external_href?
-    # Create validator
-    validator = Nanoc3::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 = Nanoc3::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 = Nanoc3::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
-
-end

data/test/extra/validators/test_w3c.rb

@@ -1,47 +0,0 @@
-# encoding: utf-8
-
-class Nanoc3::Extra::Validators::W3CTest < MiniTest::Unit::TestCase
-
-  include Nanoc3::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 = Nanoc3::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 = Nanoc3::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

@@ -1,22 +0,0 @@
-# encoding: utf-8
-
-class Nanoc3::Filters::AsciiDocTest < MiniTest::Unit::TestCase
-
-  include Nanoc3::TestHelpers
-
-  def test_filter
-    if_have 'systemu' do
-      if `which asciidoc`.strip.empty?
-        skip "could not find asciidoc"
-      end
-
-      # Create filter
-      filter = ::Nanoc3::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

@@ -1,18 +0,0 @@
-# encoding: utf-8
-
-class Nanoc3::Filters::BlueClothTest < MiniTest::Unit::TestCase
-
-  include Nanoc3::TestHelpers
-
-  def test_filter
-    if_have 'bluecloth' do
-      # Create filter
-      filter = ::Nanoc3::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

@@ -1,44 +0,0 @@
-# encoding: utf-8
-
-class Nanoc3::Filters::CodeRayTest < MiniTest::Unit::TestCase
-
-  include Nanoc3::TestHelpers
-
-  def test_filter_without_language
-    if_have 'coderay' do
-      # Get filter
-      filter = ::Nanoc3::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 = ::Nanoc3::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 = ::Nanoc3::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_colorize_syntax.rb

@@ -1,283 +0,0 @@
-# encoding: utf-8
-
-class Nanoc3::Filters::ColorizeSyntaxTest < MiniTest::Unit::TestCase
-
-  include Nanoc3::TestHelpers
-
-  def test_coderay_simple
-    if_have 'coderay', 'nokogiri' do
-      # Create filter
-      filter = ::Nanoc3::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_coderay_with_comment
-    if_have 'coderay', 'nokogiri' do
-      # Create filter
-      filter = ::Nanoc3::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 = ::Nanoc3::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 = ::Nanoc3::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 = ::Nanoc3::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_simon_highlight
-    if_have 'nokogiri', 'systemu' do
-      if `which highlight`.strip.empty?
-        skip "could not find `highlight`"
-      end
-
-      # Create filter
-      filter = ::Nanoc3::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 = ::Nanoc3::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 = ::Nanoc3::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 = ::Nanoc3::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 = ::Nanoc3::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 = ::Nanoc3::Filters::ColorizeSyntax.new
-
-        # Get input and expected output
-        input = '<pre><code class="language-ruby">puts "foo"</code></pre>'
-
-        # Run filter
-        [ :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 = ::Nanoc3::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 = ::Nanoc3::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_strip
-    if_have 'coderay', 'nokogiri' do
-      # Create filter
-      filter = ::Nanoc3::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