upmark 0.2.0 → 0.9.0

data/spec/spec_helper.rb

@@ -10,3 +10,11 @@ if ENV["BUILDBOX"]
 end
 
 require "upmark"
+
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+
+  config.order = :random
+
+  config.example_status_persistence_file_path = '.examples'
+end

data/spec/unit/lib/upmark/parser/xml_spec.rb

@@ -1,104 +1,227 @@
-require "spec_helper"
-
-describe Upmark::Parser::XML do
+RSpec.describe Upmark::Parser::XML do
   let(:parser) { Upmark::Parser::XML.new }
 
   context "#node" do
-    subject { parser.node }
-
-    it { should parse "" }
-    it { should parse "messenger bag skateboard" }
-    it { should parse "<p>messenger bag skateboard</p>" }
-    it { should parse "messenger <p>bag</p> skateboard" }
-    it { should parse "<p>messenger</p><p>bag</p><p>skateboard</p>" }
-    it { should parse "<p>messenger</p>\n<p>bag</p>\n<p>skateboard</p>" }
-    it { should parse "<p>messenger <strong>bag</strong> skateboard</p>" }
+    it 'will parse ""' do
+      expect(parser.node).to parse ""
+    end
+    it 'will parse "messenger bag skateboard"' do
+      expect(parser.node).to parse "messenger bag skateboard"
+    end
+    it 'will parse html br tags' do
+      expect(parser.node).to parse '<p>One<br>Two</p>'
+    end
+    it 'will parse "<p>messenger bag skateboard</p>"' do
+      expect(
+        parser.node
+      ).to parse "<p>messenger bag skateboard</p>"
+    end
+    it 'will parse "messenger <p>bag</p> skateboard"' do
+      expect(
+        parser.node
+      ).to parse "messenger <p>bag</p> skateboard"
+    end
+    it 'will parse "<p>messenger</p><p>bag</p><p>skateboard</p>"' do
+      expect(
+        parser.node
+      ).to parse "<p>messenger</p><p>bag</p><p>skateboard</p>"
+    end
+    it 'will parse "<p>messenger</p>\n<p>bag</p>\n<p>skateboard</p>"' do
+      expect(
+        parser.node
+      ).to parse "<p>messenger</p>\n<p>bag</p>\n<p>skateboard</p>"
+    end
+    it 'will parse "<p>messenger <strong>bag</strong> skateboard</p>"' do
+      expect(
+        parser.node
+      ).to parse "<p>messenger <strong>bag</strong> skateboard</p>"
+    end
+  end
+
+  context "#empty_element" do
+    it 'will parse <p> </p>' do
+      expect(parser.empty_element).to parse '<p> </p>'
+    end
   end
 
   context "#element" do
-    subject { parser.element }
-
-    it { should     parse "<p></p>" }
-    it { should     parse "<p>messenger bag skateboard</p>" }
-    it { should     parse %q{<tofu art="party" />} }
-    it { should_not parse "<p>" }
-    it { should_not parse "<p>messenger bag skateboard" }
-    it { should_not parse "messenger bag skateboard</p>" }
-    it { should_not parse "<p>messenger bag skateboard<p>" }
+    it 'will parse "<p></p>"' do
+      expect(parser.element).to parse "<p></p>"
+    end
+    it 'will parse "<p>messenger bag skateboard</p>"' do
+      expect(parser.element).to parse "<p>messenger bag skateboard</p>"
+    end
+    it 'will parse "<p>Some<br>Text</p>"' do
+      expect(parser.element).to parse "<p>Some<br>Text</p>"
+    end
+    it 'will parse %q{<tofu art="party" />}' do
+      expect(parser.element).to parse %q{<tofu art="party" />}
+    end
+    it 'will not parse "<p>"' do
+      expect(parser.element).to_not parse "<p>"
+    end
+    it 'will not parse "<p>messenger bag skateboard"' do
+      expect(parser.element).to_not parse "<p>messenger bag skateboard"
+    end
+    it 'will not parse "messenger bag skateboard</p>"' do
+      expect(parser.element).to_not parse "messenger bag skateboard</p>"
+    end
+    it 'will not parse "<p>messenger bag skateboard<p>"' do
+      expect(parser.element).to_not parse "<p>messenger bag skateboard<p>"
+    end
   end
 
   context "#text" do
-    subject { parser.text }
-
-    it { should     parse "messenger bag skateboard" }
-    it { should_not parse "<p>messenger bag skateboard</p>" }
-    it { should_not parse "" }
+    it 'will parse "messenger bag skateboard"' do
+      expect(parser.text).to parse "messenger bag skateboard"
+    end
+    it 'will not parse "<p>messenger bag skateboard</p>"' do
+      expect(parser.text).to_not parse "<p>messenger bag skateboard</p>"
+    end
+    it 'will not parse " "' do
+      expect(parser.text).to_not parse " "
+    end
+    it 'will not parse ""' do
+      expect(parser.text).to_not parse ""
+    end
   end
 
   context "#start_tag" do
