card 1.19.6 → 1.20.0

data/spec/lib/card/chunk_spec.rb

@@ -3,16 +3,16 @@ require "card/content/chunk"
 
 describe Card::Content::Chunk, "Chunk" do
   context "Class" do
-    it "should populate prefix map on load" 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::Include)
+        .to eq(Card::Content::Chunk::Nest)
     end
 
-    it "should find Chunk classes using matched prefix" do
+    it "finds Chunk classes using matched prefix" do
       expect(Card::Content::Chunk.find_class_by_prefix("{{"))
-        .to eq(Card::Content::Chunk::Include)
+        .to eq(Card::Content::Chunk::Nest)
     end
   end
 end

data/spec/lib/card/codename_spec.rb

@@ -5,14 +5,14 @@ describe Card::Codename, "Codename" do
     @codename = :default
   end
 
-  it "should be sane" do
+  it "is sane" do
     expect(Card[@codename].codename).to eq(@codename.to_s) # would prefer Symbol eventually
     card_id = Card::Codename[@codename]
     expect(card_id).to be_a_kind_of Integer
     expect(Card::Codename[card_id]).to eq(@codename)
   end
 
-  it "should make cards indestructable" do
+  it "makes cards indestructable" do
     Card::Auth.as_bot do
       card = Card[@codename]
       card.delete

data/spec/lib/card/content_spec.rb

@@ -5,42 +5,42 @@ describe Card::Content do
   EXAMPLES = {
     nests: {
       content: "Some Literals: \\[{I'm not| a link]}, and " \
-                '\\{{This Card|Is not Included}}' \
+                '\\{{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 Included}}",
+                 "<span>{</span>{This Card|Is not Nestd}}",
                  ", but ",
-                 { options: { inc_name: "this is",
-                              inc_syntax: "this is" } },
+                 { options: { nest_name: "this is",
+                              nest_syntax: "this is" } },
                  ", and some tail"],
-      classes: [String, :EscapedLiteral, String, :Include, String]
+      classes: [String, :EscapedLiteral, String, :Nest, String]
     },
 
     links_and_nests: {
       content: "Some Links and includes: [[the card|the text]], " \
-               "and {{This Card|Is Included}}{{this too}} " \
+               "and {{This Card|Is Nestd}}{{this too}} " \
                "and [[http://external.wagn.org/path|link text]]" \
-               "{{Included|open}}",
+               "{{Nestd|open}}",
       rendered: ["Some Links and includes: ",
                  '<a class="wanted-card" ' \
                  'href="/the_card">' \
                  "the text</a>",
                  ", and ",
-                 { options: { view: "Is Included",
-                              inc_name: "This Card",
-                              inc_syntax: "This Card|Is Included" } },
-                 { options: { inc_name: "this too",
-                              inc_syntax: "this too" } },
+                 { 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",
-                              inc_name: "Included",
-                              inc_syntax: "Included|open" } }],
+                              nest_name: "Nestd",
+                              nest_syntax: "Nestd|open" } }],
       classes: [
-        String, :Link, String, :Include, :Include, String, :Link, :Include
+        String, :Link, String, :Nest, :Nest, String, :Link, :Nest
       ]
     },
 
