wagn 1.13.0 → 1.14.0.pre1

data/spec/lib/card/name_spec.rb

@@ -5,73 +5,73 @@ describe Card::Name do
   describe "#key" do
     
     it "should lowercase and underscore" do
-      "This Name".to_name.key.should == "this_name"
+      expect("This Name".to_name.key).to eq("this_name")
     end
     
     it "should remove spaces" do
-      "this    Name".to_name.key.should == "this_name"
+      expect("this    Name".to_name.key).to eq("this_name")
     end
 
     describe "underscores" do
       
       it "should be treated like spaces" do
-        'weird_ combo'.to_name.key.should == 'weird  combo'.to_name.key
+        expect('weird_ combo'.to_name.key).to eq('weird  combo'.to_name.key)
       end
       
       it "should not impede pluralization checks" do
-        'Mamas_and_Papas'.to_name.key.should == "Mamas and Papas".to_name.key
+        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
-        "_This Name".to_name.key.should == "this_name"
+        expect("_This Name".to_name.key).to eq("this_name")
       end
       
     end
 
     it "should singularize" do
-      "ethans".to_name.key.should == "ethan"
+      expect("ethans".to_name.key).to eq("ethan")
     end
 
     it "should change CamelCase to snake case" do
-      "ThisThing".to_name.key.should == "this_thing"
+      expect("ThisThing".to_name.key).to eq("this_thing")
     end
 
     it "should handle plus cards" do
-      "ThisThing+Ethans".to_name.key.should == "this_thing+ethan"
+      expect("ThisThing+Ethans".to_name.key).to eq("this_thing+ethan")
     end
 
     it "should retain * for star cards" do
-      "*right".to_name.key.should == "*right"
+      expect("*right".to_name.key).to eq("*right")
     end
 
     it "should not singularize double s's" do
-      "grass".to_name.key.should == 'grass'
+      expect("grass".to_name.key).to eq('grass')
     end
 
     it "should not singularize letter 'S'" do
-      'S'.to_name.key.should == 's'
+      expect('S'.to_name.key).to eq('s')
     end
 
     it "should handle unicode characters" do
-      "Mañana".to_name.key.should == 'mañana'
+      expect("Mañana".to_name.key).to eq('mañana')
     end
 
     it "should handle weird initial characters" do
-      '__you motha @#$'.to_name.key.should == 'you_motha'
-      '?!_you motha @#$'.to_name.key.should == 'you_motha'
+      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
-      "3way".to_name.key.should == '3way'
+      expect("3way".to_name.key).to eq('3way')
     end
 
     it "internal plurals" do
-      "cards hooks label foos".to_name.key.should == 'card_hook_label_foo'
+      expect("cards hooks label foos".to_name.key).to eq('card_hook_label_foo')
     end
 
     it "should handle html entities" do
       # This no longer takes off the s, is singularize broken now?
-      "Jean-françois Noubel".to_name.key.should == 'jean_françoi_noubel'
+      expect("Jean-françois Noubel".to_name.key).to eq('jean_françoi_noubel')
     end
   end
 
@@ -86,193 +86,193 @@ describe Card::Name do
       it "should have the same key as the name" do
         k, k2 = cardname.key, cardname.url_key
         #warn "cn tok #{cardname.inspect}, #{k.inspect}, #{k2.inspect}"
-        k.should == k2.to_name.key
+        expect(k).to eq(k2.to_name.key)
       end
     end
   end
 
   describe "#valid" do
     it "accepts valid names" do
-      "this+THAT".to_name.should be_valid
-      "THE*ONE*AND$!ONLY".to_name.should be_valid
+      expect("this+THAT".to_name).to be_valid
+      expect("THE*ONE*AND$!ONLY".to_name).to be_valid
     end
 
     it "rejects invalid names" do
 #      "Tes~sd".to_name.should_not be_valid
-      "TEST/DDER".to_name.should_not be_valid
+      expect("TEST/DDER".to_name).not_to be_valid
     end
 
     it "rejects long names" do
       card = Card.new
       card.name="1"*256
-      card.should_not be_valid
+      expect(card).not_to be_valid
     end 
   end 
 
   describe "#left_name" do
     it "returns nil for non junction" do
-      "a".to_name.left_name.should == nil
+      expect("a".to_name.left_name).to eq(nil)
     end
 
     it "returns parent for parent" do
-      "a+b+c+d".to_name.left_name.should == "a+b+c"
+      expect("a+b+c+d".to_name.left_name).to eq("a+b+c")
     end
   end
 
   describe "#tag_name" do
     it "returns last part of plus card" do
-      "a+b+c".to_name.tag.should == "c"
+      expect("a+b+c".to_name.tag).to eq("c")
     end
 
     it "returns name of simple card" do
-      "a".to_name.tag.should == "a"
+      expect("a".to_name.tag).to eq("a")
     end
   end
 
   describe "#safe_key" do
     it "subs pluses & stars" do
-      "Alpha?+*be-ta".to_name.safe_key.should == "alpha-Xbe_tum"
+      expect("Alpha?+*be-ta".to_name.safe_key).to eq("alpha-Xbe_tum")
     end
   end
 
   describe "#replace_part" do
     it "replaces first name part" do
-      'a+b'.to_name.replace_part('a','x').to_s.should == 'x+b'
+      expect('a+b'.to_name.replace_part('a','x').to_s).to eq('x+b')
     end
     it "replaces second name part" do
-      'a+b'.to_name.replace_part('b','x').to_s.should == 'a+x'
+      expect('a+b'.to_name.replace_part('b','x').to_s).to eq('a+x')
     end
     it "replaces two name parts" do
