card 1.17.4 → 1.18.0

data/spec/lib/card/diff_spec.rb

@@ -1,19 +1,21 @@
 # -*- encoding : utf-8 -*-
-#!/usr/bin/env ruby
+# !/usr/bin/env ruby
 
 require 'card/diff'
 
 describe Card::Diff do
-
   def del text
     "<del class='diffdel diff-red'>#{text}</del>"
   end
+
   def ins text
     "<ins class='diffins diff-green'>#{text}</ins>"
   end
+
   def tag text
     "&lt;#{text}&gt;"
   end
+
   def diff old_s, new_s, opts=@opts
     Card::Diff.complete(old_s, new_s, opts)
   end
@@ -22,7 +24,6 @@ describe Card::Diff do
     Card::Diff.summary(old_s, new_s, opts)
   end
 
-
   old_p = '<p>old</p>'
   new_p = '<p>new</p>'
   new_h = '<h1>new</h1>'
@@ -32,110 +33,108 @@ describe Card::Diff do
 
   describe 'traffic light' do
     it 'is green for addition' do
-      a = "a"
-      b = "a b"
-      db = Card::Diff::DiffBuilder.new(a,b)
+      a = 'a'
+      b = 'a b'
+      db = Card::Diff::DiffBuilder.new(a, b)
       expect(db.green?).to be_truthy
       expect(db.red?).to be_falsey
     end
     it 'is red for deletion' do
-      a = "a"
-      b = ""
-      db = Card::Diff::DiffBuilder.new(a,b)
+      a = 'a'
+      b = ''
+      db = Card::Diff::DiffBuilder.new(a, b)
       expect(db.green?).to be_falsey
       expect(db.red?).to be_truthy
     end
     it 'is green and red for change' do
-      a = "a"
-      b = "b"
-      db = Card::Diff::DiffBuilder.new(a,b)
+      a = 'a'
+      b = 'b'
+      db = Card::Diff::DiffBuilder.new(a, b)
       expect(db.green?).to be_truthy
       expect(db.red?).to be_truthy
     end
     it 'is off for no change' do
-      a = "a"
-      b = "a"
-      db = Card::Diff::DiffBuilder.new(a,b)
+      a = 'a'
+      b = 'a'
+      db = Card::Diff::DiffBuilder.new(a, b)
       expect(db.green?).to be_falsey
       expect(db.red?).to be_falsey
     end
   end
 
-
   describe 'summary' do
     before(:all) do
-      @opts = {format: :html}
+      @opts = { format: :html }
     end
 
     it 'omits unchanged text' do
-      a = "<p>this was the original string</p>"
-      b = "<p>this is the new string</p>"
+      a = '<p>this was the original string</p>'
+      b = '<p>this is the new string</p>'
       expect(summary a, b).to eq(
         "...#{del 'was'}#{ins 'is'}...#{del 'original'}#{ins 'new'}..."
       )
     end
 
     it 'no ellipsis if changes fit exactly' do
