asciidoctor-doctest 1.5.0

data/spec/core_ext_spec.rb

@@ -0,0 +1,67 @@
+describe Enumerable do
+
+  describe '#map_send' do
+
+    it 'sends a message to each element and collects the result' do
+      expect([1, 2, 3].map_send(:+, 3)).to eq [4, 5, 6]
+    end
+  end
+end
+
+describe String do
+
+  describe '#concat' do
+
+    context 'without separator' do
+      subject { 'foo' }
+
+      it 'appends the given string to self' do
+        subject.concat 'bar'
+        is_expected.to eq 'foobar'
+      end
+    end
+
+    context 'with separator' do
+
+      context 'when self is empty' do
+        subject { '' }
+
+        it 'appends the given string to self' do
+          subject.concat 'bar', "\n"
+          is_expected.to eq 'bar'
+        end
+      end
+
+      context 'when self is not empty' do
+        subject { 'foo' }
+
+        it 'appends the given separator and string to self' do
+          subject.concat 'bar', "\n"
+          is_expected.to eq "foo\nbar"
+        end
+      end
+    end
+  end
+end
+
+
+describe Module do
+
+  describe '#alias_class_method' do
+
+    subject(:klass) do
+      Class.new do
+        def self.salute
+          'Meow!'
+        end
+      end
+    end
+
+    it 'defines new class method that calls the old class method' do
+      klass.alias_class_method :say_hello!, :salute
+
+      expect(klass).to respond_to :say_hello!
+      expect(klass.say_hello!).to eq klass.salute
+    end
+  end
+end

data/spec/html/examples_suite_spec.rb