-      'a+b+c'  .to_name.replace_part('a+b', 'x'  ).to_s.should == 'x+c'
-      'a+b+c+d'.to_name.replace_part('a+b', 'e+f').to_s.should == 'e+f+c+d'
+      expect('a+b+c'  .to_name.replace_part('a+b', 'x'  ).to_s).to eq('x+c')
+      expect('a+b+c+d'.to_name.replace_part('a+b', 'e+f').to_s).to eq('e+f+c+d')
     end
     it "doesn't replace two part tag" do
-      'a+b+c'.to_name.replace_part('b+c','x').to_s.should == 'a+b+c'
+      expect('a+b+c'.to_name.replace_part('b+c','x').to_s).to eq('a+b+c')
     end
   end
 
   describe "Cardnames star handling" do
     it "recognizes star cards" do
-      '*a'.to_name.star?.should be_true
+      expect('*a'.to_name.star?).to be_truthy
     end
 
     it "doesn't recognize star cards with plusses" do
-      '*a+*b'.to_name.star?.should be_false
+      expect('*a+*b'.to_name.star?).to be_falsey
     end
 
     it "recognizes rstar cards" do
-      'a+*a'.to_name.rstar?.should be_true
+      expect('a+*a'.to_name.rstar?).to be_truthy
     end
 
     it "doesn't recognize star cards as rstar" do
-      '*a'.to_name.rstar?.should be_false
+      expect('*a'.to_name.rstar?).to be_falsey
     end
 
     it "doesn't recognize non-star or star left" do
-      '*a+a'.to_name.rstar?.should be_false
+      expect('*a+a'.to_name.rstar?).to be_falsey
     end
   end
 
   describe "trait_name?" do
     it "returns true for content codename" do
-      "bazoinga+*right+*structure".to_name.trait_name?(:structure).should be_true
+      expect("bazoinga+*right+*structure".to_name.trait_name?(:structure)).to be_truthy
     end
 
     it "handles arrays" do
-      "bazoinga+*right+*structure".to_name.trait_name?(:structure, :default).should be_true
+      expect("bazoinga+*right+*structure".to_name.trait_name?(:structure, :default)).to be_truthy
     end
 
     it "returns false for non-template" do
-      "bazoinga+*right+nontent".to_name.trait_name?(:structure).should be_false
+      expect("bazoinga+*right+nontent".to_name.trait_name?(:structure)).to be_falsey
     end
   end
 
   describe "#to_absolute" do
     it "handles _self, _whole, _" do
-      "_self".to_name.to_absolute("foo").should == "foo"
-      "_whole".to_name.to_absolute("foo").should == "foo"
-      "_".to_name.to_absolute("foo").should == "foo"
+      expect("_self".to_name.to_absolute("foo")).to eq("foo")
+      expect("_whole".to_name.to_absolute("foo")).to eq("foo")
+      expect("_".to_name.to_absolute("foo")).to eq("foo")
     end
 
     it "handles _left" do
-      "_left+Z".to_name.to_absolute("A+B+C").should == "A+B+Z"
+      expect("_left+Z".to_name.to_absolute("A+B+C")).to eq("A+B+Z")
     end
 
     it "handles white space" do
-      "_left + Z".to_name.to_absolute("A+B+C").should == "A+B+Z"
+      expect("_left + Z".to_name.to_absolute("A+B+C")).to eq("A+B+Z")
     end
 
     it "handles _right" do
-      "_right+bang".to_name.to_absolute("nutter+butter").should == "butter+bang"
-      "C+_right".to_name.to_absolute("B+A").should == "C+A"
+      expect("_right+bang".to_name.to_absolute("nutter+butter")).to eq("butter+bang")
+      expect("C+_right".to_name.to_absolute("B+A")).to eq("C+A")
     end
 
     it "handles leading +" do
-      "+bug".to_name.to_absolute("hum").should == "hum+bug"
+      expect("+bug".to_name.to_absolute("hum")).to eq("hum+bug")
     end
 
     it "handles trailing +" do
-      "bug+".to_name.to_absolute("tracks").should == "bug+tracks"
+      expect("bug+".to_name.to_absolute("tracks")).to eq("bug+tracks")
     end
 
     it "handles _(numbers)" do
-      "_1".to_name.to_absolute("A+B+C").should == "A"
-      "_1+_2".to_name.to_absolute("A+B+C").should == "A+B"
-      "_2+_3".to_name.to_absolute("A+B+C").should == "B+C"
+      expect("_1".to_name.to_absolute("A+B+C")).to eq("A")
+      expect("_1+_2".to_name.to_absolute("A+B+C")).to eq("A+B")
+      expect("_2+_3".to_name.to_absolute("A+B+C")).to eq("B+C")
     end
 
     it "handles _LLR etc" do
