asciidoctor-doctest 2.0.0.beta.4 → 2.0.0.beta.5

data/spec/minitest_diffy_spec.rb

@@ -1,59 +0,0 @@
-require 'asciidoctor/doctest/minitest_diffy'
-require 'corefines'
-
-using Corefines::String::color
-
-describe Diffy::Format do
-
-  describe '#minitest' do
-
-    subject(:output) { input.minitest }
-    let(:input) { [] }
-
-    # This looks odd, but Diffy is actually using Format exactly like that.
-    # https://github.com/samg/diffy/blob/6e1f1312/lib/diffy/diff.rb#L132
-    before { input.extend described_class }
-
-    it { expect(described_class).to have_method :minitest }
-
-    context 'line starting with ---, or +++' do
-      let(:input) { ['--- a/file.rb', '+++ b/file.rb'] }
-
-      it 'discards the line' do
-        expect(output.chomp).to be_empty
-      end
-    end
-
-    context 'line with ""' do
-      let(:input) { [''] }
-
-      it 'discards this line' do
-        expect(output.chomp).to be_empty
-      end
-    end
-
-    context 'line starting with +' do
-      let(:input) { ['+ <div><p>chunky bacon</p></div>'] }
-
-      it 'replaces "+" with "A", adds padding and colour' do
-        is_expected.to eq "\n" + 'A   <div><p>chunky bacon</p></div>'.color(:red)
-      end
-    end
-
-    context 'line starting with -' do
-      let(:input) { ['- <p>chunky bacon</p>'] }
-
-      it 'replaces "-" with "E", adds padding and colour' do
-        is_expected.to eq "\n" + 'E   <p>chunky bacon</p>'.color(:green)
-      end
-    end
-
-    context 'normal lines' do
-      let(:input) { ['Lorem ipsum dolor', '  sit amet'] }
-
-      it 'returns the lines with padding' do
-        is_expected.to eq "\n  Lorem ipsum dolor\n    sit amet"
-      end
-    end
-  end
-end

data/spec/no_fallback_template_converter_spec.rb

@@ -1,38 +0,0 @@
-describe DocTest::NoFallbackTemplateConverter do
-
-  subject(:delegator) { described_class.new('html5', template_dirs: ['/tmp/html5']) }
-
-  describe '#convert' do
-
-    let(:converter) { delegator.__getobj__ }
-    let(:node) { double('Node', node_name: 'block_foo') }
-
-    before do
-      expect(converter).to receive(:handles?).with('block_foo').and_return(handles)
-    end
-
-    context 'when template is not found' do
-      let(:handles) { false }
-
-      it 'returns a not found marker instead of converted node' do
-        expect(converter).to_not receive(:convert)
-        expect(delegator.convert node).to eq described_class::NOT_FOUND_MARKER
-      end
-
-      it 'prints a warning on stderr' do
-        expect { delegator.convert node }.to output(/Could not find a custom template/i).to_stderr
-      end
-    end
-
-    context 'when template is found' do
-      let(:handles) { true }
-
-      it 'delegates to the original #convert and returns result' do
-        expect(converter).to receive(:convert)
-          .with(node, 'block_foo', {}).and_return('allons-y!')
-
-        expect(delegator.convert node).to eq 'allons-y!'
-      end
-    end
-  end
-end

data/spec/shared_examples/base_examples.rb

