card 1.93.3 → 1.93.4

data/spec/lib/card/diff_spec.rb

@@ -1,208 +0,0 @@
-# -*- encoding : utf-8 -*-
-# !/usr/bin/env ruby
-
-require "card/content/diff"
-
-describe Card::Content::Diff do
-  def del text
-    "<del class='diffdel diff-deleted'>#{text}</del>"
-  end
-
-  def ins text
-    "<ins class='diffins diff-added'>#{text}</ins>"
-  end
-
-  def tag text
-    "&lt;#{text}&gt;"
-  end
-
-  def diff old_s, new_s, opts=@opts
-    Card::Content::Diff.complete(old_s, new_s, opts)
-  end
-
-  def summary old_s, new_s, opts=@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>"
-  def p_diff
-    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::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::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::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::Content::Diff.new(a, b)
-      expect(db.green?).to be_falsey
-      expect(db.red?).to be_falsey
-    end
-  end
-
-  describe "summary" do
-    before(:all) do
-      @opts = { diff_format: :html }
-    end
-
-    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"
-      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(
-        "#{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(
-        "#{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...").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(
-        "#{del '1234'}#{ins '5...'}"
-      )
-    end
-
-    it "removes html tags" do
-      a = "<a>A</a>"
-      b = "<b>B</b>"
-      expect(summary a, b, diff_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>"
-      expect(summary a, b, diff_format: :raw).to eq(
-        "#{del(tag 'a')}#{ins(tag 'b')}...#{del(tag '/a')}#{ins(tag '/b')}"
-      )
-    end
-  end
-
-  context "html format" do
-    before(:all) do
-      @opts = { diff_format: :html }
-    end
-
-    it "doesn't change a text without changes" do
-      text = "Hello World!\n How are you?"
-      expect(diff text, text).to eq(text)
-    end
-    it "preserves html" do
-      expect(p_diff).to eq("<p>#{del 'old'}#{ins 'new'}</p>")
-    end
-    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>"
-      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>"
-      )
-    end
-  end
-
-  context "text format" do
-    before(:all) do
-      @opts = { diff_format: :text }
-    end
-
-    it "removes html" do
-      expect(p_diff).to eq("#{del 'old'}#{ins 'new'}")
-    end
-
-    it "compares complete links" do
-      diff = Card::Content::Diff.complete("[[A]]\n[[B]]", "[[A]]\n[[C]]", diff_format: :html)
-      expect(diff).to eq("[[A]]\n#{del '[[B]]'}#{ins '[[C]]'}")
-    end
-
-    it "compares complete nests" do
-      diff = Card::Content::Diff.complete("{{A}}\n{{B}}", "{{A}}\n{{C}}", diff_format: :html)
-      expect(diff).to eq("{{A}}\n#{del '{{B}}'}#{ins '{{C}}'}")
-    end
-  end
-
-  context "raw format" do
-    before(:all) do
-      @opts = { diff_format: :raw }
-    end
-
-    it "excapes html" do
-      expect(p_diff).to eq("#{tag 'p'}#{del 'old'}#{ins 'new'}#{tag '/p'}")
-    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'}"))
-    end
-  end
-
-  context "pointer format" do
-    before(:all) do
-      @opts = { diff_format: :pointer }
-    end
-
-    it "removes square brackets" do
-      expect(diff "[[Hello]]", "[[Hi]]").to eq(del("Hello<br>") + ins("Hi<br>"))
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-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/render_spec.rb

@@ -1,26 +0,0 @@
-describe Card::Format::Render do
-  describe "render" do
-    it "return nil with 'optional: :hide' argument" do
-      rendered = Card["A"].format(:html).render(:open, optional: :hide)
-      expect(rendered).to be_blank
-    end
-  end
-
-  describe "view cache" do
-    before { Cardio.config.view_cache = true }
-
-    let(:cache_key) do
-      "z-Card::Format::HtmlFormat-normal-home_view:content;"\
-      "nest_name:Z;nest_syntax:Z|content;view:contentcontent:show"
-    end
-
-    subject { Card::Cache[Card::View] }
-
-    it "can be changed with nest option" do
-      is_expected.to receive(:fetch).with cache_key
-      render_content "{{Z|content}}"
-      is_expected.not_to receive(:fetch)
-      render_content "{{Z|cache:never}}"
-    end
-  end
-end

data/spec/lib/card/format_spec.rb

