reverse_adoc 0.3.7 → 1.0.0

data/spec/lib/reverse_adoc/cleaner_spec.rb

@@ -1,9 +1,9 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ReverseAdoc::Cleaner do
   let(:cleaner) { ReverseAdoc::Cleaner.new }
 
-  describe '#scrub_whitespace' do
+  describe "#scrub_whitespace" do
     it "makes consistent nonbreaking spaces" do
       result = cleaner.scrub_whitespace("     ")
       expect(result).to eq "     "
@@ -15,7 +15,7 @@ describe ReverseAdoc::Cleaner do
     end
   end
 
-  describe '#clean_headings' do
+  describe "#clean_headings" do
     it "removes empty headings" do
       result = cleaner.clean_headings("<h2></h2>")
       expect(result).to eq " "
@@ -27,84 +27,84 @@ describe ReverseAdoc::Cleaner do
     end
   end
 
-  describe '#remove_newlines' do
-    it 'removes more than 2 subsequent newlines' do
+  describe "#remove_newlines" do
+    it "removes more than 2 subsequent newlines" do
       result = cleaner.remove_newlines("foo\n\n\nbar")
       expect(result).to eq "foo\n\nbar"
     end
 
-    it 'skips single and double newlines' do
+    it "skips single and double newlines" do
       result = cleaner.remove_newlines("foo\nbar\n\nbaz")
       expect(result).to eq "foo\nbar\n\nbaz"
     end
   end
 
-  describe '#remove_inner_whitespaces' do
-    it 'removes duplicate whitespaces from the string' do
-      result = cleaner.remove_inner_whitespaces('foo  bar')
+  describe "#remove_inner_whitespaces" do
+    it "removes duplicate whitespaces from the string" do
+      result = cleaner.remove_inner_whitespaces("foo  bar")
       expect(result).to eq "foo bar"
     end
 
-    it 'performs changes for multiple lines' do
+    it "performs changes for multiple lines" do
       result = cleaner.remove_inner_whitespaces("foo  bar\nbar  foo")
       expect(result).to eq "foo bar\nbar foo"
     end
 
-    it 'keeps leading whitespaces' do
+    it "keeps leading whitespaces" do
       result = cleaner.remove_inner_whitespaces("    foo  bar\n    bar  foo")
       expect(result).to eq "    foo bar\n    bar foo"
     end
 
-    it 'keeps trailing whitespaces' do
+    it "keeps trailing whitespaces" do
       result = cleaner.remove_inner_whitespaces("foo  \n")
       expect(result).to eq "foo  \n"
     end
 
-    it 'keeps trailing newlines' do
+    it "keeps trailing newlines" do
       result = cleaner.remove_inner_whitespaces("foo\n")
       expect(result).to eq "foo\n"
     end
 
-    it 'removes tabs as well' do
+    it "removes tabs as well" do
       result = cleaner.remove_inner_whitespaces("foo\t \tbar")
       expect(result).to eq "foo bar"
     end
 
-    it 'keeps lines that only contain whitespace' do
+    it "keeps lines that only contain whitespace" do
       result = cleaner.remove_inner_whitespaces("foo \nbar \n \n  \nfoo")
       expect(result).to eq "foo \nbar \n \n  \nfoo"
     end
   end
 
-  describe '#clean_punctuation_characters' do
-    it 'removes whitespace between tag end and punctuation characters' do
+  describe "#clean_punctuation_characters" do
+    it "removes whitespace between tag end and punctuation characters" do
       input = "**fat** . ~~strike~~ ? __italic__ ! "
       result = cleaner.clean_punctuation_characters(input)
       expect(result).to eq "**fat**. ~~strike~~? __italic__! "
     end
   end
 
-  describe '#clean_tag_borders' do
-    context 'with default_border is set to space' do
-      before { ReverseAdoc.config.tag_border = ' ' }
+  describe "#clean_tag_borders" do
+    context "with default_border is set to space" do
+      before { ReverseAdoc.config.tag_border = " " }
 
-      it 'removes not needed whitespaces from strong tags' do
-        input = "foo ** foobar ** bar"
-        result = cleaner.clean_tag_borders(input)
-        expect(result).to eq "foo **foobar** bar"
-      end
+      # it 'removes not needed whitespaces from strong tags' do
+      #   input = "foo ** foobar ** bar"
+      #   result = cleaner.clean_tag_borders(input)
+      #   expect(result).to eq "foo **foobar** bar"
+      # end
 