-    subject { parser.start_tag }
-
-    it { should     parse %q{<tofu art="party">} }
-    it { should     parse %q{<tofu art="party" synth="letterpress">} }
-    it { should     parse "<tofu>" }
-    it { should_not parse "</tofu>" }
-    it { should_not parse "<tofu" }
-    it { should_not parse "tofu>" }
+    it 'will parse %q{<tofu art="party">}' do
+      expect(parser.start_tag).to parse %q{<tofu art="party">}
+    end
+    it 'will parse %q{<tofu art="party" synth="letterpress">}' do
+      expect(parser.start_tag).to parse %q{<tofu art="party" synth="letterpress">}
+    end
+    it 'will parse "<tofu>"' do
+      expect(parser.start_tag).to parse "<tofu>"
+    end
+    it 'will not parse "</tofu>"' do
+      expect(parser.start_tag).to_not parse "</tofu>"
+    end
+    it 'will not parse "<tofu"' do
+      expect(parser.start_tag).to_not parse "<tofu"
+    end
+    it 'will not parse "tofu>"' do
+      expect(parser.start_tag).to_not parse "tofu>"
+    end
   end
 
   context "#end_tag" do
-    subject { parser.end_tag }
+    it 'will parse "</tofu>"' do
+      expect(parser.end_tag).to parse "</tofu>"
+    end
+    it 'will not parse "<tofu>"' do
+      expect(parser.end_tag).to_not parse "<tofu>"
+    end
+    it 'will not parse "<tofu"' do
+      expect(parser.end_tag).to_not parse "<tofu"
+    end
+    it 'will not parse "/tofu>"' do
+      expect(parser.end_tag).to_not parse "/tofu>"
+    end
+  end
 
-    it { should     parse "</tofu>" }
-    it { should_not parse "<tofu>" }
-    it { should_not parse "<tofu" }
-    it { should_not parse "/tofu>" }
+  context "#empty_br" do
+    it 'will parse html br tags' do
+      expect(parser.empty_br).to parse '<br>'
+    end
   end
 
   context "#empty_tag" do
-    subject { parser.empty_tag }
-
-    it { should     parse %q{<tofu />} }
-    it { should     parse %q{<tofu art="party" />} }
-    it { should     parse %q{<tofu art="party" synth="letterpress" />} }
-    it { should_not parse "<tofu>" }
-    it { should_not parse "</tofu>" }
-    it { should_not parse "<tofu" }
-    it { should_not parse "/tofu>" }
+    it 'will parse %q{<tofu />}' do
+      expect(parser.empty_tag).to parse %q{<tofu />}
+    end
+    it 'will parse %q{<tofu art="party" />}' do
+      expect(parser.empty_tag).to parse %q{<tofu art="party" />}
+    end
+    it 'will parse %q{<tofu art="party" synth="letterpress" />}' do
+      expect(parser.empty_tag).to parse %q{<tofu art="party" synth="letterpress" />}
+    end
+    it 'will not parse "<tofu>"' do
+      expect(parser.empty_tag).to_not parse "<tofu>"
+    end
+    it 'will not parse "</tofu>"' do
+      expect(parser.empty_tag).to_not parse "</tofu>"
+    end
+    it 'will not parse "<tofu"' do
+      expect(parser.empty_tag).to_not parse "<tofu"
+    end
+    it 'will not parse "/tofu>"' do
+      expect(parser.empty_tag).to_not parse "/tofu>"
+    end
   end
 
   context "#name" do
-    subject { parser.name }
-
-    it { should     parse "p" }
-    it { should     parse "h1" }
-    it { should_not parse "1h" }
-    it { should_not parse "h 1" }
+    it 'will parse "p"' do
+      expect(parser.name).to parse "p"
+    end
+    it 'will parse "h1"' do
+      expect(parser.name).to parse "h1"
+    end
+    it 'will not parse "1h"' do
+      expect(parser.name).to_not parse "1h"
+    end
+    it 'will not parse "h 1"' do
+      expect(parser.name).to_not parse "h 1"
+    end
   end
 
   context "#attribute" do