@@ -1,289 +0,0 @@
-require 'fileutils'
-require 'forwardable'
-
-using Corefines::Array::second
-
-shared_examples DocTest::IO::Base do
-
-  subject(:suite) { described_class.new(file_ext: '.adoc', path: path) }
-  let(:path) { ['/tmp/alpha', '/tmp/beta'] }
-
-
-  describe '#initialize' do
-
-    subject(:init) { described_class.new(args) }
-    let(:args) { {} }
-
-    {'nil' => nil, 'blank' => ' '}.each do |desc, file_ext|
-      context "with file_ext #{desc}" do
-        let(:args) { {file_ext: file_ext, path: path} }
-        it { expect { init }.to raise_error ArgumentError }
-      end
-    end
-
-    context 'with path string' do
-      let(:args) { {file_ext: '.html', path: '/foo/bar'} }
-
-      it 'wraps string to array' do
-        is_expected.to have_attributes(path: ['/foo/bar'])
-      end
-    end
-  end
-
-
-  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
-      path.each { |p| FileUtils.mkpath p }
-      create_and_write_group 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 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 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 path.first, group_name, '.adoc', 'level1', 'level2'
-        second = create_and_write_group 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 { 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 "#{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 { 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 "#{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 "#{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 "#{path.first}/invalid.adoc"
-      File.write "#{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::IO::Asciidoc.new(file_ext: '.adoc') }
-
-    def ours_exmpl(suffix, group = 0)
-      create_example "gr#{group}:ex#{suffix}", content: 'ours!'
-    end
-
-    def theirs_exmpl(suffix, group = 0)
-      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 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 create_example 'gr0:ex0'
-        end
-      end
-    end
-  end
-
-
-  describe '#format_options' do
-
-    shared_examples :format_options do |input, output|
-      it "returns #{output} for #{input}" do
-        expect(suite.send(:format_options, input)).to eq output
-      end
-    end
-
-    context 'empty' do
-      include_examples :format_options, {}, []
-    end
-
-    context 'options with one value' do
-      include_examples :format_options, {opt1: 'val1', opt2: 'val2'}, [':opt1: val1', ':opt2: val2']
-    end
-
-    context 'options with multiple values' do
-      include_examples :format_options, {opt1: %w[val11 val12], opt2: ['val2']},
-                       [':opt1: val11', ':opt1: val12', ':opt2: val2']
-    end
-
-    context 'boolean options' do
-      include_examples :format_options, {opt1: true, opt2: false}, [':opt1:', ':opt2: false']
-    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

data/spec/spec_helper.rb

@@ -1,39 +0,0 @@
-require 'corefines'
-require 'rspec/collection_matchers'
-require 'simplecov'
-require 'asciidoctor/doctest'
-require 'fakefs/spec_helpers'
-
-Dir['./spec/{shared_examples,support}/**/*.rb'].each { |file| require file }
-
-RSpec.configure do |config|
-
-  # rspec-expectations config
-  config.expect_with :rspec do |expects|
-
-    # This option disables deprecated 'should' syntax.
-    expects.syntax = :expect
-
-    # This option makes the +description+ and +failure_message+ of custom
-    # matchers include text for helper methods defined using +chain+, e.g.:
-    # be_bigger_than(2).and_smaller_than(4).description
-    #   # => "be bigger than 2 and smaller than 4"
-    # ...rather than:
-    #   # => "be bigger than 2"
-    expects.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  # rspec-mocks config
-  config.mock_with :rspec do |mocks|
-
-    # Prevents you from mocking or stubbing a method that does not exist on
-    # a real object.
-    mocks.verify_partial_doubles = true
-  end
-
-  config.color = true
-end
-
-def create_example(*args)
-  DocTest::Example.new(*args)
-end

data/spec/support/matchers.rb

@@ -1,7 +0,0 @@
-require 'rspec/expectations'
-
-RSpec::Matchers.define :have_method do |*names|
-  match do |klass|
-    names.all? { |name| klass.method_defined? name }
-  end
-end

data/spec/tester_spec.rb

@@ -1,153 +0,0 @@
-describe DocTest::Tester do
-
-  subject(:tester) { described_class.new(input_suite, output_suite, converter, reporter) }
-
-  let(:converter) { double 'converter' }
-  let(:input_suite) { double 'ExamplesSuite' }
-  let(:output_suite) { double 'ExamplesSuite' }
-  let(:reporter) { spy 'Reporter' }
-  let(:examples) { fixtures }
-
-
-  describe '#initialize' do
-
-    context "with default reporter" do
-      subject(:tester) { described_class.new(input_suite, output_suite, converter, nil) }
-
-      it { expect(tester.reporter).to be_a DocTest::TestReporter }
-    end
-  end
-
-
-  describe '#run_tests' do
-
-    before do |ex|
-      next if ex.metadata[:skip_before]
-
-      expect(input_suite).to receive(:pair_with)
-          .with(output_suite).and_return(examples.values)
-      allow(tester).to receive(:test_example)
-    end
-
-    context "with default pattern" do
-
-      it "pairs the examples and tests all valid pairs" do
-        ['ex:alpha', 'ex:beta', 'ex:nooutput'].each do |name|
-          expect(tester).to receive(:test_example).with(*examples[name])
-        end
-        tester.run_tests
-      end
-    end
-
-    context "with specific pattern" do
-
-      it "pairs the examples and tests those matching the pattern" do
-        expect(tester).to receive(:test_example).with(*examples['ex:beta'])
-        tester.run_tests(pattern: 'ex:b*')
-      end
-    end
-
-    it "ignores pairs with empty input example" do
-      expect(tester).to_not receive(:test_example).with(*examples['ex:noinput'])
-      tester.run_tests
-    end
-
-    it "calls reporter's methods in the correct order", :skip_before do
-      expect(reporter).to receive(:start).ordered
-      expect(input_suite).to receive(:pair_with).and_return([]).ordered
-      expect(reporter).to receive(:report).ordered
-      expect(reporter).to receive(:passed?).ordered
-
-      tester.run_tests
-    end
-  end
-
-
-  describe '#test_example' do
-
-    subject(:failures) { tester.test_example input_exmpl, output_exmpl }
-
-    let(:examples_pair) { examples['ex:alpha'] }
-    let(:input_exmpl) { examples_pair[0] }
-    let(:output_exmpl) { examples_pair[1] }
-    let(:actual) { output_exmpl.content }
-    let(:expected) { output_exmpl.content }
-
-    shared_examples :example do
-      it "calls reporter" do
-        expect(reporter).to receive(:record)
-        tester.test_example input_exmpl, output_exmpl
-      end
-    end
-
-    before do |ex|
-      next if ex.metadata[:skip_before]
-
-      expect(converter).to receive(:convert_examples)
-        .with(input_exmpl, output_exmpl)
-        .and_return([actual, expected])
-    end
-
-
-    context "when output example is empty", :skip_before do
-
-      let(:examples_pair) { examples['ex:nooutput'] }
-
-      it "skips the test" do
-        is_expected.to contain_exactly Minitest::Skip
-      end
-
-      include_examples :example
-    end
-
-    context "when examples are equivalent" do
-
-      it "returns no failure" do
-        is_expected.to be_empty
-      end
-
-      include_examples :example
-    end
-
-    context "when examples are not equivalent" do
-
-      let(:actual) { '<em>meh</em>' }
-
-      it "returns failure" do
-        is_expected.to include Minitest::Assertion
-      end
-
-      context "and input example has desc:" do
-
-        it "returns failure with message that starts with the desc" do
-          expect(failures.first.message).to match /^yada.*/
-        end
-      end
-
-      context "and both input and output examples have desc:" do
-
-        let(:examples_pair) { examples['ex:beta'] }
-
-        it "returns failure with message that starts with the output's example desc" do
-          expect(failures.first.message).to match /^Yoda.*/
-        end
-      end
-
-      include_examples :example
-    end
-  end
-
-
-  def fixtures
-    data = {
-      'ex:alpha'    => [ {content: '_alpha_', desc: 'yada'}, {content: '<i>alpha</i>'}              ],
-      'ex:beta'     => [ {content: '*beta*',  desc: 'yada'}, {content: '<b>beta</b>', desc: 'Yoda'} ],
-      'ex:noinput'  => [ {},                                 {content: '<del>noinput</del>'}        ],
-      'ex:nooutput' => [ {content: 'nooutput'},              {}                                     ]
-    }
-    data = data.map { |name, tuple|
-      [ name, tuple.map { |opts| DocTest::Example.new(name, opts) } ]
-    }
-    Hash[data]
-  end
-end