-      "_R".to_name.to_absolute("A+B+C+D+E").should    == "E"
-      "_L".to_name.to_absolute("A+B+C+D+E").should    == "A+B+C+D"
-      "_LR".to_name.to_absolute("A+B+C+D+E").should   == "D"
-      "_LL".to_name.to_absolute("A+B+C+D+E").should   == "A+B+C"
-      "_LLR".to_name.to_absolute("A+B+C+D+E").should  == "C"
-      "_LLL".to_name.to_absolute("A+B+C+D+E").should  == "A+B"
-      "_LLLR".to_name.to_absolute("A+B+C+D+E").should == "B"
-      "_LLLL".to_name.to_absolute("A+B+C+D+E").should == "A"
+      expect("_R".to_name.to_absolute("A+B+C+D+E")).to    eq("E")
+      expect("_L".to_name.to_absolute("A+B+C+D+E")).to    eq("A+B+C+D")
+      expect("_LR".to_name.to_absolute("A+B+C+D+E")).to   eq("D")
+      expect("_LL".to_name.to_absolute("A+B+C+D+E")).to   eq("A+B+C")
+      expect("_LLR".to_name.to_absolute("A+B+C+D+E")).to  eq("C")
+      expect("_LLL".to_name.to_absolute("A+B+C+D+E")).to  eq("A+B")
+      expect("_LLLR".to_name.to_absolute("A+B+C+D+E")).to eq("B")
+      expect("_LLLL".to_name.to_absolute("A+B+C+D+E")).to eq("A")
     end
 
     context "mismatched requests" do
       it "returns _self for _left or _right on simple cards" do
-        "_left+Z".to_name.to_absolute("A").should == "A+Z"
-        "_right+Z".to_name.to_absolute("A").should == "A+Z"
+        expect("_left+Z".to_name.to_absolute("A")).to eq("A+Z")
+        expect("_right+Z".to_name.to_absolute("A")).to eq("A+Z")
       end
 
       it "handles bogus numbers" do
-        "_1".to_name.to_absolute("A").should == "A"
-        "_1+_2".to_name.to_absolute("A").should == "A+A"
-        "_2+_3".to_name.to_absolute("A").should == "A+A"
+        expect("_1".to_name.to_absolute("A")).to eq("A")
+        expect("_1+_2".to_name.to_absolute("A")).to eq("A+A")
+        expect("_2+_3".to_name.to_absolute("A")).to eq("A+A")
       end
 
       it "handles bogus _llr requests" do
-           "_R".to_name.to_absolute("A").should == "A"
-           "_L".to_name.to_absolute("A").should == "A"
-          "_LR".to_name.to_absolute("A").should == "A"
-          "_LL".to_name.to_absolute("A").should == "A"
-         "_LLR".to_name.to_absolute("A").should == "A"
-         "_LLL".to_name.to_absolute("A").should == "A"
-        "_LLLR".to_name.to_absolute("A").should == "A"
-        "_LLLL".to_name.to_absolute("A").should == "A"
+           expect("_R".to_name.to_absolute("A")).to eq("A")
+           expect("_L".to_name.to_absolute("A")).to eq("A")
+          expect("_LR".to_name.to_absolute("A")).to eq("A")
+          expect("_LL".to_name.to_absolute("A")).to eq("A")
+         expect("_LLR".to_name.to_absolute("A")).to eq("A")
+         expect("_LLL".to_name.to_absolute("A")).to eq("A")
+        expect("_LLLR".to_name.to_absolute("A")).to eq("A")
+        expect("_LLLL".to_name.to_absolute("A")).to eq("A")
       end
     end
 
     it "does session user substitution" do
-      "_user".to_name.to_absolute("A").should == Card::Auth.current.name
+      expect("_user".to_name.to_absolute("A")).to eq(Card::Auth.current.name)
       Card::Auth.as_bot do
-        "_user".to_name.to_absolute("A").should == Card::Auth.current.name
+        expect("_user".to_name.to_absolute("A")).to eq(Card::Auth.current.name)
       end
     end
   end
 
   describe "#to_show" do
     it "ignores ignorables" do
-         'you+awe'.to_name.to_show('you').should == '+awe'
-      'me+you+awe'.to_name.to_show('you').should == 'me+awe' #HMMM..... what should this do?
-      'me+you+awe'.to_name.to_show('me' ).should == '+you+awe'
-      'me+you+awe'.to_name.to_show('me','you').should == '+awe'
-          'me+you'.to_name.to_show('me','you').should == 'me+you'
-         '?a?+awe'.to_name.to_show('A').should == '+awe'
-            '+awe'.to_name.to_show().should == '+awe'
+         expect('you+awe'.to_name.to_show('you')).to eq('+awe')
+      expect('me+you+awe'.to_name.to_show('you')).to eq('me+awe') #HMMM..... what should this do?
+      expect('me+you+awe'.to_name.to_show('me' )).to eq('+you+awe')
+      expect('me+you+awe'.to_name.to_show('me','you')).to eq('+awe')
+          expect('me+you'.to_name.to_show('me','you')).to eq('me+you')
+         expect('?a?+awe'.to_name.to_show('A')).to eq('+awe')
+            expect('+awe'.to_name.to_show()).to eq('+awe')
     end
   end
 

data/spec/lib/card/query_spec.rb

@@ -8,36 +8,36 @@ describe Card::Query do
 
   describe 'append' do
     it "should find real cards" do
-      Card::Query.new(:name=>[:in, 'C', 'D', 'F'], :append=>'A' ).run.map(&:name).sort.should == ["C+A", "D+A", "F+A"]
+      expect(Card::Query.new(:name=>[:in, 'C', 'D', 'F'], :append=>'A' ).run.map(&:name).sort).to eq(["C+A", "D+A", "F+A"])
     end
 
     it "should absolutize names" do
-      Card::Query.new(:name=>[:in, 'C', 'D', 'F'], :append=>'_right', :context=>'B+A' ).run.map(&:name).sort.should == ["C+A", "D+A", "F+A"]
+      expect(Card::Query.new(:name=>[:in, 'C', 'D', 'F'], :append=>'_right', :context=>'B+A' ).run.map(&:name).sort).to eq(["C+A", "D+A", "F+A"])
     end
 
     it "should find virtual cards" do