@@ -0,0 +1,249 @@
+require 'active_support/core_ext/string/strip'
+
+describe DocTest::HTML::ExamplesSuite do
+  extend Forwardable
+
+  it_should_behave_like DocTest::BaseExamplesSuite
+
+  def_delegator :suite, :create_example
+
+  subject(:suite) { described_class.new }
+
+
+  describe '#initialize' do
+
+    it 'uses ".html" as default file_ext' do
+      expect(suite.file_ext).to eq '.html'
+    end
+  end
+
+
+  describe 'parsing/serialization:' do
+
+    context 'one example' do
+
+      shared_examples :example do
+        let(:parsed) { suite.parse input, 's' }
+        let(:serialized) { suite.serialize output }
+
+        it { (expect parsed).to have(1).items }
+
+        it 'returns an array with parsed example object' do
+          (expect parsed.first).to eql output
+        end
+
+        it 'returns a serialized example as string' do
+          (expect serialized).to eql input
+        end
+      end
+
+      context 'with name only' do
+        let(:input) { "<!-- .basic -->\n" }
+        let(:output) { create_example 's:basic' }
+
+        include_examples :example
+      end
+
+      context 'with multiline content' do
+        let :content do
+          <<-EOF.strip_heredoc
+            <p>Paragraphs don't require
+            any special markup.</p>
+
+            <p>To begin a new one, separate it by blank line.</p>
+          EOF
+        end
+
+        let(:input) { "<!-- .multiline -->\n#{content}" }
+        let(:output) { create_example 's:multiline', content: content.chomp }
+
+        include_examples :example
+      end
+
+      context 'with description' do
+        let :input do
+          <<-EOF.strip_heredoc
+            <!-- .strong
+            This is a description,
+            see?
+            -->
+            <strong>allons-y!</strong>
+          EOF
+        end
+
+        let :output do
+          create_example 's:strong', content: '<strong>allons-y!</strong>',
+            desc: "This is a description,\nsee?"
+        end
+        include_examples :example
+      end
+
+      context 'with options' do
+        let :input do
+          <<-EOF.strip_heredoc
+            <!-- .basic
+            :exclude: .//code
+            :exclude: .//section
+            :include: ./p/node()
+            -->
+            <p>dummy</p>
+          EOF
+        end
+
+        let :output do
+          create_example 's:basic', content: '<p>dummy</p>', opts: {
+            exclude: ['.//code', './/section'],
+            include: ['./p/node()']
+          }
+        end
+        include_examples :example
+      end
+
+      context 'with boolean option' do
+        let(:input) { "<!-- .basic\n:header_footer:\n-->\n" }
+        let(:output) { create_example 's:basic', opts: { header_footer: true } }
+
+        include_examples :example
+      end
+
+      context 'with description and options' do
+        let :input do
+          <<-EOF.strip_heredoc
+            <!-- .basic
+            This is a description.
+            :exclude: .//code
+            :header_footer:
+            -->
+          EOF
+        end
+
+        let :output do
+          create_example 's:basic', desc: 'This is a description.', opts: {
+            exclude: ['.//code'],
+            header_footer: true
+          }
+        end
+        include_examples :example
+      end
+    end
+
+    context 'multiple examples' do
+      let :input do
+        <<-EOF.strip_heredoc
+          <!-- .basic -->
+          http://asciidoctor.org
+
+          <!-- .xref -->
+          Refer to <<section-a>>.
+        EOF
+      end
+
+      subject(:parsed) { suite.parse input, 's' }
+
+      it { is_expected.to have(2).items }
+
+      it 'returns an array with parsed Example objects' do
+        expect(parsed[0]).to eql create_example('s:basic', content: 'http://asciidoctor.org')
+        expect(parsed[1]).to eql create_example('s:xref', content: 'Refer to <<section-a>>.')
+      end
+    end
+  end
+
+
+  describe '#convert_example' do
+
+    let(:input) { create_example 's:dummy', content: '*chunky* bacon' }
+    let(:opts) { {dummy: 'value'} }
+    let(:renderer) { double 'AsciidocRenderer' }
+    let(:renderer_opts) { {header_footer: false} }
+
+    subject(:result) { suite.convert_example input, opts, renderer }
+
+    let :rendered do
+      <<-EOF
+        <section>
+          <h1>Title</h1>
+          <div>
+            <p><b>Chunky</b> bacon</p>
+          </div>
+          <code>meh</code>
+        </section>
+        <div>
+          <p>why?</p>
+        </div>
+      EOF
+    end
+
+    before do
+      expect(renderer).to receive(:render)
+        .with(input.content, renderer_opts).and_return(rendered)
+    end
+
+    it 'returns instance of HTML::Example' do
+      is_expected.to be_instance_of DocTest::HTML::Example
+    end
+
+    it 'returns Example with the same name as input_example' do
+      expect(result.name).to eq input.name
+    end
+
+    it 'returns Example with the given opts' do
+      expect(result.opts).to eq opts
+    end
+
+    context 'with :exclude option' do
+      let(:opts) { {exclude: ['.//p', './/code']} }
+
+      it 'returns content without HTML (sub)elements specified by XPath' do
+        expect(result.content.gsub(/\s*/, '')).to eq \
+          '<section><h1>Title</h1><div></div></section><div></div>'
+      end
+    end
+
+    context 'with :include option' do
+      let(:opts) { {include: ['.//p']} }
+
+      it 'returns content with only HTML (sub)elements specified by XPath' do
+        expect(result.content.gsub(/\s*/, '')).to eq '<p><b>Chunky</b>bacon</p><p>why?</p>'
+      end
+    end
+
+    context 'with :header_footer option' do
+      let(:opts) { {header_footer: true} }
+
+      it 'renders content with :header_footer => true' do
+        suite.convert_example input, {}, renderer
+      end
+    end
+
+    context 'with example named /^document.*/' do
+      let(:input) { create_example 'document:dummy', content: '*chunky* bacon' }
+      let(:renderer_opts) { {header_footer: true} }
+
+      it 'renders content with :header_footer => true' do
+        suite.convert_example input, {}, renderer
+      end
+    end
+
+    context 'with example named /inline_.*/' do
+      let(:input) { create_example 'inline_quoted:dummy', content: '*chunky* bacon' }
+      let(:rendered) { '<p><b>chunky</b> bacon</p>' }
+
+      it 'returns content without top-level <p> tags' do
+        expect(result.content).to eq '<b>chunky</b> bacon'
+      end
+
+      it 'does not add implicit include into returned example' do
+        expect(result.opts).to_not include :include
+      end
+
+      context 'with :include option' do
+        let(:opts) { {include: ['.//b']} }
+
+        it 'preferes the include option' do
+          expect(result.content).to eq '<b>chunky</b>'
+        end
+      end
+    end
+  end
+end

