card 1.93.3 → 1.93.4

data/mod/bootstrap/vendor/select2/.travis.yml

@@ -1,22 +0,0 @@
-language: node_js
-
-sudo: false
-
-node_js:
-  - 0.10
-
-env:
-  global:
-    - secure: XMNK8GVxkwKa6oLl7nJwgg/wmY1YDk5rrMd+UXz26EDCsMDbiy1P7GhN2fEiBSLaQ7YfEuvaDcmzQxTrT0YTHp1PDzb2o9J4tIDdEkqPcv1y8xMaYDfmsN0rBPdBwZEg9H5zUgi7OdUbrGswSYxsKCE3x8EOqK89104HyOo1LN4=
-    - secure: BU5BPRx6H4O3WJ509YPixjUxg+hDF3z2BVJX6NiGmKWweqvCEYFfiiHLwDEgp/ynRcF9vGVi1V4Ly1jq7f8NIajbDZ5q443XchZFYFg78K/EwD5mK6LYt16zb7+Jn0KbzwHeGRGzc9AvcEYlW6i634cSCm4n3BnqtF5PpogSzdw=
-
-script:
-  - grunt ci
-
-notifications:
-  email: false
-  irc:
-    channels:
-      - "chat.freenode.net#select2"
-    on_success: change
-    on_failure: always

data/script/fetch_bootswatch_themes.rb

@@ -1,38 +0,0 @@
-require "active_support"
-require "uri/https"
-require "open-uri"
-require "fileutils"
-
-THEMES = %w[Cerulean Cosmo Cyborg Darkly Flatly Journal Litera Lumen Lux Materia Minty
-            Pulse Sandstone Simplex Slate Solar Spacelab Superhero United Yeti]
-           .map(&:downcase).freeze
-
-class Theme
-  STORE_DIR = File.expand_path("../../db/migrate_core_cards/data/b4_themes", __FILE__).freeze
-  BOOTSWATCH_HOST = "bootswatch.com".freeze
-  VERSION = "4-alpha"
-
-  def initialize name
-    @theme = name
-    @store_dir =  File.join STORE_DIR, @theme
-    FileUtils.mkdir_p @store_dir
-  end
-
-  def store_path filename
-    File.join @store_dir, filename
-  end
-
-  def uri object
-    URI::HTTPS.build host: BOOTSWATCH_HOST, path: "/#{VERSION}/#{@theme}/#{object}"
-  end
-end
-
-THEMES.each do |theme_name|
-  theme = Theme.new theme_name
-  %w[_variables.scss _bootswatch.scss thumbnail.png].each do |filename|
-    File.open(theme.store_path(filename), "w") do |f|
-      puts theme.uri(filename)
-      f.puts theme.uri(filename).read
-    end
-  end
-end

data/spec/config/initializers/core_extensions_spec.rb

@@ -1,47 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe CoreExtensions do
-  context Hash do
-    describe "#new_nested" do
-      it "creates nested hashes" do
-        nested_hash = Hash.new_nested Hash, Hash
-        expect(nested_hash[:a]).to be_instance_of Hash
-        expect(nested_hash[:a][:b]).to be_instance_of Hash
-        expect(nested_hash[:d][:c]).to be_instance_of Hash
-      end
-
-      it "creates set in hash" do
-        nested_hash = Hash.new_nested ::Set
-        expect(nested_hash[:a]).to be_instance_of ::Set
-      end
-    end
-  end
-
-  context CoreExtensions::PersistentIdentifier do
-    describe "#name" do
-      subject { :wagn_bot.cardname }
-      it "converts into a name" do
-        is_expected.to be_instance_of Card::Name
-        expect(subject.s).to eq "Wagn Bot"
-      end
-    end
-
-    describe "#card" do
-      context "called on Integer" do
-        subject { Card::LogoID.card }
-        it "converts into a card" do
-          is_expected.to be_instance_of Card
-          expect(subject.id).to eq Card::LogoID
-        end
-      end
-
-      context "called on Symbol" do
-        subject { :logo.card }
-        it "converts into a card" do
-          is_expected.to be_instance_of Card
-          expect(subject.key).to eq(:logo.cardname.key)
-        end
-      end
-    end
-  end
-end