@@ -1,117 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Format do
-  describe "#show_view?" do
-    let(:format) { described_class.new Card.new }
-
-    def show_menu? args, default_viz=:show
-      args.merge! optional: true
-      format.with_voo(Card::View.new format, :nonview, args) do
-        format.show_view?(:menu, default_viz)
-      end
-    end
-
-    it "respects defaults" do
-      expect(show_menu?({}, :show)).to be_truthy
-      expect(show_menu?({}, :hide)).to be_falsey
-      expect(show_menu?({})).to be_truthy
-    end
-
-    it "respects developer defaults" do
-      expect(show_menu?({ show: "menu" }, :hide)).to be_truthy
-      expect(show_menu?({ hide: "menu" }, :show)).to be_falsey
-      expect(show_menu?(hide: "menu")).to be_falsey
-    end
-
-    it "handles args from nests" do
-      expect(show_menu?({ show: "menu" }, :hide)).to be_truthy
-      expect(show_menu?({ hide: "menu, paging" }, :show)).to be_falsey
-      expect(show_menu?({ show: "menu" }, :hide)).to be_truthy
-    end
-  end
-
-  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:"
-    end
-
-    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"
-    end
-    let(:url_text2) { "with external in link syntax: [[http://brain.org/Home|extra]]" }
-    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 "
-    end
-
-    it "formats 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
-      expect(cobj.to_s).to eq url_text2
-      cobj = Card::Content.new url_text3, text_format
-      expect(cobj.to_s).to eq url_text3
-      cobj = Card::Content.new url_text4, text_format
-      expect(cobj.to_s).to eq url_text4
-      cobj = Card::Content.new url_text5, text_format
-      expect(cobj.to_s).to eq url_text5
-    end
-
-    it "formats 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
-      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 "
-                           )
-    end
-
-    it "formats page_path" do
-      expect(text_format.page_path(card.name)).to eq "/" + card.name
-      expect(html_format.page_path(card.name)).to eq "/" + card.name
-      page_path = text_format.page_path card.name,
-                                        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}"
-    end
-  end
-
-  describe "async view" do
-    let(:format) do
-      Card["A"].format_with do
-        view :lazy_view, async: true do
-          "content"
-        end
-      end
-    end
-
-    it "renders placeholder" do
-      expect(format.render!(:lazy_view))
-        .to eq %(<card-view-placeholder data-url="/A?view=lazy_view_async_content" />)
-    end
-
-    it "renders content in _async_content view" do
-      expect(format.render!(:lazy_view_async_content))
-        .to eq "content"
-    end
-  end
-end

data/spec/lib/card/i18n_spec.rb

@@ -1,24 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-require "i18n/tasks"
-
-RSpec.describe "I18n" do
-  # 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
-  let(:i18n) { Dir.chdir(Cardio.gem_root) { I18n::Tasks::BaseTask.new } }
-  let(:missing_keys) { Dir.chdir(Cardio.gem_root) { i18n.missing_keys } }
-  let(:unused_keys) { Dir.chdir(Cardio.gem_root) { i18n.unused_keys } }
-
-  it "does not have missing keys" do
-    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
-    pending
-    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

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

data/spec/lib/card/loader_spec.rb

@@ -1,98 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Mod::Loader do
-  # let(:card_double) { double "Card" }
-  # let(:pat_all_double) { proxy Card::Set::All }
-  # let(:format_double) { proxy Card::Format }
-  # let(:html_format_double) { proxy Card::Format::HtmlFormat }
-  # it "autos-load Card class methods from lib/card and mods" do
-  #   #xpect(Card).to receive(:load_mods)
-  #   #
-  #   allow(Card::Mod::Loader).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::Mod::Loader).to have_received(:load_mods)
-  #   #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 "defines Card methods from modules" do
-  #   expect(Card.instance_method(:set_modules)).to be
-  # end
-  # it "defines 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 "defines 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
-
-  it "loads self set" do
-    create_card "set test load", codename: "set_test_load"
-    Card::Cache.reset_all
-    class ::Card::Set::Self
-      module SetTestLoad
-        extend Card::Set
-        def hello
-          "hello"
-        end
-      end
-    end
-
-    expect(Card["set_test_load"]).to respond_to :hello
-  end
-
-  it "loads self set for junction card" do
-    create_card "set+test+load", codename: "set_test_load"
-    Card::Cache.reset_all
-    class ::Card::Set::Self
-      module SetTestLoad
-        extend Card::Set
-        def hello
-          "hello"
-        end
-      end
-    end
-
-    expect(Card["set+test+load"]).to respond_to :hello
-  end
-
-  it "loads type set" do
-    create_card "set test load", codename: "set_test_load", type_id: Card::CardtypeID
-    Card::Cache.reset_all
-    class ::Card::Set::Type
-      module SetTestLoad
-        extend Card::Set
-        def hello
-          "hello"
-        end
-      end
-    end
-    expect(Card.new(name: "test load", type: "set test load")).to respond_to :hello
-  end
-
-  it "loads type set for a junction cardtyp" do
-    create_card "set+test load", codename: "set_test_load", type_id: Card::CardtypeID
-    Card::Cache.reset_all
-    class ::Card::Set::Type
-      module SetTestLoad
-        extend Card::Set
-        def hi
-          "hello"
-        end
-      end
-    end
-    expect(Card.new(name: "test load", type: "set+test load")).to respond_to :hi
-  end
-
-end