-      Card::Query.new(:name=>[:in, 'C', 'D'], :append=>'*plus cards' ).run.map(&:name).sort.should == ["C+*plus cards", "D+*plus cards"]
+      expect(Card::Query.new(:name=>[:in, 'C', 'D'], :append=>'*plus cards' ).run.map(&:name).sort).to eq(["C+*plus cards", "D+*plus cards"])
     end
   end
 
   describe "in" do
     it "should work for content options" do
-      Card::Query.new(:in=>['AlphaBeta', 'Theta']).run.map(&:name).sort.should == %w(A+B T)
+      expect(Card::Query.new(:in=>['AlphaBeta', 'Theta']).run.map(&:name).sort).to eq(%w(A+B T))
     end
 
     it "should find the same thing in full syntax" do
-      Card::Query.new(:content=>[:in,'Theta','AlphaBeta']).run.map(&:name).sort.should == %w(A+B T)
+      expect(Card::Query.new(:content=>[:in,'Theta','AlphaBeta']).run.map(&:name).sort).to eq(%w(A+B T))
     end
 
     it "should work on types" do
-      Card::Query.new(:type=>[:in,'Cardtype E', 'Cardtype F']).run.map(&:name).sort.should == %w(type-e-card type-f-card)
+      expect(Card::Query.new(:type=>[:in,'Cardtype E', 'Cardtype F']).run.map(&:name).sort).to eq(%w(type-e-card type-f-card))
     end
   end
 
   describe "symbolization" do
     it "should handle array values" do
       query = {'plus'=>['tags',{'refer_to'=>'cookies'}]}
-      Card::Query.new(query).query.should== {:plus=>['tags',{:refer_to=>'cookies'}]}
+      expect(Card::Query.new(query).query).to eq({:plus=>['tags',{:refer_to=>'cookies'}]})
     end
   end
 
@@ -47,38 +47,38 @@ describe Card::Query do
 
   describe "member_of/member" do
     it "member_of should find members" do
-      Card::Query.new( :member_of => "r1" ).run.map(&:name).sort.should == %w(u1 u2 u3)
+      expect(Card::Query.new( :member_of => "r1" ).run.map(&:name).sort).to eq(%w(u1 u2 u3))
     end
     it "member should find roles" do
-      Card::Query.new( :member => {:match=>"u1"} ).run.map(&:name).sort.should == %w(r1 r2 r3)
+      expect(Card::Query.new( :member => {:match=>"u1"} ).run.map(&:name).sort).to eq(%w(r1 r2 r3))
     end
   end
 
 
   describe "not" do
     it "should exclude cards matching not criteria" do
-      Card::Query.new(:plus=>"A", :not=>{:plus=>"A+B"}).run.map(&:name).sort.should==%w{ B D E F }
+      expect(Card::Query.new(:plus=>"A", :not=>{:plus=>"A+B"}).run.map(&:name).sort).to eq(%w{ B D E F })
     end
   end
   
   
   describe "multiple values" do
     it "should handle multiple values for relational keys" do
-      Card::Query.new( :member_of=>[:all, {:name=>'r1'}, {:key=>'r2'} ], :return=>:name).run.sort.should == %w{ u1 u2 }
-      Card::Query.new( :member_of=>[      {:name=>'r1'}, {:key=>'r2'} ], :return=>:name).run.sort.should == %w{ u1 u2 }
-      Card::Query.new( :member_of=>[:any, {:name=>'r1'}, {:key=>'r2'} ], :return=>:name).run.sort.should == %w{ u1 u2 u3 }      
+      expect(Card::Query.new( :member_of=>[:all, {:name=>'r1'}, {:key=>'r2'} ], :return=>:name).run.sort).to eq(%w{ u1 u2 })
+      expect(Card::Query.new( :member_of=>[      {:name=>'r1'}, {:key=>'r2'} ], :return=>:name).run.sort).to eq(%w{ u1 u2 })
+      expect(Card::Query.new( :member_of=>[:any, {:name=>'r1'}, {:key=>'r2'} ], :return=>:name).run.sort).to eq(%w{ u1 u2 u3 })      
     end
     
     it "should handle multiple values for plus_relational keys" do
-      Card::Query.new( :right_plus=>[ :all, 'e', 'c' ], :return=>:name ).run.sort.should == %w{ A } #explicit conjunction
-      Card::Query.new( :right_plus=>[ ['e',{}],  'c' ], :return=>:name ).run.sort.should == %w{ A } # first element is array
-      Card::Query.new( :right_plus=>[ 'e', 'c'       ], :return=>:name ).run.sort.should == []      # NOT interpreted as multi-value
+      expect(Card::Query.new( :right_plus=>[ :all, 'e', 'c' ], :return=>:name ).run.sort).to eq(%w{ A }) #explicit conjunction
+      expect(Card::Query.new( :right_plus=>[ ['e',{}],  'c' ], :return=>:name ).run.sort).to eq(%w{ A }) # first element is array
+      expect(Card::Query.new( :right_plus=>[ 'e', 'c'       ], :return=>:name ).run.sort).to eq([])      # NOT interpreted as multi-value
     end
 
     it "should handle multiple values for plus_relational keys" do