data/spec/config/initializers/patches/active_job_spec.rb

@@ -1,7 +0,0 @@
-RSpec.describe ActiveJob::Arguments, "serialize patch" do
-  it "handles symbols" do
-    ser = ActiveJob::Arguments.serialize([:sym])
-    deser = ActiveJob::Arguments.deserialize(ser)
-    expect(deser).to eq [:sym]
-  end
-end

data/spec/lib/card/action_spec.rb

@@ -1,15 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Action do
-  describe "#delete_old_actions" do
-    it "puts all changes on one action" do
-      a = Card["A"]
-      a.update_attributes!(name: "New A")
-      a.update_attributes!(content: "New content")
-      a.clear_history
-      expect(a.actions.count).to eq(1)
-      expect(a.actions.last.card_changes.count).to eq(0)
-      expect(a.actions.reload.last.value :name).to eq("New A")
-    end
-  end
-end

data/spec/lib/card/auth_spec.rb

@@ -1,58 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Auth do
-  before do
-    Card::Auth.current_id = Card::AnonymousID
-    @joeuserid = Card["Joe User"].id
-  end
-
-  it "authenticates user" do
-    authenticated = Card::Auth.authenticate "joe@user.com", "joe_pass"
-    expect(authenticated.left_id).to eq(@joeuserid)
-  end
-
-  it "authenticates user despite whitespace" do
-    authenticated = Card::Auth.authenticate " joe@user.com ", " joe_pass "
-    expect(authenticated.left_id).to eq(@joeuserid)
-  end
-
-  it "authenticates user with weird email capitalization" do
-    authenticated = Card::Auth.authenticate "JOE@user.com", "joe_pass"
-    expect(authenticated.left_id).to eq(@joeuserid)
-  end
-
-  it "sets current directly from email" do
-    Card::Auth.current= "joe@user.com"
-    expect(Card::Auth.current_id).to eq(@joeuserid)
-  end
-
-  it "sets current directly from id when mark is id" do
-    Card::Auth.current= @joeuserid
-    expect(Card::Auth.current_id).to eq(@joeuserid)
-  end
-
-  it "sets current directly from id when mark is id" do
-    Card::Auth.current= @joeuserid
-    expect(Card::Auth.current_id).to eq(@joeuserid)
-  end
-
-  context "with token" do
-    before do
-      @joeadmin = Card["Joe Admin"]
-      @token = "abcd"
-      Card::Auth.as_bot do
-        @joeadmin.account.token_card.update_attributes! content: @token
-      end
-    end
-
-    it "sets current from token" do
-      Card::Auth.set_current_from_token @token
-      expect(Card::Auth.current_id).to eq(@joeadmin.id)
-    end
-
-    it "sets arbitrary current from token on authorized account" do
-      Card::Auth.set_current_from_token @token, @joeuserid
-      expect(Card::Auth.current_id).to eq(@joeuserid)
-    end
-  end
-end

data/spec/lib/card/cache_spec.rb