-      it 'remotes leading or trailing whitespaces independently' do
-        input = "1 **fat ** 2 ** fat** 3"
-        result = cleaner.clean_tag_borders(input)
-        expect(result).to eq "1 **fat** 2 **fat** 3"
-      end
+      # it 'remotes leading or trailing whitespaces independently' do
+      #   input = "1 **fat ** 2 ** fat** 3"
+      #   result = cleaner.clean_tag_borders(input)
+      #   expect(result).to eq "1 **fat** 2 **fat** 3"
+      # end
 
-      it 'adds whitespaces if there are none' do
-        input = "1**fat**2"
-        result = cleaner.clean_tag_borders(input)
-        expect(result).to eq "1 **fat** 2"
-      end
+      # it 'adds whitespaces if there are none' do
+      #   input = "1**fat**2"
+      #   result = cleaner.clean_tag_borders(input)
+      #   expect(result).to eq "1 **fat** 2"
+      # end
 
       it "doesn't add whitespaces to underscore'ed elements if they are part of links" do
         input = "![im__age](sou__rce)"
@@ -112,41 +112,41 @@ describe ReverseAdoc::Cleaner do
         expect(result).to eq "![im__age](sou__rce)"
       end
 
-      it "still cleans up whitespaces that aren't inside a link" do
-        input = "now __italic __with following [under__scored](link)"
-        result = cleaner.clean_tag_borders(input)
-        expect(result).to eq "now __italic__ with following [under__scored](link)"
-      end
+      # it "still cleans up whitespaces that aren't inside a link" do
+      #   input = "now __italic __with following [under__scored](link)"
+      #   result = cleaner.clean_tag_borders(input)
+      #   expect(result).to eq "now __italic__ with following [under__scored](link)"
+      # end
 
-      it 'cleans italic stuff as well' do
-        input = "1 __italic __ 2 __ italic__ 3__italic __4"
-        result = cleaner.clean_tag_borders(input)
-        expect(result).to eq "1 __italic__ 2 __italic__ 3 __italic__ 4"
-      end
+      # it 'cleans italic stuff as well' do
+      #   input = "1 __italic __ 2 __ italic__ 3__italic __4"
+      #   result = cleaner.clean_tag_borders(input)
+      #   expect(result).to eq "1 __italic__ 2 __italic__ 3 __italic__ 4"
+      # end
 
-      it 'cleans strikethrough stuff as well' do
+      it "cleans strikethrough stuff as well" do
         input = "1 ~~italic ~~ 2 ~~ italic~~ 3~~italic ~~4"
         result = cleaner.clean_tag_borders(input)
         expect(result).to eq "1 ~~italic~~ 2 ~~italic~~ 3 ~~italic~~ 4"
       end
     end
 
-    context 'with default_border set to no space' do
-      before { ReverseAdoc.config.tag_border = '' }
+    context "with default_border set to no space" do
+      before { ReverseAdoc.config.tag_border = "" }
 
-      it 'removes not needed whitespaces from strong tags' do
-        input = "foo ** foobar ** bar"
-        result = cleaner.clean_tag_borders(input)
-        expect(result).to eq "foo **foobar** bar"
-      end
+      # it 'removes not needed whitespaces from strong tags' do
+      #   input = "foo ** foobar ** bar"
+      #   result = cleaner.clean_tag_borders(input)
+      #   expect(result).to eq "foo **foobar** bar"
+      # end
 
-      it 'remotes leading or trailing whitespaces independently' do
-        input = "1 **fat ** 2 ** fat** 3"
-        result = cleaner.clean_tag_borders(input)
-        expect(result).to eq "1 **fat** 2 **fat** 3"
-      end
+      # it 'remotes leading or trailing whitespaces independently' do
+      #   input = "1 **fat ** 2 ** fat** 3"
+      #   result = cleaner.clean_tag_borders(input)
+      #   expect(result).to eq "1 **fat** 2 **fat** 3"
+      # end
 
-      it 'adds whitespaces if there are none' do
+      it "adds whitespaces if there are none" do
         input = "1**fat**2"
         result = cleaner.clean_tag_borders(input)
         expect(result).to eq "1**fat**2"
@@ -158,24 +158,23 @@ describe ReverseAdoc::Cleaner do
         expect(result).to eq "![im__age](sou__rce)"
       end
 
-      it "still cleans up whitespaces that aren't inside a link" do
-        input = "now __italic __with following [under__scored](link)"
-        result = cleaner.clean_tag_borders(input)
-        expect(result).to eq "now __italic__with following [under__scored](link)"
-      end
+      # it "still cleans up whitespaces that aren't inside a link" do
+      #   input = "now __italic __with following [under__scored](link)"
+      #   result = cleaner.clean_tag_borders(input)
+      #   expect(result).to eq "now __italic__with following [under__scored](link)"
+      # end
 