-      Card::Query.new( :refer_to=>[ :and, 'a', 'b' ], :return=>:name ).run.sort.should == %w{ Y } 
-      Card::Query.new( :refer_to=>[       'a', 'T' ], :return=>:name ).run.sort.should == %w{ X Y }
-      Card::Query.new( :refer_to=>[ :or,  'b', 'z' ], :return=>:name ).run.sort.should == %w{ A B Y}
+      expect(Card::Query.new( :refer_to=>[ :and, 'a', 'b' ], :return=>:name ).run.sort).to eq(%w{ Y }) 
+      expect(Card::Query.new( :refer_to=>[       'a', 'T' ], :return=>:name ).run.sort).to eq(%w{ X Y })
+      expect(Card::Query.new( :refer_to=>[ :or,  'b', 'z' ], :return=>:name ).run.sort).to eq(%w{ A B Y})
     end
         
   end
@@ -86,15 +86,15 @@ describe Card::Query do
 
   describe "edited_by/editor_of" do
     it "should find card edited by joe using subspec" do
-      Card::Query.new(:edited_by=>{:match=>"Joe User"}, :sort=>"name").run.should == [Card["JoeLater"], Card["JoeNow"]]
+      expect(Card::Query.new(:edited_by=>{:match=>"Joe User"}, :sort=>"name").run).to eq([Card["JoeLater"], Card["JoeNow"]])
     end
     it "should find 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
-      Card::Query.new(:edited_by=>"Wagn Bot", :name=>'A', :return=>'name', :limit=>1).run.first.should == "A"
+      expect(Card::Query.new(:edited_by=>"Wagn Bot", :name=>'A', :return=>'name', :limit=>1).run.first).to eq("A")
     end
     it "should fail gracefully if user isn't there" do
-      Card::Query.new(:edited_by=>"Joe LUser", :sort=>"name", :limit=>1).run.should == []
+      expect(Card::Query.new(:edited_by=>"Joe LUser", :sort=>"name", :limit=>1).run).to eq([])
     end
 
     it "should not give duplicate results for multiple edits" do
@@ -103,11 +103,11 @@ describe Card::Query do
       c.save
       c.content="test3"
       c.save!
-      Card::Query.new(:edited_by=>"Joe User").run.map(&:name).sort.should == ["JoeLater","JoeNow"]
+      expect(Card::Query.new(:edited_by=>"Joe User").run.map(&:name).sort).to eq(["JoeLater","JoeNow"])
     end
 
     it "should find joe user among card's editors" do
-      Card::Query.new(:editor_of=>'JoeLater').run.map(&:name).should == ['Joe User']
+      expect(Card::Query.new(:editor_of=>'JoeLater').run.map(&:name)).to eq(['Joe User'])
     end
   end
 
@@ -118,11 +118,11 @@ describe Card::Query do
 
     it "should find Joe User as the card's creator" do
       c = Card.fetch 'Create Test'
-      Card::Query.new(:creator_of=>'Create Test').run.first.name.should == 'Joe User'
+      expect(Card::Query.new(:creator_of=>'Create Test').run.first.name).to eq('Joe User')
     end
 
     it "should find card created by Joe User" do
-      Card::Query.new(:created_by=>'Joe User', :eq=>'sufficiently distinctive').run.first.name.should == 'Create Test'
+      expect(Card::Query.new(:created_by=>'Joe User', :eq=>'sufficiently distinctive').run.first.name).to eq('Create Test')
     end
   end
 
@@ -134,31 +134,31 @@ describe Card::Query do
     end
 
     it "should find Joe User as the card's last editor" do
-      Card::Query.new(:last_editor_of=>'A').run.first.name.should == 'Joe User'
+      expect(Card::Query.new(:last_editor_of=>'A').run.first.name).to eq('Joe User')
     end
 
     it "should find card created by Joe User" do
-      Card::Query.new(:last_edited_by=>'Joe User', :eq=>'peculicious').run.first.name.should == 'A'
+      expect(Card::Query.new(:last_edited_by=>'Joe User', :eq=>'peculicious').run.first.name).to eq('A')
     end
   end
 
   describe "keyword" do
     it "should escape nonword characters" do
-      Card::Query.new( :match=>"two :(!").run.map(&:name).sort.should==CARDS_MATCHING_TWO
+      expect(Card::Query.new( :match=>"two :(!").run.map(&:name).sort).to eq(CARDS_MATCHING_TWO)
     end
   end
 
   describe "search count" do
     it "should count search" do
       s = Card.create! :name=>"ksearch", :type=>'Search', :content=>'{"match":"$keyword"}'
-      s.count(:vars=>{:keyword=>"two"}).should==CARDS_MATCHING_TWO.length
+      expect(s.count(:vars=>{:keyword=>"two"})).to eq(CARDS_MATCHING_TWO.length)
     end
   end
 
 
   describe "cgi_params" do
     it "should match content from cgi" do
-      Card::Query.new( :match=>"$keyword", :vars=>{:keyword=>"two"}).run.map(&:name).sort.should==CARDS_MATCHING_TWO
+      expect(Card::Query.new( :match=>"$keyword", :vars=>{:keyword=>"two"}).run.map(&:name).sort).to eq(CARDS_MATCHING_TWO)
     end
   end
 
@@ -166,26 +166,26 @@ describe Card::Query do
 
   describe "content equality" do
     it "should match content explicitly" do
-      Card::Query.new( :content=>['=',"I'm number two"] ).run.map(&:name).should==["Joe User"]
+      expect(Card::Query.new( :content=>['=',"I'm number two"] ).run.map(&:name)).to eq(["Joe User"])
     end
     it "should match via shortcut" do
-      Card::Query.new( '='=>"I'm number two" ).run.map(&:name).should==["Joe User"]
+      expect(Card::Query.new( '='=>"I'm number two" ).run.map(&:name)).to eq(["Joe User"])
     end
   end
 
 
   describe "links" do
 
