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

data/spec/factory_spec.rb

@@ -1,46 +0,0 @@
-require 'ostruct'
-
-describe DocTest::Factory do
-
-  subject(:factory) { Module.new { extend DocTest::Factory } }
-
-  let(:default_opts) { {} }
-
-  before do
-    factory.register(:foo, OpenStruct, default_opts)
-    factory.register(:bar, String, 'illegal')
-    factory.register(:baz, Integer)
-  end
-
-  describe '.create' do
-    it "returns instance of registered class" do
-      expect( factory.create(:foo) ).to eq OpenStruct.new
-    end
-
-    context "with opts" do
-      it "initializes class with opts" do
-        expect( factory.create(:foo, a: 42) ).to eq OpenStruct.new(a: 42)
-      end
-
-      context "when class with default_opts" do
-        let(:default_opts) { {a: 1, b: 2} }
-
-        it "initializes class with opts merged with default_opts" do
-          expect( factory.create(:foo, b: 6) ).to eq OpenStruct.new(a: 1, b: 6)
-        end
-      end
-    end
-
-    context "when class with default_opts" do
-      let(:default_opts) { {a: 1, b: 2} }
-
-      it "initializes class with default_opts" do
-        expect( factory.create(:foo) ).to eq OpenStruct.new(default_opts)
-      end
-    end
-
-    context "with unregistered name" do
-      it { expect { factory.create(:unknown) }.to raise_error(ArgumentError) }
-    end
-  end
-end

data/spec/html/converter_spec.rb