@@ -1,116 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Cache do
-  describe "with nil store" do
-    before do
-      @cache = Card::Cache.new prefix: "prefix"
-    end
-
-    describe "#basic operations" do
-      it "works" do
-        @cache.write("a", "foo")
-        expect(@cache.read("a")).to eq("foo")
-        @cache.fetch("b") { "bar" }
-        expect(@cache.read("b")).to eq("bar")
-        @cache.reset
-      end
-    end
-  end
-
-  describe "with same cache_id" do
-    before :each do
-      @hard = ActiveSupport::Cache::MemoryStore.new
-      @cache = Card::Cache.new store: @hard
-      @prefix = @cache.hard.prefix
-    end
-
-    it "#read" do
-      expect(@hard).to receive(:read).with("#{@prefix}/foo")
-      @cache.read("foo")
-    end
-
-    it "#write" do
-      expect(@hard).to receive(:write).with("#{@prefix}/foo", "val")
-      @cache.write("foo", "val")
-      expect(@cache.read("foo")).to eq("val")
-    end
-
-    it "#fetch" do
-      block = proc { "hi" }
-      expect(@hard).to receive(:fetch).with("#{@prefix}/foo", &block)
-      @cache.fetch("foo", &block)
-    end
-
-    it "#delete" do
-      expect(@hard).to receive(:delete).with("#{@prefix}/foo")
-      @cache.delete "foo"
-    end
-
-    it "#soft.write" do
-      @cache.soft.write("a", "foo")
-      expect(@cache.read("a")).to eq("foo")
-      expect(@hard).not_to receive(:write)
-      expect(@cache.hard.read("a")).to eq(nil)
-    end
-  end
-
-  it "#reset" do
-    @hard = ActiveSupport::Cache::MemoryStore.new
-    @cache = Card::Cache.new store: @hard, database: "mydb"
-
-    expect(@cache.hard.prefix).to match(/^mydb-/)
-    @cache.write("foo", "bar")
-    expect(@cache.read("foo")).to eq("bar")
-
-    # reset
-    @cache.reset
-    expect(@cache.hard.prefix).to match(/^mydb-/)
-    expect(@cache.read("foo")).to be_nil
-
-    cache2 = Card::Cache.new store: @hard, database: "mydb"
-    expect(cache2.hard.prefix).to match(/^mydb-/)
-  end
-
-  describe "with file store" do
-    before do
-      cache_path = "#{Decko.root}/tmp/cache"
-      FileUtils.mkdir_p(cache_path) unless File.directory?(cache_path)
-      @hard = ActiveSupport::Cache::FileStore.new cache_path
-
-      @hard.clear
-      # cache_path = cache_path + '/prefix'
-      # p = Pathname.new(cache_path)
-      # p.mkdir if !p.exist?
-      #
-      # root_dirs = Dir.entries(cache_path).reject{|f| ['.', '..'].include?(f)}
-      # files_to_remove = root_dirs.collect{|f| File.join(cache_path, f)}
-      # FileUtils.rm_r(files_to_remove)
-      @cache = Card::Cache.new store: @hard, prefix: "prefix"
-    end
-
-    describe "#basic operations with special symbols" do
-      it "works" do
-        @cache.write('%\\/*:?"<>|', "foo")
-        cache2 = Card::Cache.new store: @hard, prefix: "prefix"
-        expect(cache2.read('%\\/*:?"<>|')).to eq("foo")
-        @cache.reset
-      end
-    end
-
-    describe "#basic operations with non-latin symbols" do
-      it "works" do
-        @cache.write("(汉语漢語 Hànyǔ; 华语華語 Huáyǔ; 中文 Zhōngwén", "foo")
-        @cache.write("русский", "foo")
-        cache3 = Card::Cache.new store: @hard, prefix: "prefix"
-        cached = cache3.read "(汉语漢語 Hànyǔ; 华语華語 Huáyǔ; 中文 Zhōngwén"
-        expect(cached).to eq("foo")
-        expect(cache3.read("русский")).to eq("foo")
-        @cache.reset
-      end
-    end
-
-    describe "#tempfile" do
-      # TODO
-    end
-  end
-end

data/spec/lib/card/chunk_spec.rb

@@ -1,18 +0,0 @@
-# -*- encoding : utf-8 -*-
-require "card/content/chunk"
-
-describe Card::Content::Chunk, "Chunk" do
-  context "Class" do
-    it "populates prefix map on load" do
-      expect(Card::Content::Chunk.prefix_map_by_list[:default].keys.size)
-        .to be > 0
-      expect(Card::Content::Chunk.prefix_map_by_list[:default]["{"][:class])
-        .to eq(Card::Content::Chunk::Nest)
-    end
-
-    it "finds Chunk classes using matched prefix" do
-      expect(Card::Content::Chunk.find_class_by_prefix("{{"))
-        .to eq(Card::Content::Chunk::Nest)
-    end
-  end
-end

data/spec/lib/card/codename_spec.rb