-    it("should handle refer_to")      { Card::Query.new( :refer_to=>'Z').run.map(&:name).sort.should == %w{ A B } }
-    it("should handle link_to")       { Card::Query.new( :link_to=>'Z').run.map(&:name).should == %w{ A } }
-    it("should handle include" )      { Card::Query.new( :include=>'Z').run.map(&:name).should == %w{ B } }
-    it("should handle linked_to_by")   { Card::Query.new( :linked_to_by=>'A').run.map(&:name).should == %w{ Z } }
-    it("should handle included_by")    { Card::Query.new( :included_by=>'B').run.map(&:name).should == %w{ Z } }
-    it("should handle referred_to_by") { Card::Query.new( :referred_to_by=>'X').run.map(&:name).sort.should == %w{ A A+B T } }
+    it("should handle refer_to")      { expect(Card::Query.new( :refer_to=>'Z').run.map(&:name).sort).to eq(%w{ A B }) }
+    it("should handle link_to")       { expect(Card::Query.new( :link_to=>'Z').run.map(&:name)).to eq(%w{ A }) }
+    it("should handle include" )      { expect(Card::Query.new( :include=>'Z').run.map(&:name)).to eq(%w{ B }) }
+    it("should handle linked_to_by")   { expect(Card::Query.new( :linked_to_by=>'A').run.map(&:name)).to eq(%w{ Z }) }
+    it("should handle included_by")    { expect(Card::Query.new( :included_by=>'B').run.map(&:name)).to eq(%w{ Z }) }
+    it("should handle referred_to_by") { expect(Card::Query.new( :referred_to_by=>'X').run.map(&:name).sort).to eq(%w{ A A+B T }) }
   end
 
   describe "relative links" do
-    it("should handle relative refer_to")  { Card::Query.new( :refer_to=>'_self', :context=>'Z').run.map(&:name).sort.should == %w{ A B } }
+    it("should handle relative refer_to")  { expect(Card::Query.new( :refer_to=>'_self', :context=>'Z').run.map(&:name).sort).to eq(%w{ A B }) }
   end
 
   describe "permissions" do
@@ -193,33 +193,33 @@ describe Card::Query do
       Card::Auth.as_bot  do
         Card.create :name=>"C+*self+*read", :type=>'Pointer', :content=>"[[R1]]"
       end
-      Card::Query.new( :plus=>"A" ).run.map(&:name).sort.should == %w{ B D E F }
+      expect(Card::Query.new( :plus=>"A" ).run.map(&:name).sort).to eq(%w{ B D E F })
     end
   end
 
   describe "basics" do
     it "should be case insensitive for name" do
-      Card::Query.new( :name=>"a" ).run.first.name.should == 'A'
+      expect(Card::Query.new( :name=>"a" ).run.first.name).to eq('A')
     end
 
     it "should find plus cards" do
-      Card::Query.new( :plus=>"A" ).run.map(&:name).sort.should == A_JOINEES
+      expect(Card::Query.new( :plus=>"A" ).run.map(&:name).sort).to eq(A_JOINEES)
     end
 
     it "should find connection cards" do
-      Card::Query.new( :part=>"A" ).run.map(&:name).sort.should == ["A+B", "A+C", "A+D", "A+E", "C+A", "D+A", "F+A"]
+      expect(Card::Query.new( :part=>"A" ).run.map(&:name).sort).to eq(["A+B", "A+C", "A+D", "A+E", "C+A", "D+A", "F+A"])
     end
 
     it "should find left connection cards" do
-      Card::Query.new( :left=>"A" ).run.map(&:name).sort.should == ["A+B", "A+C", "A+D", "A+E"]
+      expect(Card::Query.new( :left=>"A" ).run.map(&:name).sort).to eq(["A+B", "A+C", "A+D", "A+E"])
     end
 
     it "should find right connection cards" do
-      Card::Query.new( :right=>"A" ).run.map(&:name).sort.should == ["C+A", "D+A", "F+A"]
+      expect(Card::Query.new( :right=>"A" ).run.map(&:name).sort).to eq(["C+A", "D+A", "F+A"])
     end
 
     it "should return count" do
-      Card.count_by_wql( :part=>"A" ).should == 7
+      expect(Card.count_by_wql( :part=>"A" )).to eq(7)
     end
 
 
@@ -227,11 +227,11 @@ describe Card::Query do
 
   describe "limit and offset" do
     it "should return limit" do
-      Card::Query.new( :part=>"A", :limit=>5 ).run.size.should == 5
+      expect(Card::Query.new( :part=>"A", :limit=>5 ).run.size).to eq(5)
     end
 
     it "should not break if offset but no limit" do
-      Card::Query.new( :part=>"A", :offset=>5 ).run.size.should_not == 0
+      expect(Card::Query.new( :part=>"A", :offset=>5 ).run.size).not_to eq(0)
     end
 
   end
@@ -240,15 +240,15 @@ describe Card::Query do
     user_cards =  ["Joe Admin", "Joe Camel", "Joe User", "John", "No Count", "Sample User", "Sara", "u1", "u2", "u3"].sort
 
     it "should find cards of this type" do
-      Card::Query.new( :type=>"_self", :context=>'User').run.map(&:name).sort.should == user_cards
+      expect(Card::Query.new( :type=>"_self", :context=>'User').run.map(&:name).sort).to eq(user_cards)
     end
 
     it "should find User cards " do
