card 1.18.6 → 1.19.0

data/spec/lib/card/diff_spec.rb

@@ -1,9 +1,9 @@
 # -*- encoding : utf-8 -*-
 # !/usr/bin/env ruby
 
-require 'card/diff'
+require "card/content/diff"
 
-describe Card::Diff do
+describe Card::Content::Diff do
   def del text
     "<del class='diffdel diff-red'>#{text}</del>"
   end
@@ -17,122 +17,122 @@ describe Card::Diff do
   end
 
   def diff old_s, new_s, opts=@opts
-    Card::Diff.complete(old_s, new_s, opts)
+    Card::Content::Diff.complete(old_s, new_s, opts)
   end
 
   def summary old_s, new_s, opts=@opts
-    Card::Diff.summary(old_s, new_s, opts)
+    Card::Content::Diff.summary(old_s, new_s, opts)
   end
 
-  old_p = '<p>old</p>'
-  new_p = '<p>new</p>'
-  new_h = '<h1>new</h1>'
+  old_p = "<p>old</p>"
+  new_p = "<p>new</p>"
+  new_h = "<h1>new</h1>"
   def p_diff
-    diff '<p>old</p>', '<p>new</p>'
+    diff "<p>old</p>", "<p>new</p>"
   end
 
-  describe 'traffic light' do
-    it 'is green for addition' do
-      a = 'a'
-      b = 'a b'
-      db = Card::Diff.new(a, b)
+  describe "traffic light" do
+    it "is green for addition" do
+      a = "a"
+      b = "a b"
+      db = Card::Content::Diff.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.new(a, b)
+    it "is red for deletion" do
+      a = "a"
+      b = ""
+      db = Card::Content::Diff.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.new(a, b)
+    it "is green and red for change" do
+      a = "a"
+      b = "b"
+      db = Card::Content::Diff.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.new(a, b)
+    it "is off for no change" do
+      a = "a"
+      b = "a"
+      db = Card::Content::Diff.new(a, b)
       expect(db.green?).to be_falsey
       expect(db.red?).to be_falsey
     end
   end
 
-  describe 'summary' do
+  describe "summary" do
     before(:all) do
       @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>'
+    it "omits unchanged text" do
+      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'
+    it "no ellipsis if changes fit exactly" do
+      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'
+    it "green ellipsis if added text does not fit" do
+      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'
+    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(
         "#{del '123'}#{ins '456'}..."
       )
     end
 
-    it 'red ellipsis if deleted text partially fits' do
-      a = '123456'
-      b = '567'
+    it "red ellipsis if deleted text partially fits" do
+      a = "123456"
+      b = "567"
       expect(summary a, b, summary: { length: 4 }).to eq(
-        (del '1...').to_s
+        (del "1...").to_s
       )
     end
 
-    it 'green ellipsis if added text partially fits' do
-      a = '1234'
-      b = '56789'
+    it "green ellipsis if added text partially fits" do
+      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>'
+    it "removes html tags" do
+      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>'
+    it "with html tags in raw format" do
+      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')}"
       )
     end
   end
 
-  context 'html format' do
+  context "html format" do
     before(:all) do
       @opts = { format: :html }
     end
@@ -141,15 +141,15 @@ describe Card::Diff do
       text = "Hello World!\n How are you?"
       expect(diff text, text).to eq(text)
     end
-    it 'preserves html' do
+    it "preserves html" do
       expect(p_diff).to eq("<p>#{del 'old'}#{ins 'new'}</p>")
     end
-    it 'ignores html changes' do
+    it "ignores html changes" do
       expect(diff old_p, new_h).to eq("<h1>#{del 'old'}#{ins 'new'}</h1>")
     end
 
-    it 'diff with multiple paragraphs' do
-      a = '<p>this was the original string</p>'
+    it "diff with multiple paragraphs" do
+      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(
@@ -162,47 +162,47 @@ describe Card::Diff do
     end
   end
 
-  context 'text format' do
+  context "text format" do
     before(:all) do
       @opts = { format: :text }
     end
 
-    it 'removes html' do
+    it "removes html" do
       expect(p_diff).to eq("#{del 'old'}#{ins 'new'}")
     end
 
-    it 'compares complete links' do
-      diff = Card::Diff.complete("[[A]]\n[[B]]", "[[A]]\n[[C]]", format: :html)
+    it "compares complete links" do
+      diff = Card::Content::Diff.complete("[[A]]\n[[B]]", "[[A]]\n[[C]]", format: :html)
       expect(diff).to eq("[[A]]\n#{del '[[B]]'}#{ins '[[C]]'}")
     end
 
-    it 'compares complete nests' do
-      diff = Card::Diff.complete("{{A}}\n{{B}}", "{{A}}\n{{C}}", format: :html)
+    it "compares complete nests" do
+      diff = Card::Content::Diff.complete("{{A}}\n{{B}}", "{{A}}\n{{C}}", format: :html)
       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 }
     end
 
-    it 'excapes html' do
+    it "excapes html" do
       expect(p_diff).to eq("#{tag 'p'}#{del 'old'}#{ins 'new'}#{tag '/p'}")
     end
 