@@ -1,66 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-RSpec.describe Card::Codename, "Codename" do
-  before do
-    @codename = :default
-  end
-
-  it "is sane" do
-    expect(Card[@codename].codename).to eq(@codename)
-    card_id = Card::Codename.id @codename
-    expect(card_id).to be_a_kind_of Integer
-    expect(Card::Codename[card_id]).to eq(@codename)
-  end
-
-  it "makes cards indestructable" do
-    Card::Auth.as_bot do
-      card = Card[@codename]
-      card.delete
-      expect(card.errors[:delete].first).to match "is a system card"
-      expect(Card[@codename]).to be
-    end
-  end
-
-  it "raises error for missing codename" do
-    expect { Card::NotACodenameID }
-      .to raise_error(Card::Error::UnknownCodename, /unknown codename: not_a_codename/)
-  end
-
-  describe "#id" do
-    example "symbol" do
-      expect(Card::Codename.id(:all)).to eq Card.fetch_id(:all)
-    end
-
-    example "id" do
-      all_id = Card.fetch_id(:all)
-      expect(Card::Codename.id(all_id)).to eq all_id
-    end
-
-    example "string" do
-      expect(Card::Codename.id("all")).to eq Card.fetch_id(:all)
-    end
-
-    example "missing codename" do
-      expect(Card::Codename.id("unknown")).to eq nil
-    end
-  end
-
-  describe "#[]" do
-    example "symbol" do
-      expect(Card::Codename[:all]).to eq :all
-    end
-
-    example "id" do
-      all_id = Card.fetch_id(:all)
-      expect(Card::Codename[all_id]).to eq :all
-    end
-
-    example "string" do
-      expect(Card::Codename["all"]).to eq :all
-    end
-
-    example "missing codename" do
-      expect(Card::Codename["unknown"]).to eq nil
-    end
-  end
-end

data/spec/lib/card/content_spec.rb