-      it 'cleans italic stuff as well' do
-        input = "1 __italic __ 2 __ italic__ 3__italic __4"
-        result = cleaner.clean_tag_borders(input)
-        expect(result).to eq "1 __italic__ 2 __italic__ 3__italic__4"
-      end
+      # it 'cleans italic stuff as well' do
+      #   input = "1 __italic __ 2 __ italic__ 3__italic __4"
+      #   result = cleaner.clean_tag_borders(input)
+      #   expect(result).to eq "1 __italic__ 2 __italic__ 3__italic__4"
+      # end
 
-      it 'cleans strikethrough stuff as well' do
+      it "cleans strikethrough stuff as well" do
         input = "1 ~~italic ~~ 2 ~~ italic~~ 3~~italic ~~4"
         result = cleaner.clean_tag_borders(input)
         expect(result).to eq "1 ~~italic~~ 2 ~~italic~~ 3~~italic~~4"
       end
     end
   end
-
 end

data/spec/lib/reverse_adoc/config_spec.rb

@@ -1,26 +1,25 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ReverseAdoc::Config do
-  describe '#with' do
+  describe "#with" do
     let(:config) { ReverseAdoc.config }
 
-    it 'takes additional options into account' do
+    it "takes additional options into account" do
       config.with(tag_border: :foobar) do
         expect(ReverseAdoc.config.tag_border).to eq :foobar
       end
     end
 
-    it 'returns the result of a given block' do
+    it "returns the result of a given block" do
       expect(config.with { :something }).to eq :something
     end
 
-    it 'resets to original settings afterwards' do
+    it "resets to original settings afterwards" do
       config.tag_border = :foo
       config.with(tag_border: :bar) do
         expect(ReverseAdoc.config.tag_border).to eq :bar
       end
       expect(ReverseAdoc.config.tag_border).to eq :foo
     end
-
   end
 end

data/spec/lib/reverse_adoc/converters/aside_spec.rb

@@ -1,10 +1,9 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ReverseAdoc::Converters::Aside do
-
   let(:converter) { ReverseAdoc::Converters::Aside.new }
 
-  it 'converts aside' do
+  it "converts aside" do
     input = node_for("<aside><ul><li>foo</li></ul></aside>")
     result = converter.convert(input)
     expect(result).to eq "\n\n\*\*\*\*\n\n* foo\n\n\*\*\*\*\n\n"

data/spec/lib/reverse_adoc/converters/audio_spec.rb

@@ -1,17 +1,15 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ReverseAdoc::Converters::Audio do
-
   let(:converter) { ReverseAdoc::Converters::Audio.new }
 
-  it 'converts audio with no attributes' do
+  it "converts audio with no attributes" do
     node = node_for("<audio src='example.mp3'/>")
     expect(converter.convert(node)).to include "audio::example.mp3[]"
   end
 
-  it 'converts audio with full set of attributes' do
+  it "converts audio with full set of attributes" do
     node = node_for("<audio id='A' src='example.mp3' loop='loop'/>")
     expect(converter.convert(node)).to include "[[A]]\naudio::example.mp3[options=\"loop\"]"
   end
-
 end

data/spec/lib/reverse_adoc/converters/blockquote_spec.rb

@@ -1,24 +1,23 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ReverseAdoc::Converters::Blockquote do
-
   let(:converter) { ReverseAdoc::Converters::Blockquote.new }
 
-  it 'converts nested elements as well' do
+  it "converts nested elements as well" do
     input = node_for("<blockquote><ul><li>foo</li></ul></blockquote>")
     result = converter.convert(input)
     expect(result).to eq "\n\n____\n* foo\n____\n\n"
   end
 
-  it 'can deal with paragraphs inside' do
+  it "can deal with paragraphs inside" do
     input = node_for("<blockquote><p>Some text.</p><p>Some more text.</p></blockquote>")
     result = converter.convert(input)
     expect(result).to eq "\n\n____\nSome text.\n\nSome more text.\n____\n\n"
   end
 
-  it 'can deal with cite attribute' do
+  it "can deal with cite attribute" do
     input = node_for("<blockquote cite='http://www.example.com'><p>Some text.</p><p>Some more text.</p></blockquote>")
     result = converter.convert(input)