-    it 'diff for tag change' do
+    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'}"))
     end
   end
 
-  context 'pointer format' do
+  context "pointer format" do
     before(:all) do
       @opts = { format: :pointer }
     end
 
-    it 'removes square brackets' do
-      expect(diff '[[Hello]]', '[[Hi]]').to eq(del('Hello') + ins('Hi'))
+    it "removes square brackets" do
+      expect(diff "[[Hello]]", "[[Hi]]").to eq(del("Hello") + ins("Hi"))
     end
   end
 end

data/spec/lib/card/format/nest_spec.rb

@@ -0,0 +1,11 @@
+describe Card::Format::Nest do
+  it "doesn't crash because of a loop in email templates" do
+    # 'follower notification email' in closed view is trapped in a loop of
+    # rendering a user card.
+    # It is expected to stop after a few iterations because we have a maximum
+    # content length for closed view. So if this crashes it's likely that
+    # there is a bug in calculating the @char_count in closed mode.
+    content = render_content "{{Email Templates+*type+by update|content}}"
+    expect(content).to be_truthy
+  end
+end

data/spec/lib/card/format_spec.rb

@@ -1,19 +1,19 @@
 # -*- encoding : utf-8 -*-
 
 describe Card::Format do
-  describe '#show?' do
+  describe "#show?" do
     let(:format) { described_class.new Card.new }
 
     def show_menu? args
       format.show_view?(:menu, args)
     end
-    it 'should respect defaults' do
+    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 respect developer default overrides' do
+    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))
@@ -21,42 +21,42 @@ describe Card::Format do
       expect(show_menu?(optional_menu: :hide)).to be_falsey
     end
 
-    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))
+    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
+      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
+    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
+  describe "format helpers and link building" do
     before :each do
       # should be a way to get these defaults in these tests
-      Card::Env[:host] = '//test.host'
-      Card::Env[:protocol] = 'http:'
+      Card::Env[:host] = "//test.host"
+      Card::Env[:protocol] = "http:"
     end
 
-    let(:card) { Card['Home'] }
+    let(:card) { Card["Home"] }
     let(:text_format) { card.format(:text) }
     let(:html_format) { card.format }
     let(:url_text1) do
-      'with external free link http://localhost:2020/path?cgi=foo&bar=baz'
+      "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]]'
+      "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_text3) { "with internal lik [[A]]" }
+    let(:url_text4) { "with internal lik [[Home|display text]]" }
     let(:url_text5) do
-      'external with port: http://localhost:2020/path?cgi=foo+bar=baz after '
+      "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
@@ -69,12 +69,12 @@ 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>'
+        "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
@@ -82,19 +82,19 @@ describe Card::Format do
       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 '
+        "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
+    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'
+                                        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
+    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}"

data/spec/lib/card/i18n_spec.rb

@@ -0,0 +1,40 @@
+# -*- encoding : utf-8 -*-
+require "pathname"
+
+use_i18_tasks = !(RUBY_VERSION =~ /^(1|2\.0)/)
+if use_i18_tasks
+  require "i18n/tasks"
+end
+
+# Note: I18n::Tasks only knows how to function when run from root of Card GEM,
+# since it locates its configuration file and source to parse relative to this
+
+def card_gem_root
+  Pathname(__FILE__).parent.parent.parent.parent.to_s
+end
+
+RSpec.describe "I18n" do
+  if use_i18_tasks
+    let(:i18n) { Dir.chdir(card_gem_root) { I18n::Tasks::BaseTask.new } }
+    let(:missing_keys) { Dir.chdir(card_gem_root) { i18n.missing_keys } }
+    let(:unused_keys) { Dir.chdir(card_gem_root) { i18n.unused_keys } }
+  end
+
+  it "does not have missing keys" do
+    unless use_i18_tasks
+      skip "upgrade to Ruby 2.1+ and install i18n-tasks gem"
+    end
+    expect(missing_keys).to be_empty,
+      "Missing #{missing_keys.leaves.count} i18n keys, to show them `cd` to " \
+      "root of `card` gem and run `i18n-tasks missing`"
+  end
+
+  it "does not have unused keys" do
+    unless use_i18_tasks
+      skip "upgrade to Ruby 2.1+ and install i18n-tasks gem"
+    end
+    expect(unused_keys).to be_empty,
+      "#{unused_keys.leaves.count} unused i18n keys, to show them `cd` to " \
+      "root of `card` gem and run `i18n-tasks unused`"
+  end
+end

data/spec/lib/card/loader/Modfile

@@ -0,0 +1,2 @@
+mod 'mod1'
+mod 'mod2'

data/spec/lib/card/loader/mod_dirs.rb

@@ -0,0 +1,8 @@
+
+describe Card::Mod::Dirs do
+  it 'loads mods from Modfile' do
+    path = File.expand_path "..", __FILE__
+    tg = Card::Mod::Dirs.new path
+    expect(tg.mods).to eq %w(mod1 mod2)
+  end
+end