asciidoctor-doctest 1.5.0

data/lib/asciidoctor/doctest/minitest_diffy.rb

@@ -0,0 +1,74 @@
+require 'colorize'
+require 'diffy'
+
+module Asciidoctor
+  module DocTest
+    ##
+    # Module to be included into +Minitest::Test+ to use Diffy for diff.
+    module MinitestDiffy
+
+      # @private
+      def self.included(base)
+        base.make_my_diffs_pretty!
+      end
+
+      ##
+      # Returns diff between +exp+ and +act+ (if needed) using Diffy.
+      #
+      # @note Overrides method from +Minitest::Assertions+.
+      def diff(exp, act)
+        expected = mu_pp_for_diff(exp)
+        actual = mu_pp_for_diff(act)
+
+        if need_diff? expected, actual
+          ::Diffy::Diff.new(expected, actual, context: 3).to_s
+        else
+          "Expected: #{mu_pp(exp)}\n  Actual: #{mu_pp(act)}"
+        end
+      end
+
+      ##
+      # Returns +true+ if diff should be printed (using Diffy) for the given
+      # content, +false+ otherwise.
+      #
+      # @param expected [String]
+      # @param actual [String]
+      #
+      def need_diff?(expected, actual)
+        expected.include?("\n") ||
+          actual.include?("\n") ||
+          expected.size > 30    ||
+          actual.size > 30      ||
+          expected == actual
+      end
+    end
+  end
+end
+
+module Diffy
+  module Format
+
+    ##
+    # ANSI color output suitable for terminal, customized for minitest.
+    def minitest
+      padding = ' ' * 2
+      ary = map do |line|
+        case line
+        when /^(---|\+\+\+|\\\\)/
+          # ignore
+        when /^\\\s*No newline at end of file/
+          # ignore
+        when /^\+/
+          line.chomp.sub(/^\+/, 'A' + padding).red
+        when /^-/
+          line.chomp.sub(/^\-/, 'E' + padding).green
+        else
+          padding + line.chomp
+        end
+      end
+      "\n" + ary.join("\n")
+    end
+  end
+end
+
+Diffy::Diff.default_format = :minitest

data/lib/asciidoctor/doctest/test.rb