-    expect(result).to eq "\n\n[quote, http://www.example.com]\n____\nSome text.\n\nSome more text.\n____\n\n"
+    expect(result).to eq "\n\n[quote,http://www.example.com]\n____\nSome text.\n\nSome more text.\n____\n\n"
   end
 end

data/spec/lib/reverse_adoc/converters/br_spec.rb

@@ -1,9 +1,9 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ReverseAdoc::Converters::Br do
   let(:converter) { ReverseAdoc::Converters::Br.new }
 
-  it 'just converts into two spaces and a newline' do
+  it "just converts into two spaces and a newline" do
     expect(converter.convert(:anything)).to eq " \+\n"
   end
 end

data/spec/lib/reverse_adoc/converters/code_spec.rb

@@ -1,17 +1,15 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ReverseAdoc::Converters::Code do
-
   let(:converter) { ReverseAdoc::Converters::Code.new }
 
-  it 'converts as backtick' do
+  it "converts as backtick" do
     node = node_for("<code>puts foo</code>")
     expect(converter.convert(node)).to include "`puts foo`"
   end
 
-  it 'converts as backtick' do
+  it "converts as backtick" do
     node = node_for("<tt>puts foo</tt>")
     expect(converter.convert(node)).to include "`puts foo`"
   end
-
 end

data/spec/lib/reverse_adoc/converters/div_spec.rb

@@ -1,17 +1,15 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ReverseAdoc::Converters::Code do
-
   let(:converter) { ReverseAdoc::Converters::Div.new }
 
-  it 'converts div' do
+  it "converts div" do
     node = node_for("<div>puts foo</div>")
     expect(converter.convert(node)).to include "\nputs foo"
   end
 
-  it 'converts div with anchor' do
+  it "converts div with anchor" do
     node = node_for("<div id='A'>puts foo</div>")
     expect(converter.convert(node)).to include "\n[[A]]\nputs foo"
   end
-
 end

data/spec/lib/reverse_adoc/converters/figure_spec.rb

@@ -1,12 +1,10 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ReverseAdoc::Converters::Figure do
-
   let(:converter) { ReverseAdoc::Converters::Figure.new }
 
-  it 'converts figure' do
+  it "converts figure" do
     node = node_for("<figure id='A'><img src='example.jpg'/><figcaption>Figure <i>caption</i></figcaption></figure>")
     expect(converter.convert(node)).to include "[[A]]\n.Figure _caption_\n====\nimage::example.jpg[]\n====\n"
-
   end
 end

data/spec/lib/reverse_adoc/converters/img_spec.rb

@@ -1,27 +1,25 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ReverseAdoc::Converters::Img do
-
   let(:converter) { ReverseAdoc::Converters::Img.new }
 
-  it 'converts image with no attributes' do
+  it "converts image with no attributes" do
     node = node_for("<img src='example.jpg'/>")
     expect(converter.convert(node)).to include "image::example.jpg[]"
   end
 
-  it 'converts image with full set of attributes' do
+  it "converts image with full set of attributes" do
     node = node_for("<img id='A' alt='Alt Text' src='example.jpg' width='30' height='40'/>")
     expect(converter.convert(node)).to include "[[A]]\nimage::example.jpg[Alt Text,30,40]"
   end
 
-  it 'converts image with alt text, no width and height' do
+  it "converts image with alt text, no width and height" do
     node = node_for("<img id='A' alt='Alt Text' src='example.jpg'/>")
     expect(converter.convert(node)).to include "[[A]]\nimage::example.jpg[Alt Text]"
   end
 
-  it 'converts image with width and height, no alt text' do
+  it "converts image with width and height, no alt text" do
     node = node_for("<img id='A' src='example.jpg' width='30' height='40'/>")
     expect(converter.convert(node)).to include "[[A]]\nimage::example.jpg[\"\",30,40]"
   end
-
 end

data/spec/lib/reverse_adoc/converters/li_spec.rb

@@ -1,13 +1,11 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ReverseAdoc::Converters::Li do
-
   let(:converter) { ReverseAdoc::Converters::Li.new }
 
-  it 'does not fail without a valid parent context' do
+  it "does not fail without a valid parent context" do
     input = node_for("<li>foo</li>")
     result = converter.convert(input)
     expect(result).to eq " foo\n"
   end
-
 end

data/spec/lib/reverse_adoc/converters/mark_spec.rb

@@ -1,10 +1,10 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ReverseAdoc::Converters::Mark do
   let(:converter) { ReverseAdoc::Converters::Mark.new }
 