data/spec/html/normalizer_spec.rb

@@ -0,0 +1,70 @@
+describe DocTest::HTML::Normalizer do
+
+  [Nokogiri::HTML::Document, Nokogiri::HTML::DocumentFragment].each do |klass|
+    it "HtmlNormalizer should be included in #{klass}" do
+      expect(klass).to have_method :normalize!
+    end
+  end
+
+  describe 'normalize!' do
+
+    it 'sorts attributes by name' do
+      output = normalize '<img src="tux.png" width="60" height="100" alt="Tux!">'
+      expect(output).to eq '<img alt="Tux!" height="100" src="tux.png" width="60">'
+    end
+
+    it 'removes all blank text nodes' do
+      output = normalize "  <section>\n  <p>Lorem ipsum</p>\n\t</section>\n\n"
+      expect(output).to eq '<section><p>Lorem ipsum</p></section>'
+    end
+
+    context 'in "style" attribute' do
+
+      it 'sorts CSS declarations by name' do
+        output = normalize %(<div style="width: 100%; color: 'red'; font-style: bold"></div>)
+        expect(output).to eq %(<div style="color: 'red'; font-style: bold; width: 100%;"></div>)
+      end
+    end
+
+    context 'in text node' do
+
+      it 'strips nonsignificant leading and trailing whitespaces' do
+        output = normalize "<p> Lorem<b> ipsum</b> dolor\n<br> sit <i>amet</i></p>"
+        expect(output).to eq '<p>Lorem<b> ipsum</b> dolor<br>sit <i>amet</i></p>'
+      end
+
+      it 'strips nonsignificant repeated whitespaces' do
+        output = normalize "<p>Lorem   ipsum\t\tdolor</p>"
+        expect(output).to eq "<p>Lorem ipsum\tdolor</p>"
+      end
+
+      it 'replaces newlines with spaces' do
+        output = normalize "<p>Lorem\nipsum\n\ndolor</p>"
+        expect(output).to eq '<p>Lorem ipsum dolor</p>'
+      end
+    end
+
+    context 'in preformatted node or descendant' do
+
+      it 'does not strip leading and trailing whitespaces' do
+        input = "<pre> Lorem<b> ipsum</b> dolor\n<br> sit amet</pre>"
+        expect(normalize(input)).to eq input
+      end
+
+      it 'does not strip repeated whitespaces' do
+        input = "<pre>Lorem   ipsum\t\tdolor\n<code>sit   amet</code></pre>"
+        output = normalize input
+        expect(output).to eq input
+      end
+
+      it 'does not replace newlines with spaces' do
+        input = "<pre>Lorem\n<code>\nipsum</code>\n\ndolor</pre>"
+        expect(normalize(input)).to eq input
+      end
+    end
+  end
+
+  def normalize(input)
+    Nokogiri::HTML.fragment(input).normalize!.to_s
+  end
+end

data/spec/shared_examples/base_examples_suite.rb