@@ -0,0 +1,120 @@
+require 'active_support/core_ext/object/blank'
+require 'asciidoctor/doctest/asciidoc_renderer'
+require 'asciidoctor/doctest/core_ext'
+require 'asciidoctor/doctest/minitest_diffy'
+require 'asciidoctor/doctest/asciidoc/examples_suite'
+require 'minitest'
+
+module Asciidoctor
+  module DocTest
+    ##
+    # Test class for Asciidoctor backends.
+    class Test < Minitest::Test
+      include MinitestDiffy
+
+      ##
+      # (see AsciidocRenderer#initialize)
+      def self.renderer_opts(**kwargs)
+        @renderer = AsciidocRenderer.new(**kwargs)
+      end
+
+      ##
+      # Generates tests for all the input/output examples.
+      # When some output example is missing, it's reported as skipped test.
+      #
+      # @param output_suite [BaseExamplesSuite, Class] the examples suite class
+      #        (or its instance) to read the output examples from (i.e. an
+      #        expected output).
+      # @param input_suite [BaseExamplesSuite, Class] the examples suite class
+      #        (or its instance) to read the reference input examples from.
+      #
+      # If class is given, then it's instantiated with zero arguments.
+      #
+      def self.generate_tests!(output_suite, input_suite = Asciidoc::ExamplesSuite)
+        instance = ->(o) { o.is_a?(Class) ? o.new : o }
+        @output_suite = instance[output_suite]
+        @input_suite  = instance[input_suite]
+
+        @input_suite.pair_with(@output_suite).each do |input, output|
+          next if input.empty?
+
+          define_test input.name do
+            if output.empty?
+              skip 'No expected output found'
+            else
+              test_example output, input
+            end
+          end
+        end
+      end
+
+      ##
+      # Defines a new test method.
+      #
+      # @param name [String] name of the test (method).
+      # @param block [Proc] the test method's body.
+      #
+      def self.define_test(name, &block)
+        (@test_methods ||= []) << name
+        define_method name, block
+      end
+
+      ##
+      # @!method self.test
+      #   @see .define_test
+      alias_class_method :test, :define_test
+
+      ##
+      # @private
+      # @note Overrides method from +Minitest::Test+.
+      # @return [Array] names of the test methods to run.
+      def self.runnable_methods
+        (@test_methods || []) + super - ['test_example']
+      end
+
+      ##
+      # Tests if the given reference input is matching the expected output
+      # after conversion through the tested backend.
+      #
+      # @param output_exmpl [BaseExample] the expected output example.
+      # @param input_exmpl [BaseExample] the reference input example.
+      # @raise [Minitest::Assertion] if the assertion fails.
+      #
+      def test_example(output_exmpl, input_exmpl)
+        converted_exmpl = output_suite.convert_example(input_exmpl, output_exmpl.opts, renderer)
+        msg = output_exmpl.desc.presence || input_exmpl.desc
+
+        assert_equal output_exmpl, converted_exmpl, msg
+      end
+
+      ##
+      # @private
+      # @note Overrides method from +Minitest::Test+.
+      # @return [String] name of this test that will be printed in a report.
+      def location
+        prefix = self.class.name.split('::').last
+        name = self.name.sub(':', ' : ')
+        "#{prefix} :: #{name}"
+      end
+
+      ##
+      # @private
+      # Returns a human-readable (formatted) version of the asserted object.
+      #
+      # @note Overrides method from +Minitest::Assertions+.
+      #
+      # @param example [#to_s]
+      # @return [String]
+      #
+      def mu_pp(example)
+        example.to_s
+      end
+
+      [:input_suite, :output_suite, :renderer].each do |name|
+        define_method name do
+          self.class.instance_variable_get(:"@#{name}")
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/doctest/version.rb

@@ -0,0 +1,5 @@
+module Asciidoctor
+  module DocTest
+    VERSION = '1.5.0'
+  end
+end

data/spec/asciidoc/examples_suite_spec.rb

@@ -0,0 +1,99 @@
+require 'active_support/core_ext/string/strip'
+require 'forwardable'
+
+describe DocTest::Asciidoc::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 ".adoc" as default file_ext' do
+      expect(suite.file_ext).to eq '.adoc'
+    end
+  end
+
+
+  describe '#parse' do
+
+    context 'one example' do
+
+      shared_examples :example do
+        subject(:parsed) { suite.parse input, 's' }
+
+        it { is_expected.to have(1).items }
+
+        it 'returns an array with parsed Example object' do
+          expect(parsed.first).to eql output
+        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
+            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.strip_heredoc
+            // .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
+    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
+end

data/spec/base_example_spec.rb