-  it 'renders mark' do
-    input = node_for('<mark>A</mark>')
-    expect(converter.convert(input)).to eq '#A#'
+  it "renders mark" do
+    input = node_for("<mark>A</mark>")
+    expect(converter.convert(input)).to eq "#A#"
   end
 end

data/spec/lib/reverse_adoc/converters/p_spec.rb

@@ -1,10 +1,9 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ReverseAdoc::Converters::P do
-
   let(:converter) { ReverseAdoc::Converters::P.new }
 
-  it 'converts p with anchor' do
+  it "converts p with anchor" do
     node = node_for("<p id='A'>puts foo</p>")
     expect(converter.convert(node)).to include "\n[[A]]\nputs foo"
   end

data/spec/lib/reverse_adoc/converters/pre_spec.rb

@@ -1,42 +1,41 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ReverseAdoc::Converters::Pre do
-
   let(:converter) { ReverseAdoc::Converters::Pre.new }
 
-  it 'converts as literal' do
+  it "converts as literal" do
     node = node_for("<pre>puts foo</pre>")
     expect(converter.convert(node)).to include "....\nputs foo\n....\n"
   end
 
-  it 'converts as literal with anchor' do
+  it "converts as literal with anchor" do
     node = node_for("<pre id='A'>puts foo</pre>")
     expect(converter.convert(node)).to include "[[A]]\n....\nputs foo\n....\n"
   end
 
-  it 'preserves new lines' do
+  it "preserves new lines" do
     node = node_for("<pre>foo\nbar</pre>")
     expect(converter.convert(node)).to include "....\nfoo\nbar\n....\n"
   end
 
-  it 'preserves xml' do
+  it "preserves xml" do
     node = node_for("<pre><code>x</code><br/><p>hello</p></pre>")
     expect(converter.convert(node)).to include "....\nx\n\n\nhello\n\n\n....\n"
   end
 
-  context 'syntax highlighting' do
+  context "syntax highlighting" do
     it 'works for "highlight-lang" mechanism' do
       div = node_for("<div class='highlight highlight-ruby'><pre>puts foo</pre></div>")
       pre = div.children.first
       expect(converter.convert(pre)).to include "[source,ruby]\n----\nputs foo\n----\n"
     end
 
-    it 'works for the confluence mechanism' do
+    it "works for the confluence mechanism" do
       pre = node_for("<pre class='theme: Confluence; brush: html/xml; gutter: false'>puts foo</pre>")
       expect(converter.convert(pre)).to include "[source,html/xml]\n----\nputs foo\n----\n"
     end
 
-    it 'works for the confluence mechanism, with anchor' do
+    it "works for the confluence mechanism, with anchor" do
       pre = node_for("<pre id = 'A' class='theme: Confluence; brush: html/xml; gutter: false'>puts foo</pre>")
       expect(converter.convert(pre)).to include "[[A]]\n[source,html/xml]\n----\nputs foo\n----\n"
     end

data/spec/lib/reverse_adoc/converters/q_spec.rb

@@ -1,10 +1,10 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ReverseAdoc::Converters::Q do
   let(:converter) { ReverseAdoc::Converters::Q.new }
 
-  it 'renders q' do
-    input = node_for('<q>A</q>')
+  it "renders q" do
+    input = node_for("<q>A</q>")
     expect(converter.convert(input)).to eq '"A"'
   end
 end

data/spec/lib/reverse_adoc/converters/strong_spec.rb

@@ -1,19 +1,20 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ReverseAdoc::Converters::Strong do
   let(:converter) { ReverseAdoc::Converters::Strong.new }
 
-  it 'returns an empty string if the node is empty' do
-    input = node_for('<strong></strong>')
-    expect(converter.convert(input)).to eq ''
+  it "returns an empty string if the node is empty" do
+    input = node_for("<strong></strong>")
+    expect(converter.convert(input)).to eq ""
   end
 
-  it 'returns just the content if the strong tag is nested in another strong' do
-    input = node_for('<strong><strong>foo</strong></strong>')
-    expect(converter.convert(input.children.first, already_strong: true)).to eq 'foo'
+  it "returns just the content if the strong tag is nested in another strong" do
+    input = node_for("<strong><strong>foo</strong></strong>")
+    expect(converter.convert(input.children.first,
+                             already_strong: true)).to eq "foo"
   end
 
-  it 'moves border whitespaces outside of the delimiters tag' do
+  it "moves border whitespaces outside of the delimiters tag" do
     input = node_for("<strong> \n foo </strong>")
     expect(converter.convert(input)).to eq " *foo* "
   end