@@ -1,137 +0,0 @@
-require 'forwardable'
-
-using Corefines::String::unindent
-
-module DocTest
-  describe HTML::Converter do
-    extend Forwardable
-
-    def_delegator :converter, :convert_examples
-
-    subject(:converter) { described_class.new }
-
-    describe '#convert_examples' do
-
-      let(:input) { Example.new 's:dummy', content: '*chunky* bacon', opts: input_opts }
-      let(:input_opts) { {} }
-      let(:output) { Example.new 's:dummy', content: output_content, opts: output_opts }
-      let(:output_content) { '<b>chunky</b> bacon' }
-      let(:output_opts) { {dummy: 'value'} }
-      let(:converter_opts) { {header_footer: false} }
-
-      subject(:result) { convert_examples input, output }
-
-      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(converter).to receive(:convert)
-          .with(input.content, converter_opts).and_return(rendered)
-      end
-
-      it 'returns array of converted input content and output content'
-
-      context 'with :exclude option' do
-        let(:output_opts) { {exclude: ['.//p', './/code']} }
-
-        it 'returns content without HTML (sub)elements specified by XPath' do
-          expect(result.first.gsub(/\s*/, '')).to eq \
-            '<section><h1>Title</h1><div></div></section><div></div>'
-        end
-      end
-
-      context 'with :include option' do
-        let(:output_opts) { {include: ['.//p']} }
-
-        it 'returns content with only HTML (sub)elements specified by XPath' do
-          expect(result.first.gsub(/\s*/, '')).to eq '<p><b>Chunky</b>bacon</p><p>why?</p>'
-        end
-      end
-
-      context 'with :header_footer option' do
-        let(:converter_opts) { {header_footer: true} }
-
-        context 'specified in output example' do
-          let(:output_opts) { {header_footer: true} }
-
-          it 'renders content with :header_footer => true' do
-            convert_examples input, output
-          end
-        end
-
-        context 'specified in input example' do
-          let(:input_opts) { {header_footer: true} }
-
-          it 'renders content with :header_footer => true' do
-            convert_examples input, output
-          end
-
-          context 'and disabled in output example' do
-            let(:output_opts) { {header_footer: false} }
-            let(:converter_opts) { {header_footer: false} }
-
-            it 'renders content with :header_footer => false' do
-              convert_examples input, output
-            end
-          end
-        end
-      end
-
-      context 'with example named /^document.*/' do
-        let(:input) { Example.new 'document:dummy', content: '*chunky* bacon' }
-        let(:converter_opts) { {header_footer: true} }
-
-        it 'renders content with :header_footer => true' do
-          convert_examples input, output
-        end
-      end
-
-      context 'with example named /inline_.*/' do
-        let(:input) { Example.new '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.first).to eq '<b>chunky</b> bacon'
-        end
-
-        context 'with :include option' do
-          let(:output_opts) { {include: ['.//b']} }
-
-          it 'preferes the include option' do
-            expect(result.first).to eq '<b>chunky</b>'
-          end
-        end
-      end
-
-      context 'with output example including DOCTYPE' do
-        let :output_content do
-          <<-EOF.unindent.strip
-            <!DOCTYPE html>
-            <html>
-              <head>
-                <title>Test</title>
-              </head>
-              <body></body>
-            </html>
-          EOF
-        end
-
-        it 'returns expected content with DOCTYPE' do
-          expect(result.last).to eq output_content
-        end
-      end
-    end
-  end
-end

data/spec/html_normalizer_spec.rb

@@ -1,70 +0,0 @@
-describe DocTest::HtmlNormalizer 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/io/asciidoc_spec.rb

@@ -1,139 +0,0 @@
-using Corefines::String::unindent
-
-describe DocTest::IO::Asciidoc do
-
-  it_should_behave_like DocTest::IO::Base
-
-  subject(:suite) { described_class.new(file_ext: '.adoc') }
-
-
-  describe '#initialize' do
-
-    it 'uses ".adoc" as default file_ext' do
-      expect(suite.file_ext).to eq '.adoc'
-    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.unindent
-            Paragraphs don't require
-            any special markup.
-
-            To begin a new one, separate it by blank line.
-          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.unindent
-            // .strong
-            // This is a description,
-            // see?
-            *allons-y!*
-          EOF
-        end
-
-        let :output do
-          create_example 's:strong', content: '*allons-y!*',
-            desc: "This is a description,\nsee?"
-        end
-
-        include_examples :example
-      end
-
-      context 'with options' do
-        let :input do
-          <<-EOF.unindent
-            // .basic
-            // :exclude: /^=+.*/
-            // :exclude: /^#+.*/
-            // :include: /^----\\n(.*)\\n----/m
-            // :header_footer:
-            _dummy_
-          EOF
-        end
-
-        let :output do
-          create_example 's:basic', content: '_dummy_', opts: {
-            exclude: ['/^=+.*/', '/^#+.*/'],
-            include: ['/^----\\n(.*)\\n----/m'],
-            header_footer: true
-          }
-        end
-        include_examples :example
-      end
-
-      context 'with description and options' do
-        let :input do
-          <<-EOF.unindent
-            // .basic
-            // This is a description.
-            // :exclude: /^=+.*/
-          EOF
-        end
-
-        let :output do
-          create_example 's:basic', desc: 'This is a description.', opts: {
-            exclude: ['/^=+.*/']
-          }
-        end
-        include_examples :example
-      end
-    end
-
-    context 'multiple examples' do
-      let :input do
-        <<-EOF.unindent
-          // .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
-end

data/spec/io/xml_spec.rb

@@ -1,141 +0,0 @@
-using Corefines::String::unindent
-
-describe DocTest::IO::XML do
-
-  it_should_behave_like DocTest::IO::Base
-
-  subject(:suite) { described_class.new(file_ext: '.html') }
-
-
-  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.unindent
-            <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.unindent
-            <!-- .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.unindent
-            <!-- .basic
-            :exclude: .//code
-            :exclude: .//section
-            :include: ./p/node()
-            :header_footer:
-            -->
-            <p>dummy</p>
-          EOF
-        end
-
-        let :output do
-          create_example 's:basic', content: '<p>dummy</p>', opts: {
-            exclude: ['.//code', './/section'],
-            include: ['./p/node()'],
-            header_footer: true
-          }
-        end
-        include_examples :example
-      end
-
-      context 'with description and options' do
-        let :input do
-          <<-EOF.unindent
-            <!-- .basic
-            This is a description.
-            :exclude: .//code
-            -->
-          EOF
-        end
-
-        let :output do
-          create_example 's:basic', desc: 'This is a description.', opts: {
-            exclude: ['.//code']
-          }
-        end
-        include_examples :example
-      end
-    end
-
-    context 'multiple examples' do
-      let :input do
-        <<-EOF.unindent
-          <!-- .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
-end