@@ -0,0 +1,176 @@
+describe DocTest::BaseExample do
+
+  subject(:o) { described_class.new ['foo', 'bar'] }
+
+  it { is_expected.to respond_to :group_name, :local_name, :content, :desc, :opts }
+
+  describe '#name' do
+
+    it 'returns #{group_name}:#{local_name}' do
+      o.group_name = 'block_olist'
+      o.local_name = 'with-start'
+
+      expect(o.name).to eq "#{o.group_name}:#{o.local_name}"
+    end
+  end
+
+  describe '#name=' do
+
+    shared_examples :example do
+      it 'sets group_name and local_name' do
+        is_expected.to have_attributes group_name: 'section', local_name: 'basic'
+      end
+    end
+
+    context 'with String' do
+      before { o.name = 'section:basic' }
+      include_examples :example
+    end
+
+    context 'with Array' do
+      before { o.name = ['section', 'basic'] }
+      include_examples :example
+    end
+  end
+
+  describe '#name_match?' do
+    name = 'block_ulist:with-title'
+
+    context "when name is e.g. #{name}" do
+      subject(:o) { described_class.new(name) }
+
+      [ '*', '*:*', 'block_ulist:*', '*:with-title', 'block_*:*',
+        'block_ulist:with-*', 'block_ulist:*title'
+      ].each do |pattern|
+        it "returns true for #{pattern}" do
+          expect(o.name_match?(pattern)).to be_truthy
+        end
+      end
+
+      [ 'block_foo:with-title', 'block_ulist:foo', 'foo:*' '*:foo', 'foo'
+      ].each do |pattern|
+        it "returns false for #{pattern}" do
+          expect(o.name_match?(pattern)).to be_falsy
+        end
+      end
+    end
+  end
+
+  describe '#empty?' do
+    subject { o.empty? }
+
+    context 'when content is nil' do
+      before { o.content = nil }
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when content is blank' do
+      before { o.content = ' ' }
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when content is not blank' do
+      before { o.content = 'allons-y!' }
+      it { is_expected.to be_falsy }
+    end
+  end
+
+  describe '#[]' do
+
+    context 'when option exists' do
+      it 'returns the option value' do
+        o.opts[:foo] = 'bar'
+        expect(o['foo']).to eq 'bar'
+      end
+    end
+
+    context 'when option does not exist' do
+      it 'returns nil' do
+        expect(o[:nothing]).to be_nil
+      end
+    end
+  end
+
+  describe '#[]=' do
+    subject { o.opts }
+
+    context 'with boolean value' do
+      [true, false].each do |value|
+        it "associates the option with #{value}" do
+          o['foo'] = value
+          is_expected.to eq(foo: value)
+        end
+      end
+    end
+
+    context 'with Array value' do
+      it 'associates the option with the value' do
+        o['foo'] = ['a', 'b']
+        is_expected.to eq(foo: ['a', 'b'])
+      end
+    end
+
+    context 'with String value' do
+
+      context 'when option is not defined' do
+        it 'associates the option with the value wrapped in an array' do
+          o['key'] = 'foo'
+          is_expected.to eq(key: ['foo'])
+        end
+      end
+
+      context 'when option is already defined' do
+        before { o.opts[:key] = ['foo'] }
+
+        it 'adds the value to array associated with the option' do
+          o[:key] = 'bar'
+          is_expected.to eq(key: ['foo', 'bar'])
+        end
+      end
+    end
+
+    context 'with nil value' do
+      before { o.opts[:key] = ['foo'] }
+
+      it 'deletes the option' do
+        o[:key] = nil
+        is_expected.to be_empty
+      end
+    end
+  end
+
+  describe '#==' do
+
+    let(:first) { described_class.new('a:b', content: 'allons-y!') }
+    let(:second) { described_class.new('a:b', content: 'allons-y!') }
+
+    it 'returns true for different instances with the same name and content' do
+      expect(first).to eq second
+    end
+
+    it 'returns false for instances with different name' do
+      second.name = 'a:x'
+      expect(first).to_not eq second
+    end
+
+    it 'returns false for instances with different content_normalized' do
+      expect(second).to receive(:content_normalized).and_return('ALLONS-Y!')
+      expect(first).to_not eq second
+    end
+  end
+
+  describe '#dup' do
+    it 'returns deep copy' do
+      origo = described_class.new('a:b', content: 'allons-y!', desc: 'who?', opts: {key: ['value']})
+      copy = origo.dup
+
+      expect(origo).to eql copy
+      expect(origo).to_not equal copy
+
+      origo.instance_values.values.zip(copy.instance_values.values).each do |val1, val2|
+        expect(val1).to_not equal val2 unless val1.nil? && val2.nil?
+      end
+      expect(origo.opts[:key].first).to_not equal copy.opts[:key].first
+    end
+  end
+end