-      Card::Query.new( :type=>"User" ).run.map(&:name).sort.should == user_cards
+      expect(Card::Query.new( :type=>"User" ).run.map(&:name).sort).to eq(user_cards)
     end
 
     it "should handle casespace variants" do
-      Card::Query.new( :type=>"users" ).run.map(&:name).sort.should == user_cards
+      expect(Card::Query.new( :type=>"users" ).run.map(&:name).sort).to eq(user_cards)
     end
 
   end
@@ -257,7 +257,7 @@ describe Card::Query do
   describe "trash handling" do
     it "should not find cards in the trash" do
       Card["A+B"].delete!
-      Card::Query.new( :left=>"A" ).run.map(&:name).sort.should == ["A+C", "A+D", "A+E"]
+      expect(Card::Query.new( :left=>"A" ).run.map(&:name).sort).to eq(["A+C", "A+D", "A+E"])
     end
   end
 
@@ -271,23 +271,24 @@ describe Card::Query do
       Card.create! :type=>"Nudetype", :name=>"nsecond", :content=>"b"
       Card.create! :type=>"Nudetype", :name=>"nthird", :content=>"c"
       # WACK!! this doesn't seem to be consistent across fixture generations :-/
-      Card::Query.new( :type=>"Nudetype", :sort=>"create", :dir=>"asc").run.map(&:name).should ==
+      expect(Card::Query.new( :type=>"Nudetype", :sort=>"create", :dir=>"asc").run.map(&:name)).to eq(
         ["nfirst","nsecond","nthird"]
+      )
     end
 
     it "should sort by name" do
-      Card::Query.new( :name=> %w{ in B Z A Y C X }, :sort=>"alpha", :dir=>"desc" ).run.map(&:name).should ==  %w{ Z Y X C B A }
-      Card::Query.new( :name=> %w{ in B Z A Y C X }, :sort=>"name", :dir=>"desc"  ).run.map(&:name).should ==  %w{ Z Y X C B A }
+      expect(Card::Query.new( :name=> %w{ in B Z A Y C X }, :sort=>"alpha", :dir=>"desc" ).run.map(&:name)).to eq(%w{ Z Y X C B A })
+      expect(Card::Query.new( :name=> %w{ in B Z A Y C X }, :sort=>"name", :dir=>"desc"  ).run.map(&:name)).to eq(%w{ Z Y X C B A })
       #Card.create! :name => 'the alphabet'
       #Card::Query.new( :name=>["in", "B", "C", "the alphabet"], :sort=>"name").run.map(&:name).should ==  ["the alphabet", "B", "C"]
     end
 
     it "should sort by content" do
-      Card::Query.new( :name=> %w{ in Z T A }, :sort=>"content").run.map(&:name).should ==  %w{ A Z T }
+      expect(Card::Query.new( :name=> %w{ in Z T A }, :sort=>"content").run.map(&:name)).to eq(%w{ A Z T })
     end
 
     it "should play nice with match" do
-      Card::Query.new( :match=>'Z', :type=>'Basic', :sort=>"content").run.map(&:name).should ==  %w{ A B Z }
+      expect(Card::Query.new( :match=>'Z', :type=>'Basic', :sort=>"content").run.map(&:name)).to eq(%w{ A B Z })
     end
 
     it "should sort by plus card content" do
@@ -299,14 +300,14 @@ describe Card::Query do
 
         w = Card::Query.new( :right_plus=>'*table of contents', :sort=>{ :right=>'*table_of_contents'}, :sort_as=>'integer'  ) # FIXME: codename
         #warn "sql from new wql = #{w.sql}"
-        w.run.map(&:name).should == %w{ *all *account+*right Basic+*type Config+*self Setting+*self }
+        expect(w.run.map(&:name)).to eq(%w{ *all Basic+*type Setting+*self })
       end
     end
 
     it "should sort by count" do
       Card::Auth.as_bot do
         w = Card::Query.new( :name=>[:in,'Sara','John','Joe User'], :sort=>{ :right=>'*watcher', :item=>'referred_to', :return=>'count' } )
-        w.run.map(&:name).should == ['Joe User','John','Sara']
+        expect(w.run.map(&:name)).to eq(['Joe User','John','Sara'])
       end
     end
 
@@ -322,47 +323,47 @@ describe Card::Query do
 
   describe "params" do
     it "should merge in params as normal WQL" do
-      Card::Query.new( :params=>{:name=>"two"}).run.first.name.should=='Two'
+      expect(Card::Query.new( :params=>{:name=>"two"}).run.first.name).to eq('Two')
     end
   end
 
 
   describe "match" do
     it "should reach content and name via shortcut" do
-      Card::Query.new( :match=>"two").run.map(&:name).sort.should==CARDS_MATCHING_TWO
+      expect(Card::Query.new( :match=>"two").run.map(&:name).sort).to eq(CARDS_MATCHING_TWO)
     end
 
     it "should get only content when content is explicit" do
-      Card::Query.new( :content=>[:match, "two"] ).run.map(&:name).sort.should==["Joe User"]
+      expect(Card::Query.new( :content=>[:match, "two"] ).run.map(&:name).sort).to eq(["Joe User"])
     end
 
     it "should get only name when name is explicit" do
-      Card::Query.new( :name=>[:match, "two"] ).run.map(&:name).sort.should==["One+Two","One+Two+Three","Two"].sort
+      expect(Card::Query.new( :name=>[:match, "two"] ).run.map(&:name).sort).to eq(["One+Two","One+Two+Three","Two"].sort)
     end
   end
 
   describe "and" do
     it "should act as a simple passthrough" do