@@ -0,0 +1,262 @@
+require 'active_support/core_ext/array/access'
+require 'fileutils'
+require 'forwardable'
+require 'fakefs/spec_helpers'
+
+module FakeFS
+  # XXX remove after merging of https://github.com/defunkt/fakefs/pull/270
+  module FileTest
+
+    def readable?(file_name)
+      File.readable?(file_name)
+    end
+    module_function :readable?
+  end
+
+  # XXX remove after merging of https://github.com/defunkt/fakefs/pull/269
+  class Pathname
+    def read(*args)
+      File.read(@path, *args)
+    end
+  end
+end
+
+
+shared_examples DocTest::BaseExamplesSuite do
+  extend Forwardable
+
+  def_delegator :suite, :create_example
+
+  subject(:suite) { described_class.new(file_ext: '.adoc', examples_path: ex_path) }
+  let(:ex_path) { ['/tmp/alpha', '/tmp/beta'] }
+
+
+  describe '#parse' do
+    context 'empty file' do
+      subject { suite.parse '', 'block_ulist' }
+
+      it { is_expected.to be_empty }
+    end
+  end
+
+
+  describe '#read_examples' do
+    include FakeFS::SpecHelpers
+
+    subject(:result) { suite.read_examples group_name }
+
+    let(:group_name) { 'section' }
+
+    before do
+      ex_path.each { |p| FileUtils.mkpath p }
+      create_and_write_group ex_path.first, 'noise', '.adoc', 'foo', 'bar'
+
+      allow(suite).to receive(:parse) do |input, group_name|
+        path, file_name, *example_names = input.split("\n")
+        expect(group_name).to eq file_name.split('.').first
+
+        example_names.map do |name|
+          # this content is just filling to identify the example in test
+          create_example [group_name, name], content: "#{path}/#{file_name}:#{name}"
+        end
+      end
+    end
+
+    context "when the group's file is not found" do
+      it { is_expected.to be_empty }
+    end
+
+    context "when the group's file has a wrong file extension" do
+      before do
+        create_and_write_group ex_path.first, group_name, '.html', 'level1', 'level2'
+      end
+
+      it { is_expected.to be_empty }
+    end
+
+    context 'when single group file is found' do
+      let! :examples do
+        create_and_write_group ex_path.second, group_name, '.adoc', 'level1', 'level2'
+      end
+
+      it 'returns parsed examples' do
+        is_expected.to eq examples
+      end
+    end
+
+    context 'when multiple group files are found and contains example with same name' do
+      let! :examples do
+        first = create_and_write_group ex_path.first, group_name, '.adoc', 'level1', 'level2'
+        second = create_and_write_group ex_path.second, group_name, '.adoc', 'level2', 'level3'
+        [*first, second[1]]
+      end
+
+      it 'returns parsed examples without duplicates (first wins)' do
+        is_expected.to eq examples
+      end
+    end
+  end
+
+
+  describe '#write_examples' do
+    include FakeFS::SpecHelpers
+
+    let :examples do
+      (1..2).map { |i| create_example "section:level#{i}", content: 'yada' }
+    end
+
+    before { ex_path.each { |p| FileUtils.mkpath p } }
+
+    it 'writes serialized examples to file named after the group with file extension' do
+      expect(suite).to receive :serialize do |exmpls|
+        exmpls.map(&:name).join("\n")
+      end
+      suite.write_examples examples
+
+      file = File.read "#{ex_path.first}/section.adoc"
+      expect(file).to eq examples.map(&:name).join("\n")
+    end
+  end
+
+
+  describe '#file_names' do
+    include FakeFS::SpecHelpers
+
+    subject(:result) { suite.group_names }
+
+    before { ex_path.each { |p| FileUtils.mkpath p } }
+
+    context 'when no file is found' do
+      it { is_expected.to be_empty }
+    end
+
+    it 'returns names of files with matching file extension only' do
+      %w[block_image.html block_ulist.adoc].each do |name|
+        File.write "#{ex_path.first}/#{name}", 'yada'
+      end
+      is_expected.to contain_exactly 'block_ulist'
+    end
+
+    it 'returns names sorted and deduplicated' do
+      (names = %w[z j d c k d]).each_with_index do |name, i|
+        File.write "#{ex_path[i % 2]}/#{name}.adoc", 'yada'
+      end
+
+      is_expected.to eq names.uniq.sort
+    end
+
+    it 'ignores directories and files in subdirectories' do
+      Dir.mkdir "#{ex_path.first}/invalid.adoc"
+      File.write "#{ex_path.first}/invalid.adoc/wat.adoc", 'yada'
+
+      is_expected.to be_empty
+    end
+  end
+
+
+  describe '#update_examples' do
+
+    let :current do
+      %w[gr0:ex0 gr0:ex1 gr1:ex0 gr1:ex1].map do |name|
+        create_example name, content: name.reverse
+      end
+    end
+    let :updated do
+      [ (create_example 'gr0:ex0', content: 'allons-y!'),
+        (create_example 'gr1:ex1', content: 'allons-y!') ]
+    end
+
+    before do
+      expect(suite).to receive(:read_examples).exactly(2).times do |group_name|
+        current.select { |e| e.group_name == group_name }
+      end
+    end
+
+    it 'merges current and updated examples and writes them' do
+      is_expected.to receive(:write_examples).with [updated[0], current[1]]
+      is_expected.to receive(:write_examples).with [current[2], updated[1]]
+
+      suite.update_examples updated
+    end
+  end
+
+
+  describe '#pair_with' do
+
+    subject(:result) { ours_suite.pair_with(theirs_suite).to_a }
+    let(:result_names) { result.map(&:first).map(&:name) }
+
+    let(:ours_suite) { described_class.new(file_ext: '.xyz') }
+    let(:theirs_suite) { DocTest::Asciidoc::ExamplesSuite.new(file_ext: '.adoc') }
+
+    def ours_exmpl(suffix, group = 0)
+      ours_suite.create_example "gr#{group}:ex#{suffix}", content: 'ours!'
+    end
+
+    def theirs_exmpl(suffix, group = 0)
+      theirs_suite.create_example "gr#{group}:ex#{suffix}", content: 'theirs!'
+    end
+
+    before do
+      expect(ours_suite).to receive(:group_names)
+        .and_return(['gr0', 'gr1'])
+      expect(theirs_suite).to receive(:read_examples)
+        .with(/gr[0-1]/).exactly(:twice).and_return(*theirs)
+      expect(ours_suite).to receive(:read_examples)
+        .with(/gr[0-1]/).exactly(:twice).and_return(*ours)
+    end
+
+    context do
+      let :ours do
+        [ [ ours_exmpl(0, 0), ours_exmpl(1, 0) ], [ ours_exmpl(0, 1), ours_exmpl(1, 1) ] ]
+      end
+      let :theirs do
+        [ [ theirs_exmpl(1, 0), theirs_exmpl(0, 0) ], [ theirs_exmpl(0, 1), theirs_exmpl(1, 1) ] ]
+      end
+
+      it 'returns pairs of ours/theirs examples in ours order' do
+        expect(result_names).to eq %w[gr0:ex0 gr0:ex1 gr1:ex0 gr1:ex1]
+        expect(result).to eq ours.flatten(1).zip theirs.flatten(1).sort_by(&:name)
+      end
+    end
+
+    context 'when some example is missing' do
+      let(:ours) { [(0..2).map { |i| ours_exmpl i }, []] }
+      let(:theirs) { [[1, 0, 2].map { |i| theirs_exmpl i }, []] }
+
+      context 'in theirs suite' do
+        let(:theirs) { [ [theirs_exmpl(2), theirs_exmpl(0)], [] ] }
+
+        it 'returns pairs in ours order' do
+          expect(result_names).to eq %w[gr0:ex0 gr0:ex1 gr0:ex2]
+        end
+
+        it 'replaces the missing example with empty one with the name' do
+          expect(result.second.last).to eq theirs_suite.create_example 'gr0:ex1'
+        end
+      end
+
+      context 'in ours suite' do
+        let(:ours) { [ [ours_exmpl(1), ours_exmpl(2)], [] ] }
+
+        it 'returns pairs in ours order with the missing example at the end' do
+          expect(result_names).to eq %w[gr0:ex1 gr0:ex2 gr0:ex0]
+        end
+
+        it 'replaces the missing example with empty one with the name' do
+          expect(result.last.first).to eq ours_suite.create_example 'gr0:ex0'
+        end
+      end
+    end
+  end
+
+
+  def create_and_write_group(path, group_name, file_ext, *examples)
+    content = [path, group_name + file_ext, *examples].join("\n")
+    File.write File.join(path, group_name + file_ext), content
+
+    examples.map do |name|
+      create_example [group_name, name], content: "#{path}/#{group_name}#{file_ext}:#{name}"
+    end
+  end
+end