-    subject { parser.attribute }
-
-    it { should     parse %q{art="party organic"} }
-    it { should     parse %q{art='party organic'} }
-    it { should     parse %q{art="party'organic"} }
-    it { should     parse %q{art='party"organic'} }
-    it { should_not parse "art" }
-    it { should_not parse "art=" }
-    it { should_not parse "art=party" }
-    it { should_not parse %q{="party organic"} }
-    it { should_not parse %q{art="party organic'} }
-    it { should_not parse %q{art='party organic"} }
+    it 'will parse %q{art="party organic"}' do
+      expect(parser.attribute).to parse %q{art="party organic"}
+    end
+    it 'will parse %q{art=\'party organic\'}' do
+      expect(parser.attribute).to parse %q{art='party organic'}
+    end
+    it 'will parse %q{art="party\'organic"}' do
+      expect(parser.attribute).to parse %q{art="party'organic"}
+    end
+    it 'will parse %q{art=\'party"organic\'}' do
+      expect(parser.attribute).to parse %q{art='party"organic'}
+    end
+    it 'will not parse "art"' do
+      expect(parser.attribute).to_not parse "art"
+    end
+    it 'will not parse "art="' do
+      expect(parser.attribute).to_not parse "art="
+    end
+    it 'will not parse "art=party"' do
+      expect(parser.attribute).to_not parse "art=party"
+    end
+    it 'will not parse %q{="party organic"}' do
+      expect(parser.attribute).to_not parse %q{="party organic"}
+    end
+    it 'will not parse %q{art="party organic\'}' do
+      expect(parser.attribute).to_not parse %q{art="party organic'}
+    end
+    it 'will not parse %q{art=\'party organic"}' do
+      expect(parser.attribute).to_not parse %q{art='party organic"}
+    end
   end
 
   context "#parse" do
-    subject { parser.parse(html) }
+    RSpec::Matchers.define :convert do |html|
+      match do |parser|
+        @actual = parser.parse(html)
+        @actual == @expected
+      end
 
-    context "single tag" do
-      let(:html) { "<p>messenger</p>" }
+      chain :to do |ast|
+        @expected = ast
+      end
+      attr_reader :expected
+
+      failure_message do
+        %Q{expected "#{html}" to parse to "#{@expected.inspect}" but was #{@result.inspect}}
+      end
 
-      it do
-        should == [
+      diffable
+    end
+
+    context "single tag" do
+      it 'is parsed as a single element' do
+        expect(parser).to convert("<p>messenger</p>").to([
           {
             element: {
               start_tag: {name: "p", attributes: []},
@@ -106,29 +229,41 @@ describe Upmark::Parser::XML do
               children:  [{text: "messenger"}]
             }
           }
-        ]
+        ])
+      end
+
+      it 'will ignore empty text tags' do
+        expect(parser).to convert('<p> </p>').to(
+          [
+            {
+              empty:
+                {
+                  start_tag: { name: "p", attributes: [] },
+                  end_tag:   { name: "p" },
+                }
+            }
+          ]
+        )
       end
     end
 
     context "empty tag" do
-      let(:html) { "<br />" }
-
-      it do
-        should == [
+      it 'is parsed an empty_tag element' do
+        expect(parser).to convert("<br />").to([
           {
             element: {
               empty_tag: {name: "br", attributes: []}
             }
           }
-        ]
+        ])
       end
     end
 
     context "single tag with attributes" do
       let(:html) { %q{<a href="http://helvetica.com/" title="art party organic">messenger bag skateboard</a>} }
 
-      it do
-        should == [
+      it 'is parsed an element with an attribute subtree' do
+        expect(parser).to convert(html).to([
           {
             element: {
               start_tag: {
@@ -142,15 +277,15 @@ describe Upmark::Parser::XML do
               children: [{text: "messenger bag skateboard"}]
             }
           }
-        ]
+        ])
       end
     end
 
     context "multiple inline tags" do
       let(:html) { "<p>messenger</p><p>bag</p><p>skateboard</p>" }
 
-      it do
-        should == [
+      it 'converts to multiple elements' do
+        expect(parser).to convert(html).to([
           {
             element: {
               start_tag: {name: "p", attributes: []},
@@ -170,15 +305,15 @@ describe Upmark::Parser::XML do
               children:  [{text: "skateboard"}]
             }
           }
-        ]
+        ])
       end
     end
 
     context "multiple tags" do
       let(:html) { "<p>messenger</p>\n<p>bag</p>\n<p>skateboard</p>" }
 
-      it do
-        should == [
+      it 'converts to multiple elements' do
+        expect(parser).to convert(html).to([
           {
             element: {
               start_tag: {name: "p", attributes: []},
@@ -202,15 +337,15 @@ describe Upmark::Parser::XML do
               children:  [{text: "skateboard"}]
             }
           }
-        ]
+        ])
       end
     end
 
     context "nested tags" do
       let(:html) { "<p>messenger <strong>bag</strong> skateboard</p>" }
 
-      it do
-        should == [
+      it 'converts to multiple nested elements' do
+        expect(parser).to convert(html).to([
           {
             element: {
               start_tag: {name: "p", attributes: []},
@@ -230,7 +365,7 @@ describe Upmark::Parser::XML do
               ]
             }
           }
-        ]
+        ])
       end
     end
   end

data/spec/unit/lib/upmark/transform/markdown_spec.rb

@@ -1,10 +1,18 @@
-require "spec_helper"
+RSpec.describe Upmark::Transform::Markdown do
+  def transform(ast)
+    Upmark::Transform::Markdown.new.apply(ast)
+  end
 
-describe Upmark::Transform::Markdown do
-  let(:transform) { Upmark::Transform::Markdown.new }
+  let(:transformed_ast) { transform(ast) }
 
   context "#apply" do
-    subject { transform.apply(ast) }
+    context '<br>' do
+      let(:ast) { [{ element: { name: 'br' }}] }
+
+      it 'will transform to markdown' do
+        expect(transformed_ast).to eq ["\n"]
+      end
+    end
 
     context "<p>" do
       context "single tag" do
@@ -21,7 +29,11 @@ describe Upmark::Transform::Markdown do
           ]
         end
 
-        it { should == ["messenger bag skateboard\n\n"] }
+        it 'transforms to markdown' do
+          expect(
+            transformed_ast
+          ).to eq(["messenger bag skateboard\n\n"])
+        end
       end
 
       context "multiple tags" do
@@ -52,21 +64,31 @@ describe Upmark::Transform::Markdown do
           ]
         end
 
-        it { should == ["messenger\n\n", "bag\n\n", "skateboard\n\n"] }
+        it 'transforms to markdown' do
+          expect(
+            transformed_ast
+          ).to eq(["messenger\n\n", "bag\n\n", "skateboard\n\n"])
+        end
       end
     end
 
     context "<a>" do
       context "single tag" do
         let(:ast) do
+          a_tag(
+            href: "http://helvetica.com/",
+            title: "art party organic",
+          )
+        end
+
+        def a_tag(attributes)
           [
             {
               element: {
                 name: "a",
-                attributes: [
-                  {name: "href",  value: "http://helvetica.com/"},
-                  {name: "title", value: "art party organic"}
-                ],
+                attributes: attributes.map do |key, value|
+                  { name: key.to_s, value: value }
+                end,
                 children: [{text: "messenger bag skateboard"}],
                 ignore: false
               }
@@ -74,22 +96,50 @@ describe Upmark::Transform::Markdown do
           ]
         end
 
-        it { should == [%q{[messenger bag skateboard](http://helvetica.com/ "art party organic")}] }
+        it 'transforms to markdown' do
+          expect(
+            transformed_ast
+          ).to eq([%q{[messenger bag skateboard](http://helvetica.com/ "art party organic")}])
+        end
+
+        it 'transforms mailto to markdown' do
+          expect(
+            transform a_tag(href: 'mailto:a@example.com', title: 'Some Path')
+          ).to eq([%q{[messenger bag skateboard](mailto:a@example.com "Some Path")}])
+        end
+
+        it 'strips local urls to their text' do
+          expect(
+            transform a_tag(href: 'file://some/path', title: 'Some Path')
+          ).to eq ['messenger bag skateboard']
+        end
+
+        it 'strips relative urls to their alt text' do
+          expect(
+            transform a_tag(src: 'some/path', title: 'Some Path')
+          ).to eq ['messenger bag skateboard']
+        end
       end
     end
 
     context "<img>" do
       context "empty tag" do
         let(:ast) do
+          img(
+            src:   "http://helvetica.com/image.gif",
+            title: "art party organic",
+            alt:   "messenger bag skateboard",
+          )
+        end
+
+        def img(attributes)
           [
             {
               element: {
                 name: "img",
-                attributes: [
-                  {name: "src",   value: "http://helvetica.com/image.gif"},
-                  {name: "title", value: "art party organic"},
-                  {name: "alt",   value: "messenger bag skateboard"}
-                ],
+                attributes: attributes.map do |key, value|
+                  { name: key.to_s, value: value }
+                end,
                 children: [],
                 ignore: false
               }
@@ -97,7 +147,29 @@ describe Upmark::Transform::Markdown do
           ]
         end
 
-        it { should == [%q{![messenger bag skateboard](http://helvetica.com/image.gif "art party organic")}] }
+        it 'transforms to markdown' do
+          expect(
+            transformed_ast
+          ).to eq([%q{![messenger bag skateboard](http://helvetica.com/image.gif "art party organic")}])
+        end
+
+        it 'strips file urls to their alt text or title' do
+          expect(
+            transform img(src: 'file://some/path', alt: 'Some', title: 'Path')
+          ).to eq ['Some']
+          expect(
+            transform img(src: 'file://some/path', title: 'Some Path')
+          ).to eq ['Some Path']
+        end
+
+        it 'strips relative urls to their alt text' do
+          expect(
+            transform img(src: 'some/path', alt: 'Some', title: 'Path')
+          ).to eq ['Some']
+          expect(
+            transform img(src: 'some/path', title: 'Some Path')
+          ).to eq ['Some Path']
+        end
       end
     end
   end