-      Card::Query.new(:and=>{:match=>'two'}).run.map(&:name).sort.should==CARDS_MATCHING_TWO
+      expect(Card::Query.new(:and=>{:match=>'two'}).run.map(&:name).sort).to eq(CARDS_MATCHING_TWO)
     end
 
     it "should work within 'or'" do
       results = Card::Query.new(:or=>{:name=>'Z', :and=>{:left=>'A', :right=>'C'}}).run
-      results.length.should == 2
-      results.map(&:name).sort.should == ['A+C','Z']
+      expect(results.length).to eq(2)
+      expect(results.map(&:name).sort).to eq(['A+C','Z'])
     end
   end
 
   describe "any/or" do
     it "should work with :plus" do
-      Card::Query.new(:plus=>"A", :or =>{:name=>'B', :match=>'K'}).run.map(&:name).sort.should==%w{ B }
-      Card::Query.new(:plus=>"A", :any=>{:name=>'B', :match=>'K'}).run.map(&:name).sort.should==%w{ B }
+      expect(Card::Query.new(:plus=>"A", :or =>{:name=>'B', :match=>'K'}).run.map(&:name).sort).to eq(%w{ B })
+      expect(Card::Query.new(:plus=>"A", :any=>{:name=>'B', :match=>'K'}).run.map(&:name).sort).to eq(%w{ B })
     end
   end
 
   describe "offset" do
     it "should not break count" do
-      Card.count_by_wql({:match=>'two', :offset=>1}).should==CARDS_MATCHING_TWO.length
+      expect(Card.count_by_wql({:match=>'two', :offset=>1})).to eq(CARDS_MATCHING_TWO.length)
     end
   end
 
@@ -375,16 +376,16 @@ describe Card::Query do
     end
 
     it "should find cards returned by search of given name" do
-      Card::Query.new(:found_by=>'Simple Search').run.first.name.should=='A'
+      expect(Card::Query.new(:found_by=>'Simple Search').run.first.name).to eq('A')
     end
     it "should find cards returned by virtual cards" do
-      Card::Query.new(:found_by=>'Image+*type+by name').run.map(&:name).sort.should==Card.search(:type=>'Image').map(&:name).sort
+      expect(Card::Query.new(:found_by=>'Image+*type+by name').run.map(&:name).sort).to eq(Card.search(:type=>'Image').map(&:name).sort)
     end
     it "should play nicely with other properties and relationships" do
-      Card::Query.new(:plus=>{:found_by=>'Simple Search'}).run.map(&:name).sort.should==Card::Query.new(:plus=>{:name=>'A'}).run.map(&:name).sort
+      expect(Card::Query.new(:plus=>{:found_by=>'Simple Search'}).run.map(&:name).sort).to eq(Card::Query.new(:plus=>{:name=>'A'}).run.map(&:name).sort)
     end
     it "should be able to handle _self" do
-      Card::Query.new(:context=>'Simple Search', :left=>{:found_by=>'_self'}, :right=>'B').run.first.name.should=='A+B'
+      expect(Card::Query.new(:context=>'Simple Search', :left=>{:found_by=>'_self'}, :right=>'B').run.first.name).to eq('A+B')
     end
 
   end
@@ -396,28 +397,28 @@ describe Card::Query do
   describe "relative" do
     it "should clean wql" do
       wql = Card::Query.new( :part=>"_self",:context=>'A' )
-      wql.query[:part].should == 'A'
+      expect(wql.query[:part]).to eq('A')
     end
 
     it "should find connection cards" do
-      Card::Query.new( :part=>"_self", :context=>'A' ).run.map(&:name).sort.should == ["A+B", "A+C", "A+D", "A+E", "C+A", "D+A", "F+A"]
+      expect(Card::Query.new( :part=>"_self", :context=>'A' ).run.map(&:name).sort).to eq(["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
-      Card['B+A'].should be_nil
-      Card::Query.new( :left=>'_right', :right=>'_left', :context=>'B+A' ).run.map(&:name).should == ['A+B']
+      expect(Card['B+A']).to be_nil
+      expect(Card::Query.new( :left=>'_right', :right=>'_left', :context=>'B+A' ).run.map(&:name)).to eq(['A+B'])
     end
 
     it "should find plus cards for _self" do
-      Card::Query.new( :plus=>"_self", :context=>"A" ).run.map(&:name).sort.should == A_JOINEES
+      expect(Card::Query.new( :plus=>"_self", :context=>"A" ).run.map(&:name).sort).to eq(A_JOINEES)
     end
 
     it "should find plus cards for _left" do
-      Card::Query.new( :plus=>"_left", :context=>"A+B" ).run.map(&:name).sort.should == A_JOINEES
+      expect(Card::Query.new( :plus=>"_left", :context=>"A+B" ).run.map(&:name).sort).to eq(A_JOINEES)
     end
 
     it "should find plus cards for _right" do
-      Card::Query.new( :plus=>"_right", :context=>"C+A" ).run.map(&:name).sort.should == A_JOINEES
+      expect(Card::Query.new( :plus=>"_right", :context=>"C+A" ).run.map(&:name).sort).to eq(A_JOINEES)
     end
 
   end
@@ -429,7 +430,7 @@ describe Card::Query do
       Card::Query.new( { :left=>{:name=>"X"}}).sql.scan( /read_rule_id IN \([\d\,]+\)/ ) do |m|
         perm_count+=1
       end
-      perm_count.should == 2
+      expect(perm_count).to eq(2)
     end
 
 #    it "are not generated inside .without_nested_permissions block" do