-      a = "123"
-      b = "456"
-      expect(summary a, b, summary: {length: 6}).to eq(
+      a = '123'
+      b = '456'
+      expect(summary a, b, summary: { length: 6 }).to eq(
         "#{del '123'}#{ins '456'}"
       )
     end
 
     it 'green ellipsis if added text does not fit' do
-      a = "123"
-      b = "5678"
-      expect(summary a, b, summary: {length: 6}).to eq(
+      a = '123'
+      b = '5678'
+      expect(summary a, b, summary: { length: 6 }).to eq(
         "#{del '123'}#{ins '...'}"
       )
     end
 
     it 'neutral ellipsis if complete change does not fit' do
-      a = "123 123"
-      b = "456 456"
-      expect(summary a, b, summary: {length: 9}).to eq(
+      a = '123 123'
+      b = '456 456'
+      expect(summary a, b, summary: { length: 9 }).to eq(
         "#{del '123'}#{ins '456'}..."
       )
     end
 
     it 'red ellipsis if deleted text partially fits' do
-      a = "123456"
-      b = "567"
-      expect(summary a, b, summary: {length: 4}).to eq(
-        "#{del '1...'}"
+      a = '123456'
+      b = '567'
+      expect(summary a, b, summary: { length: 4 }).to eq(
+        (del '1...').to_s
       )
     end
 
     it 'green ellipsis if added text partially fits' do
-      a = "1234"
-      b = "56789"
-      expect(summary a, b, summary: {length: 8}).to eq(
+      a = '1234'
+      b = '56789'
+      expect(summary a, b, summary: { length: 8 }).to eq(
         "#{del '1234'}#{ins '5...'}"
       )
     end
 
     it 'removes html tags' do
-      a = "<a>A</a>"
-      b = "<b>B</b>"
+      a = '<a>A</a>'
+      b = '<b>B</b>'
       expect(summary a, b, format: :html).to eq(
         "#{del 'A'}#{ins 'B'}"
       )
     end
 
     it 'with html tags in raw format' do
-      a = "<a>1</a>"
-      b = "<b>1</b>"
+      a = '<a>1</a>'
+      b = '<b>1</b>'
       expect(summary a, b, format: :raw).to eq(
-        "#{del( tag 'a' )}#{ins(tag 'b')}...#{del( tag '/a' )}#{ins(tag '/b')}"
+        "#{del(tag 'a')}#{ins(tag 'b')}...#{del(tag '/a')}#{ins(tag '/b')}"
       )
     end
-
   end
 
-  context "html format" do
+  context 'html format' do
     before(:all) do
-      @opts = {format: :html}
+      @opts = { format: :html }
     end
 
     it "doesn't change a text without changes" do
@@ -150,22 +149,22 @@ describe Card::Diff do
     end
 
     it 'diff with multiple paragraphs' do
-      a = "<p>this was the original string</p>"
+      a = '<p>this was the original string</p>'
       b = "<p>this is</p>\n<p> the new string</p>\n<p>around the world</p>"
 
       expect(diff a, b).to eq(
-          "<p>this #{del 'was'}#{ins 'is'}</p>"+
-          "\n<p> the " +
-          "#{del 'original'}#{ins 'new'}" +
-          " string</p>\n" +
-          "<p>#{ins 'around the world'}</p>"
-          )
+        "<p>this #{del 'was'}#{ins 'is'}</p>"\
+        "\n<p> the " \
+        "#{del 'original'}#{ins 'new'}" \
+        " string</p>\n" \
+        "<p>#{ins 'around the world'}</p>"
+      )
     end
   end
 
-  context "text format" do
+  context 'text format' do
     before(:all) do
-      @opts = {format: :text}
+      @opts = { format: :text }
     end
 
     it 'removes html' do
@@ -174,19 +173,18 @@ describe Card::Diff do
 
     it 'compares complete links' do
       diff = Card::Diff.complete("[[A]]\n[[B]]", "[[A]]\n[[C]]", format: :html)
-      expect(diff).to eq( "[[A]]\n#{del '[[B]]'}#{ins '[[C]]'}")
+      expect(diff).to eq("[[A]]\n#{del '[[B]]'}#{ins '[[C]]'}")
     end
 
-    it 'compares complete inclusions' do
+    it 'compares complete nests' do
       diff = Card::Diff.complete("{{A}}\n{{B}}", "{{A}}\n{{C}}", format: :html)
-      expect(diff).to eq( "{{A}}\n#{del '{{B}}'}#{ins '{{C}}'}")
+      expect(diff).to eq("{{A}}\n#{del '{{B}}'}#{ins '{{C}}'}")
     end
-
   end
 
-  context "raw format" do
+  context 'raw format' do
     before(:all) do
-      @opts = {format: :raw}
+      @opts = { format: :raw }
     end
 
     it 'excapes html' do
@@ -194,17 +192,17 @@ describe Card::Diff do
     end
 
     it 'diff for tag change' do
-      expect(diff old_p, new_h).to eq( del("#{tag 'p'}old#{tag '/p'}") + ins("#{tag 'h1'}new#{tag '/h1'}") )
+      expect(diff old_p, new_h).to eq(del("#{tag 'p'}old#{tag '/p'}") + ins("#{tag 'h1'}new#{tag '/h1'}"))
     end
   end
 
   context 'pointer format' do
     before(:all) do
-      @opts = {format: :pointer}
+      @opts = { format: :pointer }
     end
 
     it 'removes square brackets' do
-      expect(diff "[[Hello]]", "[[Hi]]").to eq( del('Hello') + ins('Hi') )
+      expect(diff '[[Hello]]', '[[Hi]]').to eq(del('Hello') + ins('Hi'))
     end
   end
 end

data/spec/lib/card/format_spec.rb

@@ -1,33 +1,37 @@
 # -*- encoding : utf-8 -*-
 
 describe Card::Format do
-
   describe '#show?' do
     let(:format) { described_class.new Card.new }
 
-    it "should respect defaults" do
-      expect(format.show_view?( :menu, default_visibility: :show )).to be_truthy
-      expect(format.show_view?( :menu, default_visibility: :hide )).to be_falsey
-      expect(format.show_view?( :menu, {}                          )).to be_truthy
+    def show_menu? args
+      format.show_view?(:menu, args)
     end
-
-    it "should respect developer default overrides" do
-      expect(format.show_view?( :menu, optional_menu: :show, default_visibility: :hide )).to be_truthy
-      expect(format.show_view?( :menu, optional_menu: :hide, default_visibility: :show )).to be_falsey
-      expect(format.show_view?( :menu, optional_menu: :hide                             )).to be_falsey
+    it 'should respect defaults' do
+      expect(show_menu?(default_visibility: :show)).to be_truthy
+      expect(show_menu?(default_visibility: :hide)).to be_falsey
+      expect(show_menu?({})).to be_truthy
     end
 
-    it "should handle args from inclusions" do
-      expect(format.show_view?( :menu, show: 'menu', default_visibility: :hide         )).to be_truthy
-      expect(format.show_view?( :menu, hide: 'menu, paging', default_visibility: :show )).to be_falsey
-      expect(format.show_view?( :menu, show: 'menu', optional_menu: :hide              )).to be_truthy
+    it 'should respect developer default overrides' do
+      expect(show_menu?(optional_menu: :show, default_visibility: :hide))
+        .to be_truthy
+      expect(show_menu?(optional_menu: :hide, default_visibility: :show))
+        .to be_falsey
+      expect(show_menu?(optional_menu: :hide)).to be_falsey
     end
 
-    it "should handle hard developer overrides" do
-      expect(format.show_view?( :menu, optional_menu: :always, hide: 'menu' )).to be_truthy
-      expect(format.show_view?( :menu, optional_menu: :never,  show: 'menu' )).to be_falsey
+    it 'should handle args from nests' do
+      expect(show_menu?(show: 'menu', default_visibility: :hide)).to be_truthy
+      expect(show_menu?(hide: 'menu, paging', default_visibility: :show))
+        .to be_falsey
+      expect(show_menu?(show: 'menu', optional_menu: :hide)).to be_truthy
     end
 
+    it 'should handle hard developer overrides' do
+      expect(show_menu?(optional_menu: :always, hide: 'menu')).to be_truthy
+      expect(show_menu?(optional_menu: :never,  show: 'menu')).to be_falsey
+    end
   end
 
   describe 'format helpers and link building' do
@@ -38,15 +42,21 @@ describe Card::Format do
     end
 
     let(:card) { Card['Home'] }
-    let(:text_format) { card.format(:text)}
+    let(:text_format) { card.format(:text) }
     let(:html_format) { card.format }
-    let(:url_text1) { 'with external free link http://localhost:2020/path?cgi=foo&bar=baz' }
-    let(:url_text2) { 'with external in link syntax: [[http://brain.org/Home|extra]]' }
+    let(:url_text1) do
+      'with external free link http://localhost:2020/path?cgi=foo&bar=baz'
+    end
+    let(:url_text2) do
+      'with external in link syntax: [[http://brain.org/Home|extra]]'
+    end
     let(:url_text3) { 'with internal lik [[A]]' }
     let(:url_text4) { 'with internal lik [[Home|display text]]' }
-    let(:url_text5) { 'external with port: http://localhost:2020/path?cgi=foo+bar=baz after '}
+    let(:url_text5) do
+      'external with port: http://localhost:2020/path?cgi=foo+bar=baz after '
+    end
 
-    it "should format links" do
+    it 'should format links' do
       cobj = Card::Content.new url_text1, text_format
       expect(cobj.to_s).to eq url_text1
       cobj = Card::Content.new url_text2, text_format
@@ -59,24 +69,35 @@ describe Card::Format do
       expect(cobj.to_s).to eq url_text5
     end
 
-    it "should format html links" do
+    it 'should format html links' do
       cobj = Card::Content.new url_text1, html_format
-      expect(cobj.to_s).to eq "with external free link <a target=\"_blank\" class=\"external-link\" href=\"http://localhost:2020/path?cgi=foo&amp;bar=baz\">http://localhost:2020/path?cgi=foo&bar=baz</a>"
-      cobj = Card::Content.new url_text2+url_text3+url_text4, html_format
-      expect(cobj.to_s).to eq url_text2+url_text3+url_text4
+      expect(cobj.to_s).to eq(
+        'with external free link <a target="_blank" class="external-link" ' \
+        'href="http://localhost:2020/path?cgi=foo&amp;bar=baz">' \
+        'http://localhost:2020/path?cgi=foo&bar=baz</a>'
+      )
+      cobj = Card::Content.new url_text2 + url_text3 + url_text4, html_format
+      expect(cobj.to_s).to eq url_text2 + url_text3 + url_text4
       cobj = Card::Content.new url_text5, html_format
-      expect(cobj.to_s).to eq "external with port: <a target=\"_blank\" class=\"external-link\" href=\"http://localhost:2020/path?cgi=foo+bar=baz\">http://localhost:2020/path?cgi=foo+bar=baz</a> after "
+      expect(cobj.to_s).to eq(
+        'external with port: <a target="_blank" class="external-link" ' \
+        'href="http://localhost:2020/path?cgi=foo+bar=baz">' \
+        'http://localhost:2020/path?cgi=foo+bar=baz</a> after '
+      )
     end
 
-    it "formats page_path" do
-      expect(text_format.page_path card.cardname).to eq '/'+card.name
-      expect(html_format.page_path card.cardname).to eq '/'+card.name
-      expect(text_format.page_path card.cardname, format: 'txt', opt1: 11, opt2: 'foo').to eq "/#{card.name}.txt?opt1=11&opt2=foo"
+    it 'formats page_path' do
+      expect(text_format.page_path(card.cardname)).to eq '/' + card.name
+      expect(html_format.page_path(card.cardname)).to eq '/' + card.name
+      page_path = text_format.page_path card.cardname,
+                                        format: 'txt', opt1: 11, opt2: 'foo'
+      expect(page_path).to eq "/#{card.name}.txt?opt1=11&opt2=foo"
     end
 
-    it "fomats full path and url" do
-      expect(text_format.card_path card.name).to eq "/#{card.name}"
-      expect(html_format.card_url card.name).to eq "http://test.host/#{card.name}"
+    it 'fomats full path and url' do
+      expect(text_format.card_path(card.name)).to eq "/#{card.name}"
+      expect(html_format.card_url(card.name))
+        .to eq "http://test.host/#{card.name}"
     end
   end
 end

data/spec/lib/card/loader_spec.rb

@@ -1,39 +1,37 @@
 # -*- encoding : utf-8 -*-
 
-=begin
-describe Card::Loader do
-  # let(:card_double) { double "Card" }
-  # let(:pat_all_double) { proxy Card::AllSet }
-  # let(:format_double) { proxy Card::Format }
-  # let(:html_format_double) { proxy Card::HtmlFormat }
-  # it "should auto-load Card class methods from lib/card and mods" do
-  #   #xpect(Card).to receive(:load_mods)
-  #   #
-  #   card = Card[:all]
-  #   expect(card_double).to receive(:load_formats)
-  #   #expect(Card).to receive(:load_sets)
-  #   #expect(Card).to receive(:tracks).with(:any_args) # so Card still loads without core in failure testing
-  #   Card[:all]
-  #   #expect(Card.instance_method(:version)).to be
-  #   # allow(Card).to receive(:version)
-  #   # expect(Card.instance_method(:type_card)).to be
-  #   # allow(Card).to receive(:file_path_sdfs)
-  #   #expect(Card.instance_method(:file_path)).to be
-  # end
-  # it "should define Card methods from modules" do
-  #   expect(Card.instance_method(:set_modules)).to be
-  # end
-  # it "should define Formatter methods from modules" do
-  #   #expect(Card.instance_method(:render_core)).to be
-  #   expect(Card.instance_method(:_render_raw)).to be
-  #   expect(Card.instance_method(:render_core)).to be
-  #   expect(Card.instance_method(:_render_raw)).to be
-  # end
-  # it "should define Formatter methods from modules" do
-  #   expect(html_format_double.method(:render_core)).to be
-  #   expect(html_format_double.method(:_render_raw)).to be
-  #   expect(html_format_double.method(:render_core)).to be
-  #   expect(html_format_double.method(:_render_raw)).to be
-  # end
-end
-=end
+# describe Card::Loader do
+#   # let(:card_double) { double "Card" }
+#   # let(:pat_all_double) { proxy Card::AllSet }
+#   # let(:format_double) { proxy Card::Format }
+#   # let(:html_format_double) { proxy Card::HtmlFormat }
+#   # it "should auto-load Card class methods from lib/card and mods" do
+#   #   #xpect(Card).to receive(:load_mods)
+#   #   #
+#   #   card = Card[:all]
+#   #   expect(card_double).to receive(:load_formats)
+#   #   #expect(Card).to receive(:load_sets)
+#   #   #expect(Card).to receive(:tracks).with(:any_args) # so Card still loads without core in failure testing
+#   #   Card[:all]
+#   #   #expect(Card.instance_method(:version)).to be
+#   #   # allow(Card).to receive(:version)
+#   #   # expect(Card.instance_method(:type_card)).to be
+#   #   # allow(Card).to receive(:file_path_sdfs)
+#   #   #expect(Card.instance_method(:file_path)).to be
+#   # end
+#   # it "should define Card methods from modules" do
+#   #   expect(Card.instance_method(:set_modules)).to be
+#   # end
+#   # it "should define Formatter methods from modules" do
+#   #   #expect(Card.instance_method(:render_core)).to be
+#   #   expect(Card.instance_method(:_render_raw)).to be
+#   #   expect(Card.instance_method(:render_core)).to be
+#   #   expect(Card.instance_method(:_render_raw)).to be
+#   # end
+#   # it "should define Formatter methods from modules" do
+#   #   expect(html_format_double.method(:render_core)).to be
+#   #   expect(html_format_double.method(:_render_raw)).to be
+#   #   expect(html_format_double.method(:render_core)).to be
+#   #   expect(html_format_double.method(:_render_raw)).to be
+#   # end
+# end