@@ -1,428 +0,0 @@
-# -*- encoding : utf-8 -*-
-require "card/content"
-
-describe Card::Content do
-  EXAMPLES = {
-    nests: {
-      content: "Some Literals: \\[{I'm not| a link]}, and " \
-                '\\{{This Card|Is not Nestd}}' \
-                ", but " \
-                "{{this is}}" \
-                ", and some tail",
-      rendered: ["Some Literals: \\[{I'm not| a link]}, and ",
-                 "<span>{</span>{This Card|Is not Nestd}}",
-                 ", but ",
-                 { options: { nest_name: "this is",
-                              nest_syntax: "this is" } },
-                 ", and some tail"],
-      classes: [String, :EscapedLiteral, String, :Nest, String]
-    },
-
-    links_and_nests: {
-      content: "Some Links and includes: [[the card|the text]], " \
-               "and {{This Card|Is Nestd}}{{this too}} " \
-               "and [[http://external.wagn.org/path|link text]]" \
-               "{{Nestd|open}}",
-      rendered: ["Some Links and includes: ",
-                 '<a class="wanted-card" ' \
-                 'href="/the_card">' \
-                 '<span class="card-title">the text</span></a>',
-                 ", and ",
-                 { options: { view: "Is Nestd",
-                              nest_name: "This Card",
-                              nest_syntax: "This Card|Is Nestd" } },
-                 { options: { nest_name: "this too",
-                              nest_syntax: "this too" } },
-                 " and ",
-                 '<a target="_blank" class="external-link" ' \
-               'href="http://external.wagn.org/path">link text</a>',
-                 { options: { view: "open",
-                              nest_name: "Nestd",
-                              nest_syntax: "Nestd|open" } }],
-      classes: [
-        String, :Link, String, :Nest, :Nest, String, :Link, :Nest
-      ]
-    },
-
-    uris_and_links: {
-      content: "Some URIs and Links: http://a.url.com/ " \
-               "More urls: wagn.com/a/path/to.html " \
-               "http://localhost:2020/path?cgi=foo&bar=baz " \
-               "[[http://brain.org/Home|extra]] " \
-               "[ http://gerry.wagn.com/a/path ] " \
-               "{ https://brain.org/more?args } ",
-      rendered: ["Some URIs and Links: ",
-                 '<a target="_blank" class="external-link" ' \
-                 'href="http://a.url.com/">http://a.url.com/</a>',
-                 " More urls: ",
-                 '<a target="_blank" class="external-link" ' \
-                 'href="http://wagn.com/a/path/to.html">' \
-                 "wagn.com/a/path/to.html</a>",
-                 " ",
-                 '<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>",
-                 " ",
-                 '<a target="_blank" class="external-link" ' \
-                 'href="http://brain.org/Home">extra</a>',
-                 " [ ",
-                 '<a target="_blank" class="external-link" ' \
-                 'href="http://gerry.wagn.com/a/path">' \
-                 "http://gerry.wagn.com/a/path</a>",
-                 " ] { ",
-                 '<a target="_blank" class="external-link" ' \
-                 'href="https://brain.org/more?args">' \
-                 "https://brain.org/more?args</a>",
-                 " } "],
-      text_rendered: ["Some URIs and Links: ", "http://a.url.com/",
-                      " More urls: ",
-                      "wagn.com/a/path/to.html[http://wagn.com/a/path/to.html]",
-                      " ",
-                      "http://localhost:2020/path?cgi=foo&bar=baz",
-                      " ",
-                      "extra[http://brain.org/Home]",
-                      " [ ",
-                      "http://gerry.wagn.com/a/path",
-                      " ] { ",
-                      "https://brain.org/more?args",
-                      " } "],
-      classes: [
-        String, :URI, String, :HostURI, String, :URI, String, :Link,
-        String, :URI, String, :URI, String
-      ]
-    },
-
-    uris_and_links_2: {
-      content: "Some URIs and Links: http://a.url.com " \
-               "More urls: wagn.com/a/path/to.html " \
-               "[ http://gerry.wagn.com/a/path ] " \
-               "{ https://brain.org/more?args } " \
-               "http://localhost:2020/path?cgi=foo&bar=baz " \
-               "[[http://brain.org/Home|extra]]",
-      rendered: ["Some URIs and Links: ",
-                 '<a target="_blank" class="external-link" ' \
-                 'href="http://a.url.com">http://a.url.com</a>',
-                 " More urls: ",
-                 '<a target="_blank" class="external-link" ' \
-                 'href="http://wagn.com/a/path/to.html">' \
-                 "wagn.com/a/path/to.html</a>",
-                 " [ ",
-                 '<a target="_blank" class="external-link" ' \
-                 'href="http://gerry.wagn.com/a/path">' \
-                 "http://gerry.wagn.com/a/path</a>",
-                 " ] { ",
-                 '<a target="_blank" class="external-link" ' \
-                 'href="https://brain.org/more?args">' \
-                 "https://brain.org/more?args</a>",
-                 " } ",
-                 '<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>",
-                 " ",
-                 '<a target="_blank" class="external-link" ' \
-               'href="http://brain.org/Home">extra</a>'],
-      classes:  [
-        String, :URI, String, :HostURI, String, :URI, String, :URI,
-        String, :URI, String, :Link
-      ]
-    },
-
-    no_chunks: {
-      content: "No chunks",
-      rendered: "No chunks"
-    },
-
-    single_nest: {
-      content: "{{one nest|size;large}}",
-      classes: [:Nest]
-    },
-
-    css: {
-      content: %(
-     /* body text */
-     body {
-       color: #444444;
-     }
-
-     /* page - background image and color */
-     body#wagn {
-       background: #ffffff;
-     }
-
-     /* top bar background color; text colors */
-     #menu {
-       background: #3260a0;
-     }
-     #menu a {
-       color: #EEEEEE;
-     }
-
-     /* header text */
-     h1, h2 {
-       color: #664444;
-     }
-     h1.page-header,
-     h2.page-header {
-       color: #222299;
-     }
-   )
-    }
-  }.freeze
-
-  EXAMPLES.each_value do |val|
-    next unless val[:classes]
-    val[:classes] = val[:classes].map do |klass|
-      klass.is_a?(Class) ? klass : Card::Content::Chunk.const_get(klass)
-    end
-  end
-
-  context "instance" do
-    before do
-      @check_proc = proc do |m, v|
-        if m.is_a? Array
-          wrong_class = m[0] != v.class
-          expect(wrong_class).to be_falsey
-          is_last = m.size == 1
-          is_last ? true : m[1..-1] unless wrong_class
-        end
-      end
-
-      assert card = Card["One"]
-      @card = card
-
-      # non-nil valued opts only ...
-      @render_block = proc do |opts|
-        options = opts.inject({}) do |i, v|
-          i if !v[1].nil? && (i[v[0]] = v[1])
-        end
-        { options: options }
-      end
-    end
-
-    let(:example)       { EXAMPLES[@example] }
-    let(:cobj)          { Card::Content.new example[:content], @card }
-    let(:classes)       { example[:classes] }
-    let(:rendered)      { example[:rendered] }
-    let(:text_rendered) { example[:text_rendered] }
-    let(:content)       { example[:content] }
-
-    describe "parse" do
-      def check_chunk_classes
-        all_classes_pass_check_proc
-        clist = nonstring_classes
-        cobj.each_chunk do |chk|
-          expect(chk).to be_instance_of clist.shift
-        end
-        expect(clist).to be_empty
-      end
-
-      def nonstring_classes
-        classes.select { |c| String != c }
-      end
-
-      def all_classes_pass_check_proc
-        expect(cobj.inject(classes, &@check_proc)).to eq(true)
-      end
-
-      it "finds all the chunks and strings" do
-        # note the mixed [} that are considered matching, needs some cleanup ...
-        @example = :nests
-        all_classes_pass_check_proc
-      end
-
-      it "gives just the chunks" do
-        @example = :nests
-        check_chunk_classes
-      end
-
-      it "finds all the chunks links and trasclusions" do
-        @example = :links_and_nests
-        all_classes_pass_check_proc
-      end
-
-      it "finds uri chunks " do
-        # tried some tougher cases that failed, don't know the spec, so
-        # hard to form better tests for URIs here
-        @example = :uris_and_links
-        check_chunk_classes
-      end
-
-      it "finds uri chunks (b)" do
-        # tried some tougher cases that failed, don't know the spec, so
-        # hard to form better tests for URIs here
-        @example = :uris_and_links_2
-        check_chunk_classes
-      end
-
-      it "parses just a string" do
-        @example = :no_chunks
-        expect(cobj).to eq(rendered)
-      end
-
-      it "parses a single chunk" do
-        @example = :single_nest
-        check_chunk_classes
-      end
-
-      it "leaves css alone" do
-        @example = :css
-        expect(cobj).to eq(content)
-      end
-    end
-
-    describe "render" do
-      it "renders all nests" do
-        @example = :nests
-        expect(cobj.as_json.to_s).to match(/not rendered/)
-        cobj.process_each_chunk(&@render_block)
-        rdr = cobj.as_json.to_json
-        expect(rdr).not_to match(/not rendered/)
-        expect(rdr).to eq(rendered.to_json)
-      end
-
-      it "renders links and nests" do
-        @example = :links_and_nests
-        cobj.process_each_chunk(&@render_block)
-        rdr = cobj.as_json.to_json
-        expect(rdr).not_to match(/not rendered/)
-        expect(rdr).to eq(rendered.to_json)
-      end
-
-      it "renders links correctly for text formatters" do
-        @example = :uris_and_links
-        card2 = Card[@card.id]
-        format = card2.format format: :text
-        cobj = Card::Content.new content, format
-        cobj.process_each_chunk(&@render_block)
-        expect(cobj.as_json.to_json).to eq(text_rendered.to_json)
-      end
-
-      it "does not need rendering if no nests" do
-        @example = :uris_and_links
-        cobj.process_each_chunk(&@render_block)
-        expect(cobj.as_json.to_json).to eq(rendered.to_json)
-      end
-
-      it "does not need rendering if no nests (b)" do
-        @example = :uris_and_links_2
-        rdr1 = cobj.as_json.to_json
-        expect(rdr1).to match(/not rendered/)
-        # links are rendered too, but not with a block
-        cobj.process_each_chunk(&@render_block)
-        rdr2 = cobj.as_json.to_json
-        expect(rdr2).not_to match(/not rendered/)
-        expect(rdr2).to eq(rendered.to_json)
-      end
-    end
-  end
-
-  UNTAGGED_CASES = [" [grrew][/wiki/grrew]ss ",
-                    " {{this is a test}}, {{this|view|is:too}} and",
-                    " so is http://foo.bar.come//",
-                    ' and foo="my attr, not int a tag" <not a=tag ',
-                    ' p class"foobar"> and more'].freeze
-
-  context "class" do
-    describe "#clean!" do
-      it "does not alter untagged content" do
-        UNTAGGED_CASES.each do |test_case|
-          assert_equal test_case, Card::Content.clean!(test_case)
-        end
-      end
-
-      it "strips disallowed html class attributes" do
-        assert_equal "<p>html<div>with</div> funky tags</p>",
-                     Card::Content.clean!(
-                       '<p>html<div class="boo">with</div>' \
-                       "<monkey>funky</butts>tags</p>"
-                     )
-        assert_equal "<span>foo</span>",
-                     Card::Content.clean!('<span class="banana">foo</span>')
-      end
-
-      it "does not strip permitted_classes" do
-        has_stripped1 = '<span class="w-spotlight">foo</span>'
-        assert_equal has_stripped1,
-                     Card::Content.clean!(has_stripped1)
-        has_stripped2 = '<p class="w-highlight w-ok">foo</p>'
-        assert_equal has_stripped2,
-                     Card::Content.clean!(has_stripped2)
-      end
-
-      it "strips permitted_classes " \
-            "but not permitted ones when both are present" do
-        assert_equal '<span class="w-spotlight w-ok">foo</span>',
-                     Card::Content.clean!(
-                       '<span class="w-spotlight banana w-ok">foo</span>'
-                     )
-        assert_equal '<p class="w-highlight">foo</p>',
-                     Card::Content.clean!(
-                       '<p class="w-highlight bad-at end">foo</p>'
-                     )
-        assert_equal '<p class="w-highlight">foo</p>',
-                     Card::Content.clean!(
-                       '<p class="bad-class w-highlight">foo</p>'
-                     )
-      end
-
-      it "allows permitted attributes" do
-        assert_equal '<img src="foo">', Card::Content.clean!('<img src="foo">')
-        assert_equal "<img alt='foo'>", Card::Content.clean!("<img alt='foo'>")
-        assert_equal '<img title="foo">',
-                     Card::Content.clean!("<img title=foo>")
-        assert_equal '<a href="foo">', Card::Content.clean!('<a href="foo">')
-        assert_equal '<code lang="foo">',
-                     Card::Content.clean!('<code lang="foo">')
-        assert_equal '<blockquote cite="foo">',
-                     Card::Content.clean!('<blockquote cite="foo">')
-      end
-
-      it "does not allow nonpermitted attributes" do
-        assert_equal "<img>", Card::Content.clean!('<img size="25">')
-        assert_equal "<p>",   Card::Content.clean!('<p font="blah">')
-      end
-
-      it "removes comments" do
-        assert_equal "yo", Card::Content.clean!("<!-- not me -->yo")
-        assert_equal "joe",
-                     Card::Content.clean!("<!-- not me -->joe<!-- not me -->")
-      end
-
-      it "fixes regular nbsp order by default" do
-        assert_equal "space&nbsp; test&nbsp; two&nbsp;&nbsp; space",
-                     Card::Content.clean!(
-                       "space&nbsp; test &nbsp;two &nbsp;&nbsp;space"
-                     )
-      end
-
-      # it "doesn't fix regular nbsp order with setting" do
-      #   # manually configure this setting, then make this one live
-      #   # (test above will then fail)
-      #   pending "Can't set Card.config.space_last_in_multispace= false "\
-      #           'for one test'
-      #   assert_equal 'space&nbsp; test &nbsp;two &nbsp;&nbsp;space',
-      #                Card::Content.clean!(
-      #                  'space&nbsp; test &nbsp;two &nbsp;&nbsp;space'
-      #                )
-      # end
-    end
-  end
-
-  describe "#pieces" do
-    def pieces content
-      Card::Content.new(content, Card["A"],).pieces
-    end
-
-    example "A {{B}}" do
-      expect(pieces("A {{B}}").size).to eq 2
-    end
-
-    example "A" do
-      expect(pieces("A").size).to eq 1
-    end
-
-    example "{{B}}" do
-      expect(pieces("{{B}}").size).to eq 1
-    end
-  end
-end