@@ -134,7 +134,7 @@ describe Card::Content do
 
     single_nest: {
       content: "{{one nest|size;large}}",
-      classes: [:Include]
+      classes: [:Nest]
     },
 
     css: {
@@ -324,13 +324,13 @@ describe Card::Content do
 
   context "class" do
     describe "#clean!" do
-      it "should not alter untagged content" 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 "should strip disallowed html class attributes" do
+      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>' \
@@ -340,7 +340,7 @@ describe Card::Content do
                      Card::Content.clean!('<span class="banana">foo</span>')
       end
 
-      it "should not strip permitted_classes" do
+      it "does not strip permitted_classes" do
         has_stripped1 = '<span class="w-spotlight">foo</span>'
         assert_equal has_stripped1,
                      Card::Content.clean!(has_stripped1)
@@ -349,7 +349,7 @@ describe Card::Content do
                      Card::Content.clean!(has_stripped2)
       end
 
-      it "should strip permitted_classes " \
+      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!(
@@ -365,7 +365,7 @@ describe Card::Content do
                      )
       end
 
-      it "should allow permitted attributes" do
+      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">',
@@ -377,12 +377,12 @@ describe Card::Content do
                      Card::Content.clean!('<blockquote cite="foo">')
       end
 
-      it "should not allow nonpermitted attributes" do
+      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 "should remove comments" do
+      it "removes comments" do
         assert_equal "yo", Card::Content.clean!("<!-- not me -->yo")
         assert_equal "joe",
                      Card::Content.clean!("<!-- not me -->joe<!-- not me -->")

data/spec/lib/card/diff_spec.rb

@@ -202,7 +202,7 @@ describe Card::Content::Diff do
     end
 
     it "removes square brackets" do
-      expect(diff "[[Hello]]", "[[Hi]]").to eq(del("Hello") + ins("Hi"))
+      expect(diff "[[Hello]]", "[[Hi]]").to eq(del("Hello<br>") + ins("Hi<br>"))
     end
   end
 end

data/spec/lib/card/format_spec.rb

@@ -1,36 +1,31 @@
 # -*- encoding : utf-8 -*-
 
 describe Card::Format do
-  describe "#show?" do
+  describe "#show_view?" do
     let(:format) { described_class.new Card.new }
 
-    def show_menu? args
-      format.show_view?(:menu, args)
+    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 "should respect defaults" do
-      expect(show_menu?(default_visibility: :show)).to be_truthy
-      expect(show_menu?(default_visibility: :hide)).to be_falsey
+    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 "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
+    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 "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
+    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
 
@@ -56,7 +51,7 @@ describe Card::Format do
       "external with port: http://localhost:2020/path?cgi=foo+bar=baz after "
     end
 
-    it "should format links" do
+    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
@@ -69,7 +64,7 @@ describe Card::Format do
       expect(cobj.to_s).to eq url_text5
     end
 
-    it "should format html links" do
+    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" ' \

data/spec/lib/card/loader_spec.rb

@@ -5,7 +5,7 @@
 #   # let(:pat_all_double) { proxy Card::Set::All }
 #   # let(:format_double) { proxy Card::Format }
 #   # let(:html_format_double) { proxy Card::Format::HtmlFormat }
-#   # it "should auto-load Card class methods from lib/card and mods" do
+#   # it "autos-load Card class methods from lib/card and mods" do
 #   #   #xpect(Card).to receive(:load_mods)
 #   #   #
 #   #   card = Card[:all]
@@ -19,16 +19,16 @@
 #   #   # allow(Card).to receive(:file_path_sdfs)
 #   #   #expect(Card.instance_method(:file_path)).to be
 #   # end
-#   # it "should define Card methods from modules" do
+#   # it "defines Card methods from modules" do
 #   #   expect(Card.instance_method(:set_modules)).to be
 #   # end
-#   # it "should define Formatter methods from modules" do
+#   # 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 "should define Formatter methods from modules" do
+#   # 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

data/spec/lib/card/name_spec.rb

@@ -2,64 +2,64 @@
 
 describe Card::Name do
   describe "#key" do
-    it "should lowercase and underscore" do
+    it "lowercases and underscores" do
       expect("This Name".to_name.key).to eq("this_name")
     end
 
-    it "should remove spaces" do
+    it "removes spaces" do
       expect("this    Name".to_name.key).to eq("this_name")
     end
 
     describe "underscores" do
-      it "should be treated like spaces" do
+      it "is treated like spaces" do
         expect("weird_ combo".to_name.key).to eq("weird  combo".to_name.key)
       end
 
-      it "should not impede pluralization checks" do
+      it "does not impede pluralization checks" do
         expect("Mamas_and_Papas".to_name.key).to(
           eq("Mamas and Papas".to_name.key)
         )
       end
 
-      it "should be removed when before first word character" do
+      it "is removed when before first word character" do
         expect("_This Name".to_name.key).to eq("this_name")
       end
     end
 
-    it "should singularize" do
+    it "singularizes" do
       expect("ethans".to_name.key).to eq("ethan")
     end
 
-    it "should change CamelCase to snake case" do
+    it "changes CamelCase to snake case" do
       expect("ThisThing".to_name.key).to eq("this_thing")
     end
 
-    it "should handle plus cards" do
+    it "handles plus cards" do
       expect("ThisThing+Ethans".to_name.key).to eq("this_thing+ethan")
     end
 
-    it "should retain * for star cards" do
+    it "retains * for star cards" do
       expect("*right".to_name.key).to eq("*right")
     end
 
-    it "should not singularize double s's" do
+    it "does not singularize double s's" do
       expect("grass".to_name.key).to eq("grass")
     end
 
-    it "should not singularize letter 'S'" do
+    it "does not singularize letter 'S'" do
       expect("S".to_name.key).to eq("s")
     end
 
-    it "should handle unicode characters" do
+    it "handles unicode characters" do
       expect("Mañana".to_name.key).to eq("mañana")
     end
 
-    it "should handle weird initial characters" do
+    it "handles weird initial characters" do
       expect("__you motha @\#$".to_name.key).to eq("you_motha")
       expect("?!_you motha @\#$".to_name.key).to eq("you_motha")
     end
 
-    it "should allow numbers" do
+    it "allows numbers" do
       expect("3way".to_name.key).to eq("3way")
     end
 
@@ -67,7 +67,7 @@ describe Card::Name do
       expect("cards hooks label foos".to_name.key).to eq("card_hook_label_foo")
     end
 
-    it "should handle html entities" do
+    it "handles html entities" do
       # This no longer takes off the s, is singularize broken now?
       expect("Jean-françois Noubel".to_name.key).to(
         eq("jean_françoi_noubel")
@@ -80,7 +80,7 @@ describe Card::Name do
                  "PB & J", "Mañana"].map(&:to_name)
 
     cardnames.each do |cardname|
-      it "should have the same key as the name" do
+      it "has the same key as the name" do
         k = cardname.key
         k2 = cardname.url_key
         # warn "cn tok #{cardname.inspect}, #{k.inspect}, #{k2.inspect}"

data/spec/lib/card/query_spec.rb

@@ -10,7 +10,7 @@ describe Card::Query do
     Card::Query.run @query.reverse_merge return: :name, sort: :name
   end
 
-  it "should not alter original statement" do
+  it "does not alter original statement" do
     @query = { right_plus: { name: %w(in tag source) } }
     query_clone = @query.deep_clone
     subject # runs query
@@ -18,7 +18,7 @@ describe Card::Query do
   end
 
   describe "append" do
-    it "should find real cards" do
+    it "finds real cards" do
       @query = {
         name: [:in, "C", "D", "F"],
         append: "A"
@@ -26,7 +26,7 @@ describe Card::Query do
       is_expected.to eq(%w(C+A D+A F+A))
     end
 
-    it "should absolutize names" do
+    it "absolutizes names" do
       @query = {
         name: [:in, "C", "D", "F"],
         append: "_right",
@@ -35,7 +35,7 @@ describe Card::Query do
       is_expected.to eq(%w(C+A D+A F+A))
     end
 
-    it "should find virtual cards" do
+    it "finds virtual cards" do
       @query = {
         name: [:in, "C", "D"],
         append: "*plus cards"
@@ -45,17 +45,17 @@ describe Card::Query do
   end
 
   describe "in" do
-    it "should work for content options" do
+    it "works for content options" do
       @query = { in: %w(AlphaBeta Theta) }
       is_expected.to eq(%w(A+B T))
     end
 
-    it "should find the same thing in full syntax" do
+    it "finds the same thing in full syntax" do
       @query = { content: [:in, "Theta", "AlphaBeta"] }
       is_expected.to eq(%w(A+B T))
     end
 
-    it "should work on types" do
+    it "works on types" do
       @query = { type: [:in, "Cardtype E", "Cardtype F"] }
       is_expected.to eq(%w(type-e-card type-f-card))
     end
@@ -74,7 +74,7 @@ describe Card::Query do
   end
 
   describe "not" do
-    it "should exclude cards matching not criteria" do
+    it "excludes cards matching not criteria" do
       Card::Auth.as_bot
       @query = { plus: "A", not: { plus: "A+B" } }
       is_expected.to eq(%w(B D E F))
@@ -82,64 +82,64 @@ describe Card::Query do
   end
 
   describe "multiple values" do
-    it "should handle :all as the first element of an Array" do
+    it "handles :all as the first element of an Array" do
       @query = { member_of: [:all, { name: "r1" }, { key: "r2" }] }
       is_expected.to eq(%w(u1 u2))
     end
 
-    it "should handle act like :all by default" do
+    it "handles act like :all by default" do
       @query = { member_of: [{ name: "r1" }, { key: "r2" }] }
       is_expected.to eq(%w(u1 u2))
     end
 
-    it "should handle :any as the first element of an Array" do
+    it "handles :any as the first element of an Array" do
       @query = { member_of: [:any, { name: "r1" }, { key: "r2" }] }
       is_expected.to eq(%w(u1 u2 u3))
     end
 
-    it "should handle :any as a relationship" do
+    it "handles :any as a relationship" do
       @query = { member_of: { any: [{ name: "r1" }, { key: "r2" }] } }
       is_expected.to eq(%w(u1 u2 u3))
     end
 
-    it "should handle explicit conjunctions in plus_relational keys" do
+    it "handles explicit conjunctions in plus_relational keys" do
       @query = { right_plus: [:all, "e", "c"] }
       is_expected.to eq(%w(A))
     end
 
-    it "should handle multiple values for right_part in compound relations" do
+    it "handles multiple values for right_part in compound relations" do
       @query = { right_plus: [["e", {}], "c"] }
       is_expected.to eq(%w(A)) # first element is array
     end
 
-    it "should not interpret simple arrays as multi values for plus" do
+    it "does not interpret simple arrays as multi values for plus" do
       @query = { right_plus: %w(e c) }
       is_expected.to eq([]) # NOT interpreted as multi-value
     end
 
-    it "should handle :and for references" do
+    it "handles :and for references" do
       @query = { refer_to: [:and, "a", "b"] }
       is_expected.to eq(%w(Y))
     end
 
-    it "should handle :or for references" do
+    it "handles :or for references" do
       @query = { refer_to: [:or, "b", "z"] }
       is_expected.to eq(%w(A B Y))
     end
 
-    it "should handle treat simple arrays like :all for references" do
+    it "handles treat simple arrays like :all for references" do
       @query = { refer_to: %w(A T) }
       is_expected.to eq(%w(X Y))
     end
   end
 
   describe "edited_by/editor_of" do
-    it "should find card edited by joe using subquery" do
+    it "finds card edited by joe using subquery" do
       @query = { edited_by: { match: "Joe User" } }
       is_expected.to eq(%w(JoeLater JoeNow))
     end
 
-    it "should find card edited by Wagn Bot" do
+    it "finds card edited by Wagn Bot" do
       # this is a weak test, since it gives the name, but different sorting
       # mechanisms in other db setups
       # was having it return *account in some cases and 'A' in others
@@ -147,12 +147,12 @@ describe Card::Query do
       is_expected.to eq(%w(A))
     end
 
-    it 'should fail gracefully if user isn\'t there' do
+    it "fails gracefully if user isn't there" do
       @query = { edited_by: "Joe LUser" }
       is_expected.to eq([])
     end
 
-    it "should not give duplicate results for multiple edits" do
+    it "does not give duplicate results for multiple edits" do
       c = Card["JoeNow"]
       c.content = "testagagin"
       c.save
@@ -162,7 +162,7 @@ describe Card::Query do
       is_expected.to eq(%w(JoeLater JoeNow))
     end
 
-    it 'should find joe user among card\'s editors' do
+    it "finds joe user among card's editors" do
       @query = { editor_of: "JoeLater" }
       is_expected.to eq(["Joe User"])
     end
@@ -173,12 +173,12 @@ describe Card::Query do
       Card.create name: "Create Test", content: "sufficiently distinctive"
     end
 
-    it "should find Joe User as the card's creator" do
+    it "finds Joe User as the card's creator" do
       @query = { creator_of: "Create Test" }
       is_expected.to eq(["Joe User"])
     end
 
-    it "should find card created by Joe User" do
+    it "finds card created by Joe User" do
       @query = { created_by: "Joe User", eq: "sufficiently distinctive" }
       is_expected.to eq(["Create Test"])
     end
@@ -191,26 +191,26 @@ describe Card::Query do
       c.save!
     end
 
-    it "should find Joe User as the card's last editor" do
+    it "finds Joe User as the card's last editor" do
       @query = { last_editor_of: "A" }
       is_expected.to eq(["Joe User"])
     end
 
-    it "should find card created by Joe User" do
+    it "finds card created by Joe User" do
       @query = { last_edited_by: "Joe User", eq: "peculicious" }
       is_expected.to eq(["A"])
     end
   end
 
   describe "keyword" do
-    it "should escape nonword characters" do
+    it "escapes nonword characters" do
       @query = { match: "two :(!" }
       is_expected.to eq(CARDS_MATCHING_TWO)
     end
   end
 
   describe "search count" do
-    it "should return integer" do
+    it "returns integer" do
       search = Card.create!(
         name: "tmpsearch",
         type: "Search",
@@ -221,51 +221,51 @@ describe Card::Query do
   end
 
   describe "cgi_params" do
-    it "should match content from cgi" do
+    it "matchs content from cgi" do
       @query = { match: "$keyword", vars: { keyword: "two" } }
       is_expected.to eq(CARDS_MATCHING_TWO)
     end
   end
 
   describe "content equality" do
-    it "should match content explicitly" do
+    it "matchs content explicitly" do
       @query = { content: ["=", "I'm number two"] }
       is_expected.to eq(["Joe User"])
     end
 
-    it "should match via shortcut" do
+    it "matchs via shortcut" do
       @query = { "=" => "I'm number two" }
       is_expected.to eq(["Joe User"])
     end
   end
 
   describe "links" do
-    it "should handle refer_to" do
+    it "handles refer_to" do
       @query = { refer_to: "Z" }
       is_expected.to eq(%w(A B))
     end
 
-    it "should handle link_to" do
+    it "handles link_to" do
       @query = { link_to: "Z" }
       is_expected.to eq(%w(A))
     end
 
-    it "should handle include" do
+    it "handles include" do
       @query = { include: "Z" }
       is_expected.to eq(%w(B))
     end
 
-    it "should handle linked_to_by" do
+    it "handles linked_to_by" do
       @query = { linked_to_by: "A" }
       is_expected.to eq(%w(Z))
     end
 
-    it "should handle included_by" do
+    it "handles included_by" do
       @query = { included_by: "B" }
       is_expected.to eq(%w(Z))
     end
 
-    it "should handle referred_to_by" do
+    it "handles referred_to_by" do
       @query = { referred_to_by: "X" }
       is_expected.to eq(%w(A A+B T))
     end
@@ -284,14 +284,14 @@ describe Card::Query do
   end
 
   describe "relative links" do
-    it "should handle relative refer_to" do
+    it "handles relative refer_to" do
       @query = { refer_to: "_self", context: "Z" }
       is_expected.to eq(%w(A B))
     end
   end
 
   describe "permissions" do
-    it "should not find cards not in group" do
+    it "does not find cards not in group" do
       Card::Auth.as_bot do
         Card.create name: "C+*self+*read", type: "Pointer", content: "[[R1]]"
       end
@@ -301,53 +301,53 @@ describe Card::Query do
   end
 
   describe "basics" do
-    it "should be case insensitive for name" do
+    it "is case insensitive for name" do
       @query = { name: "a" }
       is_expected.to eq(["A"])
     end
 
-    it "should find plus cards" do
+    it "finds plus cards" do
       @query = { plus: "A" }
       is_expected.to eq(A_JOINEES)
     end
 
-    it "should find connection cards" do
+    it "finds connection cards" do
       @query = { part: "A" }
       is_expected.to eq(%w(A+B A+C A+D A+E C+A D+A F+A))
     end
 
-    it "should find left connection cards" do
+    it "finds left connection cards" do
       @query = { left: "A" }
       is_expected.to eq(%w(A+B A+C A+D A+E))
     end
 
-    it "should find right connection cards based on name" do
+    it "finds right connection cards based on name" do
       @query = { right: "A" }
       is_expected.to eq(%w(C+A D+A F+A))
     end
 
-    it "should find right connection cards based on content" do
+    it "finds right connection cards based on content" do
       @query = { right: { content: "Alpha [[Z]]" } }
       is_expected.to eq(%w(C+A D+A F+A))
     end
 
-    it "should return count" do
+    it "returns count" do
       expect(Card.count_by_wql part: "A").to eq(7)
     end
   end
 
   describe "limit and offset" do
-    it "should return limit" do
+    it "returns limit" do
       @query = { part: "A", limit: 5 }
       expect(subject.size).to eq(5)
     end
 
-    it "should not break if offset but no limit" do
+    it "does not break if offset but no limit" do
       @query = { part: "A", offset: 5 }
       expect(subject.size).not_to eq(0)
     end
 
-    it "should not break count" do
+    it "does not break count" do
       query = { match: "two", offset: 1 }
       expect(Card.count_by_wql(query)).to eq(CARDS_MATCHING_TWO.length)
     end
@@ -360,24 +360,24 @@ describe Card::Query do
       "Sunglasses fan", "u1", "u2", "u3"
     ].sort
 
-    it "should find cards of this type" do
+    it "finds cards of this type" do
       @query = { type: "_self", context: "User" }
       is_expected.to eq(user_cards)
     end
 
-    it "should find User cards " do
+    it "finds User cards " do
       @query = { type: "User" }
       is_expected.to eq(user_cards)
     end
 
-    it "should handle casespace variants" do
+    it "handles casespace variants" do
       @query = { type: "users" }
       is_expected.to eq(user_cards)
     end
   end
 
   describe "trash handling" do
-    it "should not find cards in the trash" do
+    it "does not find cards in the trash" do
       Card["A+B"].delete!
       @query = { left: "A" }
       is_expected.to eq(["A+C", "A+D", "A+E"])
@@ -385,7 +385,7 @@ describe Card::Query do
   end
 
   describe "order" do
-    it "should sort by create" do
+    it "sorts by create" do
       Card.create! name: "classic bootstrap skin head"
       # classic skin head is created more recently than classic skin,
       # which is in the seed data
@@ -395,22 +395,22 @@ describe Card::Query do
       )
     end
 
-    it "should sort by name" do
+    it "sorts by name" do
       @query = { name: %w(in B Z A Y C X), sort: "name", dir: "desc" }
       is_expected.to eq(%w(Z Y X C B A))
     end
 
-    it "should sort by content" do
+    it "sorts by content" do
       @query = { name: %w(in Z T A), sort: "content" }
       is_expected.to eq(%w(A Z T))
     end
 
-    it "should play nice with match" do
+    it "plays nice with match" do
       @query = { match: "Z", type: "Basic", sort: "content" }
       is_expected.to eq(%w(A B Z))
     end
 
-    it "should sort by plus card content" do
+    it "sorts by plus card content" do
       Card::Auth.as_bot do
         c = Card.fetch("Setting+*self+*table of contents")
         c.content = "10"
@@ -426,7 +426,7 @@ describe Card::Query do
       end
     end
 
-    it "should sort by count" do
+    it "sorts by count" do
       Card::Auth.as_bot do
         @query = {
           name: [:in, "*always", "*never", "*edited"],
@@ -436,7 +436,7 @@ describe Card::Query do
       end
     end
 
-    #  it 'should sort by update' do
+    #  it 'sorts by update' do
     #    # do this on a restricted set so it won't change every time we
     #    #  add a card..
     #    Card::Query.run(
@@ -450,47 +450,47 @@ describe Card::Query do
   end
 
   describe "match" do
-    it "should reach content and name via shortcut" do
+    it "reachs content and name via shortcut" do
       @query = { match: "two" }
       is_expected.to eq(CARDS_MATCHING_TWO)
     end
 
-    it "should get only content when content is explicit" do
+    it "gets only content when content is explicit" do
       @query = { content: [:match, "two"] }
       is_expected.to eq(["Joe User", "script: ace+*all+*script+*machine cache",
                          "script: slot+*all+*script+*machine cache"])
     end
 
-    it "should get only name when name is explicit" do
+    it "gets only name when name is explicit" do
       @query = { name: [:match, "two"] }
       is_expected.to eq(["One+Two", "One+Two+Three", "Two"])
     end
   end
 
   describe "and" do
-    it "should act as a simple passthrough with operators" do
+    it "acts as a simple passthrough with operators" do
       @query = { and: { match: "two" } }
       is_expected.to eq(CARDS_MATCHING_TWO)
     end
 
-    it "should act as a simple passthrough with relationships" do
+    it "acts as a simple passthrough with relationships" do
       @query = { and: {}, type: "Cardtype E" }
       is_expected.to eq(["type-e-card"])
     end
 
-    it 'should work within "or"' do
+    it 'works within "or"' do
       @query = { or: { name: "Z", and: { left: "A", right: "C" } } }
       is_expected.to eq(["A+C", "Z"])
     end
   end
 
   describe "any" do
-    it "should work with :plus" do
+    it "works with :plus" do
       @query = { plus: "A", any: { name: "B", match: "K" } }
       is_expected.to eq(["B"])
     end
 
-    it "should work with multiple plusses" do
+    it "works with multiple plusses" do
       @query = { or: { right_plus: "A", plus: "B" } }
       is_expected.to eq(%w(A C D F))
     end
@@ -504,29 +504,29 @@ describe Card::Query do
       )
     end
 
-    it "should find cards returned by search of given name" do
+    it "finds cards returned by search of given name" do
       @query = { found_by: "Simple Search" }
       is_expected.to eq(["A"])
     end
 
-    it "should find cards returned by virtual cards" do
+    it "finds cards returned by virtual cards" do
       image_cards = Card.search type: "Image", return: :name, sort: :name
       @query = { found_by: "Image+*type+by name" }
       is_expected.to eq(image_cards)
     end
 
-    it "should play nicely with other properties and relationships" do
+    it "plays nicely with other properties and relationships" do
       explicit_query = { plus: { name: "A" }, return: :name, sort: :name }
       @query = { plus: { found_by: "Simple Search" } }
       is_expected.to eq(Card::Query.run(explicit_query))
     end
 
-    it "should play work with virtual cards" do
+    it "plays work with virtual cards" do
       @query = { found_by: "A+*self", plus: "C" }
       is_expected.to eq(["A"])
     end
 
-    it "should be able to handle _self" do
+    it "is able to handle _self" do
       @query = {
         context: "Simple Search",
         left: { found_by: "_self" },
@@ -538,33 +538,33 @@ describe Card::Query do
   end
 
   describe "relative" do
-    it "should clean wql" do
+    it "cleans wql" do
       query = Card::Query.new(part: "_self", context: "A")
       expect(query.statement[:part]).to eq("A")
     end
 
-    it "should find connection cards" do
+    it "finds connection cards" do
       @query = { part: "_self", context: "A" }
       is_expected.to eq(%w(A+B A+C A+D A+E C+A D+A F+A))
     end
 
-    it "should be able to use parts of nonexistent cards in search" do
+    it "is able to use parts of nonexistent cards in search" do
       expect(Card["B+A"]).to be_nil
       @query = { left: "_right", right: "_left", context: "B+A" }
       is_expected.to eq(["A+B"])
     end
 
-    it "should find plus cards for _self" do
+    it "finds plus cards for _self" do
       @query = { plus: "_self", context: "A" }
       is_expected.to eq(A_JOINEES)
     end
 
-    it "should find plus cards for _left" do
+    it "finds plus cards for _left" do
       @query = { plus: "_left", context: "A+B" }
       is_expected.to eq(A_JOINEES)
     end
 
-    it "should find plus cards for _right" do
+    it "finds plus cards for _right" do
       @query = { plus: "_right", context: "C+A" }
       is_expected.to eq(A_JOINEES)
     end