card 1.16.6 → 1.16.7

data/spec/lib/card/diff_spec.rb

@@ -17,12 +17,12 @@ describe Card::Diff do
   def diff old_s, new_s, opts=@opts
     Card::Diff.complete(old_s, new_s, opts)
   end
-  
+
   def summary old_s, new_s, opts=@opts
     Card::Diff.summary(old_s, new_s, opts)
   end
-  
-  
+
+
   old_p = '<p>old</p>'
   new_p = '<p>new</p>'
   new_h = '<h1>new</h1>'
@@ -33,111 +33,111 @@ describe Card::Diff do
   describe 'traffic light' do
     it 'is green for addition' do
       a = "a"
-      b = "a b" 
+      b = "a b"
       db = Card::Diff::DiffBuilder.new(a,b)
       expect(db.green?).to be_truthy
       expect(db.red?).to be_falsey
     end
     it 'is red for deletion' do
       a = "a"
-      b = "" 
+      b = ""
       db = Card::Diff::DiffBuilder.new(a,b)
       expect(db.green?).to be_falsey
       expect(db.red?).to be_truthy
     end
     it 'is green and red for change' do
       a = "a"
-      b = "b" 
+      b = "b"
       db = Card::Diff::DiffBuilder.new(a,b)
       expect(db.green?).to be_truthy
       expect(db.red?).to be_truthy
     end
     it 'is off for no change' do
       a = "a"
-      b = "a" 
+      b = "a"
       db = Card::Diff::DiffBuilder.new(a,b)
       expect(db.green?).to be_falsey
       expect(db.red?).to be_falsey
     end
   end
-  
-  
+
+
   describe 'summary' do
     before(:all) do
-      @opts = {:format=>:html}
+      @opts = {format: :html}
     end
-    
+
     it 'omits unchanged text' do
       a = "<p>this was the original string</p>"
-      b = "<p>this is the new string</p>" 
+      b = "<p>this is the new string</p>"
       expect(summary a, b).to eq(
         "...#{del 'was'}#{ins 'is'}...#{del 'original'}#{ins 'new'}..."
       )
     end
-    
+
     it 'no ellipsis if changes fit exactly' do
       a = "123"
-      b = "456" 
-      expect(summary a, b, :summary=>{:length=>6}).to eq(
+      b = "456"
+      expect(summary a, b, summary: {length: 6}).to eq(
         "#{del '123'}#{ins '456'}"
       )
     end
-    
+
     it 'green ellipsis if added text does not fit' do
       a = "123"
-      b = "5678" 
-      expect(summary a, b, :summary=>{:length=>6}).to eq(
+      b = "5678"
+      expect(summary a, b, summary: {length: 6}).to eq(
         "#{del '123'}#{ins '...'}"
       )
     end
-    
+
     it 'neutral ellipsis if complete change does not fit' do
       a = "123 123"
-      b = "456 456" 
-      expect(summary a, b, :summary=>{:length=>9}).to eq(
+      b = "456 456"
+      expect(summary a, b, summary: {length: 9}).to eq(
         "#{del '123'}#{ins '456'}..."
       )
     end
-    
+
     it 'red ellipsis if deleted text partially fits' do
       a = "123456"
-      b = "567" 
-      expect(summary a, b, :summary=>{:length=>4}).to eq(
+      b = "567"
+      expect(summary a, b, summary: {length: 4}).to eq(
         "#{del '1...'}"
       )
     end
-    
+
     it 'green ellipsis if added text partially fits' do
       a = "1234"
-      b = "56789" 
-      expect(summary a, b, :summary=>{:length=>8}).to eq(
+      b = "56789"
+      expect(summary a, b, summary: {length: 8}).to eq(
         "#{del '1234'}#{ins '5...'}"
       )
     end
-    
+
     it 'removes html tags' do
       a = "<a>A</a>"
-      b = "<b>B</b>" 
-      expect(summary a, b, :format=>:html).to eq(
+      b = "<b>B</b>"
+      expect(summary a, b, format: :html).to eq(
         "#{del 'A'}#{ins 'B'}"
       )
     end
-    
+
     it 'with html tags in raw format' do
       a = "<a>1</a>"
-      b = "<b>1</b>" 
-      expect(summary a, b, :format=>:raw).to eq(
+      b = "<b>1</b>"
+      expect(summary a, b, format: :raw).to eq(
         "#{del( tag 'a' )}#{ins(tag 'b')}...#{del( tag '/a' )}#{ins(tag '/b')}"
       )
     end
-    
+
   end
-  
+
   context "html format" do
     before(:all) do
-      @opts = {:format=>:html}
+      @opts = {format: :html}
     end
-    
+
     it "doesn't change a text without changes" do
       text = "Hello World!\n How are you?"
       expect(diff text, text).to eq(text)
@@ -148,10 +148,10 @@ describe Card::Diff do
     it 'ignores html changes' do
       expect(diff old_p, new_h).to eq("<h1>#{del 'old'}#{ins 'new'}</h1>")
     end
-    
+
     it 'diff with multiple paragraphs' do
       a = "<p>this was the original string</p>"
-      b = "<p>this is</p>\n<p> the new string</p>\n<p>around the world</p>" 
+      b = "<p>this is</p>\n<p> the new string</p>\n<p>around the world</p>"
 
       expect(diff a, b).to eq(
           "<p>this #{del 'was'}#{ins 'is'}</p>"+
@@ -162,49 +162,49 @@ describe Card::Diff do
           )
     end
   end
-  
+
   context "text format" do
     before(:all) do
-      @opts = {:format=>:text}
+      @opts = {format: :text}
     end
-  
+
     it 'removes html' do
       expect(p_diff).to eq("#{del 'old'}#{ins 'new'}")
     end
-    
+
     it 'compares complete links' do
-      diff = Card::Diff.complete("[[A]]\n[[B]]", "[[A]]\n[[C]]", :format=>:html)
+      diff = Card::Diff.complete("[[A]]\n[[B]]", "[[A]]\n[[C]]", format: :html)
       expect(diff).to eq( "[[A]]\n#{del '[[B]]'}#{ins '[[C]]'}")
     end
-    
+
     it 'compares complete inclusions' do
-      diff = Card::Diff.complete("{{A}}\n{{B}}", "{{A}}\n{{C}}", :format=>:html)
+      diff = Card::Diff.complete("{{A}}\n{{B}}", "{{A}}\n{{C}}", format: :html)
       expect(diff).to eq( "{{A}}\n#{del '{{B}}'}#{ins '{{C}}'}")
     end
-    
+
   end
-  
+
   context "raw format" do
     before(:all) do
-      @opts = {:format=>:raw}
+      @opts = {format: :raw}
     end
-  
+
     it 'excapes html' do
       expect(p_diff).to eq("#{tag 'p'}#{del 'old'}#{ins 'new'}#{tag '/p'}")
     end
-    
+
     it 'diff for tag change' do
       expect(diff old_p, new_h).to eq( del("#{tag 'p'}old#{tag '/p'}") + ins("#{tag 'h1'}new#{tag '/h1'}") )
-    end    
+    end
   end
-  
+
   context 'pointer format' do
     before(:all) do
-      @opts = {:format=>:pointer}
+      @opts = {format: :pointer}
     end
-    
+
     it 'removes square brackets' do
       expect(diff "[[Hello]]", "[[Hi]]").to eq( del('Hello') + ins('Hi') )
-    end 
+    end
   end
 end

data/spec/lib/card/format_spec.rb

@@ -6,26 +6,26 @@ describe Card::Format do
     let(:format) { described_class.new Card.new }
 
     it "should respect defaults" do
-      expect(format.show_view?( :menu, :default_visibility=>:show )).to be_truthy
-      expect(format.show_view?( :menu, :default_visibility=>:hide )).to be_falsey
+      expect(format.show_view?( :menu, default_visibility: :show )).to be_truthy
+      expect(format.show_view?( :menu, default_visibility: :hide )).to be_falsey
       expect(format.show_view?( :menu, {}                          )).to be_truthy
     end
 
     it "should respect developer default overrides" do
-      expect(format.show_view?( :menu, :optional_menu=>:show, :default_visibility=>:hide )).to be_truthy
-      expect(format.show_view?( :menu, :optional_menu=>:hide, :default_visibility=>:show )).to be_falsey
-      expect(format.show_view?( :menu, :optional_menu=>:hide                             )).to be_falsey
+      expect(format.show_view?( :menu, optional_menu: :show, default_visibility: :hide )).to be_truthy
+      expect(format.show_view?( :menu, optional_menu: :hide, default_visibility: :show )).to be_falsey
+      expect(format.show_view?( :menu, optional_menu: :hide                             )).to be_falsey
     end
 
     it "should handle args from inclusions" do
-      expect(format.show_view?( :menu, :show=>'menu', :default_visibility=>:hide         )).to be_truthy
-      expect(format.show_view?( :menu, :hide=>'menu, paging', :default_visibility=>:show )).to be_falsey
-      expect(format.show_view?( :menu, :show=>'menu', :optional_menu=>:hide              )).to be_truthy
+      expect(format.show_view?( :menu, show: 'menu', default_visibility: :hide         )).to be_truthy
+      expect(format.show_view?( :menu, hide: 'menu, paging', default_visibility: :show )).to be_falsey
+      expect(format.show_view?( :menu, show: 'menu', optional_menu: :hide              )).to be_truthy
     end
 
     it "should handle hard developer overrides" do
-      expect(format.show_view?( :menu, :optional_menu=>:always, :hide=>'menu' )).to be_truthy
-      expect(format.show_view?( :menu, :optional_menu=>:never,  :show=>'menu' )).to be_falsey
+      expect(format.show_view?( :menu, optional_menu: :always, hide: 'menu' )).to be_truthy
+      expect(format.show_view?( :menu, optional_menu: :never,  show: 'menu' )).to be_falsey
     end
 
   end
@@ -71,7 +71,7 @@ describe Card::Format do
     it "formats page_path" do
       expect(text_format.page_path card.cardname).to eq '/'+card.name
       expect(html_format.page_path card.cardname).to eq '/'+card.name
-      expect(text_format.page_path card.cardname, :format => 'txt', :opt1 => 11, :opt2 => 'foo').to eq "/#{card.name}.txt?opt1=11&opt2=foo"
+      expect(text_format.page_path card.cardname, format: 'txt', opt1: 11, opt2: 'foo').to eq "/#{card.name}.txt?opt1=11&opt2=foo"
     end
 
     it "fomats full path and url" do

data/spec/lib/card/query_spec.rb

@@ -1,456 +1,573 @@
 # -*- encoding : utf-8 -*-
 
-A_JOINEES = ["B", "C", "D", "E", "F"]
-
-CARDS_MATCHING_TWO = ["Two","One+Two","One+Two+Three","Joe User"].sort
+A_JOINEES = %w( B C D E F )
+CARDS_MATCHING_TWO = ['Joe User', 'One+Two', 'One+Two+Three', 'Two']
 
 describe Card::Query do
+  subject do
+    Card::Query.run @query.reverse_merge return: :name, sort: :name
+  end
 
   describe 'append' do
-    it "should find real cards" do
-      expect(Card::Query.new(:name=>[:in, 'C', 'D', 'F'], :append=>'A' ).run.map(&:name).sort).to eq(["C+A", "D+A", "F+A"])
+    it 'should find real cards' do
+      @query = {
+        name: [:in, 'C', 'D', 'F'],
+        append: 'A'
+      }
+      is_expected.to eq(%w( C+A D+A F+A ))
+    end
+
+    it 'should absolutize names' do
+      @query = {
+        name: [:in, 'C', 'D', 'F'],
+        append: '_right',
+        context: 'B+A'
+      }
+      is_expected.to eq(%w( C+A D+A F+A ))
+    end
+
+    it 'should find virtual cards' do
+      @query = {
+        name: [:in, 'C', 'D'],
+        append: '*plus cards'
+      }
+      is_expected.to eq(['C+*plus cards', 'D+*plus cards'])
     end
+  end
 
-    it "should absolutize names" do
-      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"])
+  describe 'in' do
+    it 'should work for content options' do
+      @query = { in: %w( AlphaBeta Theta ) }
+      is_expected.to eq(%w( A+B T ))
     end
 
-    it "should find virtual cards" do
-      expect(Card::Query.new(:name=>[:in, 'C', 'D'], :append=>'*plus cards' ).run.map(&:name).sort).to eq(["C+*plus cards", "D+*plus cards"])
+    it 'should find the same thing in full syntax' do
+      @query = { content: [:in, 'Theta', 'AlphaBeta'] }
+      is_expected.to eq(%w( A+B T ))
     end
-  end
 
-  describe "in" do
-    it "should work for content options" do
-      expect(Card::Query.new(:in=>['AlphaBeta', 'Theta']).run.map(&:name).sort).to eq(%w(A+B T))
+    it 'should work on types' do
+      @query = { type: [:in, 'Cardtype E', 'Cardtype F'] }
+      is_expected.to eq(%w(type-e-card type-f-card))
     end
+  end
 
-    it "should find the same thing in full syntax" do
-      expect(Card::Query.new(:content=>[:in,'Theta','AlphaBeta']).run.map(&:name).sort).to eq(%w(A+B T))
+  describe 'member_of/member' do
+    it 'member_of should find members' do
+      @query = { member_of: 'r1' }
+      is_expected.to eq(%w(u1 u2 u3))
     end
 
-    it "should work on types" do
-      expect(Card::Query.new(:type=>[:in,'Cardtype E', 'Cardtype F']).run.map(&:name).sort).to eq(%w(type-e-card type-f-card))
+    it 'member should find roles' do
+      @query = { member: { match: 'u1' } }
+      is_expected.to eq(%w(r1 r2 r3))
     end
   end
 
-  describe "symbolization" do
-    it "should handle array values" do
-      query = {'plus'=>['tags',{'refer_to'=>'cookies'}]}
-      expect(Card::Query.new(query).query).to eq({:plus=>['tags',{:refer_to=>'cookies'}]})
+  describe 'not' do
+    it 'should exclude 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 ))
     end
   end
 
+  describe 'multiple values' do
+    it 'should handle :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
+      @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
+      @query = { member_of: [:any, { name: 'r1' }, { key: 'r2' }] }
+      is_expected.to eq(%w( u1 u2 u3 ))
+    end
 
-
-  describe "member_of/member" do
-    it "member_of should find members" do
-      expect(Card::Query.new( :member_of => "r1" ).run.map(&:name).sort).to eq(%w(u1 u2 u3))
+    it 'should handle :any as a relationship' do
+      @query = { member_of: { any: [{ name: 'r1' }, { key: 'r2' }] } }
+      is_expected.to eq(%w( u1 u2 u3 ))
     end
-    it "member should find roles" do
-      expect(Card::Query.new( :member => {:match=>"u1"} ).run.map(&:name).sort).to eq(%w(r1 r2 r3))
+
+    it 'should handle explicit conjunctions in plus_relational keys' do
+      @query = { right_plus: [:all, 'e', 'c'] }
+      is_expected.to eq(%w( A ))
     end
-  end
 
+    it 'should handle 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
 
-  describe "not" do
-    it "should exclude cards matching not criteria" do
-      expect(Card::Query.new(:plus=>"A", :not=>{:plus=>"A+B"}).run.map(&:name).sort).to eq(%w{ B D E F })
+    it 'should 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
-  end
-  
-  
-  describe "multiple values" do
-    it "should handle multiple values for relational keys" do
-      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 })      
+
+    it 'should handle :and for references' do
+      @query = { refer_to: [:and, 'a', 'b'] }
+      is_expected.to eq(%w( Y ))
     end
 
-    it "should handle multiple values for plus_relational keys" do
-      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
+    it 'should handle :or for references' do
+      @query = { refer_to: [:or, 'b', 'z'] }
+      is_expected.to eq(%w( A B Y))
     end
 
-    it "should handle multiple values for plus_relational keys" do
-      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})
+    it 'should handle 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
-      expect(Card::Query.new(:edited_by=>{:match=>"Joe User"}, :sort=>"name").run).to include(Card["JoeLater"], Card["JoeNow"])
+  describe 'edited_by/editor_of' do
+    it 'should find 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
-      #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
-      expect(Card::Query.new(:edited_by=>"Wagn Bot", :name=>'A', :return=>'name', :limit=>1).run.first).to eq("A")
+
+    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
+      @query = { edited_by: 'Wagn Bot', name: 'A' }
+      is_expected.to eq(%w( A ))
     end
-    it "should fail gracefully if user isn't there" do
-      expect(Card::Query.new(:edited_by=>"Joe LUser", :sort=>"name", :limit=>1).run).to eq([])
+
+    it 'should fail 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
-      c=Card["JoeNow"]
-      c.content="testagagin"
+    it 'should not give duplicate results for multiple edits' do
+      c = Card['JoeNow']
+      c.content = 'testagagin'
       c.save
-      c.content="test3"
+      c.content = 'test3'
       c.save!
-      expect(Card::Query.new(:edited_by=>"Joe User").run.map(&:name).count("JoeNow")).to eq 1
+      @query = { edited_by: 'Joe User' }
+      is_expected.to eq(%w( JoeLater JoeNow ))
     end
 
-    it "should find joe user among card's editors" do
-      expect(Card::Query.new(:editor_of=>'JoeLater').run.map(&:name)).to eq(['Joe User'])
+    it 'should find joe user among card\'s editors' do
+      @query = { editor_of: 'JoeLater' }
+      is_expected.to eq(['Joe User'])
     end
   end
 
-  describe "created_by/creator_of" do
+  describe 'created_by/creator_of' do
     before do
-      Card.create :name=>'Create Test', :content=>'sufficiently distinctive'
+      Card.create name: 'Create Test', content: 'sufficiently distinctive'
     end
 
     it "should find Joe User as the card's creator" do
-      c = Card.fetch 'Create Test'
-      expect(Card::Query.new(:creator_of=>'Create Test').run.first.name).to eq('Joe User')
+      @query = { creator_of: 'Create Test' }
+      is_expected.to eq(['Joe User'])
     end
 
-    it "should find card created by Joe User" do
-      expect(Card::Query.new(:created_by=>'Joe User', :eq=>'sufficiently distinctive').run.first.name).to eq('Create Test')
+    it 'should find card created by Joe User' do
+      @query = { created_by: 'Joe User', eq: 'sufficiently distinctive' }
+      is_expected.to eq(['Create Test'])
     end
   end
 
-  describe "last_edited_by/last_editor_of" do
+  describe 'last_edited_by/last_editor_of' do
     before do
-      c=Card.fetch('A')
-      c.content='peculicious'
+      c = Card.fetch('A')
+      c.content = 'peculicious'
       c.save!
     end
 
     it "should find Joe User as the card's last editor" do
-      expect(Card::Query.new(:last_editor_of=>'A').run.first.name).to eq('Joe User')
+      @query = { last_editor_of: 'A' }
+      is_expected.to eq(['Joe User'])
+    end
+
+    it 'should find card created by Joe User' do
+      @query = { last_edited_by: 'Joe User', eq: 'peculicious' }
+      is_expected.to eq(['A'])
     end
+  end
 
-    it "should find card created by Joe User" do
-      expect(Card::Query.new(:last_edited_by=>'Joe User', :eq=>'peculicious').run.first.name).to eq('A')
+  describe 'keyword' do
+    it 'should escape nonword characters' do
+      @query = { match: 'two :(!' }
+      is_expected.to eq(CARDS_MATCHING_TWO)
     end
   end
 
-  describe "keyword" do
-    it "should escape nonword characters" do
-      expect(Card::Query.new( :match=>"two :(!").run.map(&:name).sort).to eq(CARDS_MATCHING_TWO)
+  describe 'search count' do
+    it 'should return integer' do
+      search = Card.create!(
+        name: 'tmpsearch',
+        type: 'Search',
+        content: '{"match":"two"}'
+      )
+      expect(search.count).to eq(CARDS_MATCHING_TWO.length + 1)
     end
   end
 
-  describe "search count" do
-    it "should count search" do
-      s = Card.create! :name=>"ksearch", :type=>'Search', :content=>'{"match":"$keyword"}'
-      expect(s.count(:vars=>{:keyword=>"two"})).to eq(CARDS_MATCHING_TWO.length)
+  describe 'cgi_params' do
+    it 'should match 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
+      @query = { content: ['=', "I'm number two"] }
+      is_expected.to eq(['Joe User'])
+    end
 
-  describe "cgi_params" do
-    it "should match content from cgi" do
-      expect(Card::Query.new( :match=>"$keyword", :vars=>{:keyword=>"two"}).run.map(&:name).sort).to eq(CARDS_MATCHING_TWO)
+    it 'should match 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
+      @query = { refer_to: 'Z' }
+      is_expected.to eq(%w( A B ))
+    end
 
+    it 'should handle link_to' do
+      @query = { link_to: 'Z' }
+      is_expected.to eq(%w( A ))
+    end
 
-  describe "content equality" do
-    it "should match content explicitly" do
-      expect(Card::Query.new( :content=>['=',"I'm number two"] ).run.map(&:name)).to eq(["Joe User"])
+    it 'should handle include' do
+      @query = { include: 'Z' }
+      is_expected.to eq(%w( B ))
     end
-    it "should match via shortcut" do
-      expect(Card::Query.new( '='=>"I'm number two" ).run.map(&:name)).to eq(["Joe User"])
+
+    it 'should handle linked_to_by' do
+      @query = { linked_to_by: 'A' }
+      is_expected.to eq(%w( Z ))
     end
-  end
 
+    it 'should handle included_by' do
+      @query = { included_by: 'B' }
+      is_expected.to eq(%w( Z ))
+    end
 
-  describe "links" do
+    it 'should handle referred_to_by' do
+      @query = { referred_to_by: 'X' }
+      is_expected.to eq(%w( A A+B T ))
+    end
+  end
 
-    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 }) }
+  describe 'compound relationships' do
+    it 'right_plus should handle subqueries' do
+      @query = { right_plus: ['*create', refer_to: 'Anyone']}
+      is_expected.to eq(['Fruit+*type', 'Sign up+*type'])
+    end
+
+    it 'plus should handle subqueries' do # albeit more slowly :)
+      @query = { plus: ['*create', refer_to: 'Anyone']}
+      is_expected.to eq(['Fruit+*type', 'Sign up+*type'])
+    end
   end
 
-  describe "relative links" do
-    it("should handle relative refer_to")  { expect(Card::Query.new( :refer_to=>'_self', :context=>'Z').run.map(&:name).sort).to eq(%w{ A B }) }
+  describe 'relative links' do
+    it 'should handle 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
-      Card::Auth.as_bot  do
-        Card.create :name=>"C+*self+*read", :type=>'Pointer', :content=>"[[R1]]"
+  describe 'permissions' do
+    it 'should not find cards not in group' do
+      Card::Auth.as_bot do
+        Card.create name: 'C+*self+*read', type: 'Pointer', content: '[[R1]]'
       end
-      expect(Card::Query.new( :plus=>"A" ).run.map(&:name).sort).to eq(%w{ B D E F })
+      @query = { plus: 'A' }
+      is_expected.to eq(%w( B D E F ))
     end
   end
 
-  describe "basics" do
-    it "should be case insensitive for name" do
-      expect(Card::Query.new( :name=>"a" ).run.first.name).to eq('A')
+  describe 'basics' do
+    it 'should be case insensitive for name' do
+      @query = { name: 'a' }
+      is_expected.to eq(['A'])
     end
 
-    it "should find plus cards" do
-      expect(Card::Query.new( :plus=>"A" ).run.map(&:name).sort).to eq(A_JOINEES)
+    it 'should find plus cards' do
+      @query = { plus: 'A' }
+      is_expected.to eq(A_JOINEES)
     end
 
-    it "should find connection cards" do
-      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"])
+    it 'should find 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
-      expect(Card::Query.new( :left=>"A" ).run.map(&:name).sort).to eq(["A+B", "A+C", "A+D", "A+E"])
+    it 'should find 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" do
-      expect(Card::Query.new( :right=>"A" ).run.map(&:name).sort).to eq(["C+A", "D+A", "F+A"])
+    it 'should find right connection cards based on name' do
+      @query = { right: 'A' }
+      is_expected.to eq(%w( C+A D+A F+A ))
     end
 
-    it "should return count" do
-      expect(Card.count_by_wql( :part=>"A" )).to eq(7)
+    it 'should find 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
+      expect(Card.count_by_wql part: 'A').to eq(7)
+    end
   end
 
-  describe "limit and offset" do
-    it "should return limit" do
-      expect(Card::Query.new( :part=>"A", :limit=>5 ).run.size).to eq(5)
+  describe 'limit and offset' do
+    it 'should return limit' do
+      @query = { part: 'A', limit: 5 }
+      expect(subject.size).to eq(5)
     end
 
-    it "should not break if offset but no limit" do
-      expect(Card::Query.new( :part=>"A", :offset=>5 ).run.size).not_to eq(0)
+    it 'should 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
+      query = { match: 'two', offset: 1 }
+      expect(Card.count_by_wql(query)).to eq(CARDS_MATCHING_TWO.length)
+    end
   end
 
-  describe "type" do
-    user_cards =  ["Big Brother", "Joe Admin", "Joe Camel", "Joe User", "John", "Narcissist", "No Count", "Optic fan", "Sample User", "Sara", "Sunglasses fan", "u1", "u2", "u3"].sort
+  describe 'type' do
+    user_cards = [
+      'Big Brother', 'Joe Admin', 'Joe Camel', 'Joe User', 'John',
+      'Narcissist', 'No Count', 'Optic fan', 'Sample User', 'Sara',
+      'Sunglasses fan', 'u1', 'u2', 'u3'
+    ].sort
 
-    it "should find cards of this type" do
-      expect(Card::Query.new( :type=>"_self", :context=>'User').run.map(&:name).sort).to eq(user_cards)
+    it 'should find cards of this type' do
+      @query = { type: '_self', context: 'User' }
+      is_expected.to eq(user_cards)
     end
 
-    it "should find User cards " do
-      expect(Card::Query.new( :type=>"User" ).run.map(&:name).sort).to eq(user_cards)
+    it 'should find User cards ' do
+      @query = { type: 'User' }
+      is_expected.to eq(user_cards)
     end
 
-    it "should handle casespace variants" do
-      expect(Card::Query.new( :type=>"users" ).run.map(&:name).sort).to eq(user_cards)
+    it 'should handle 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
-      Card["A+B"].delete!
-      expect(Card::Query.new( :left=>"A" ).run.map(&:name).sort).to eq(["A+C", "A+D", "A+E"])
+  describe 'trash handling' do
+    it 'should not find cards in the trash' do
+      Card['A+B'].delete!
+      @query = { left: 'A' }
+      is_expected.to eq(['A+C', 'A+D', 'A+E'])
     end
   end
 
-
-
-
-  describe "order" do
-    it "should sort 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
-      wql = { :sort=>"create", :name=>[:match,'classic bootstrap skin']}
-      expect( Card::Query.new(wql).run.map(&:name) ).to eq( ["classic bootstrap skin","classic bootstrap skin head"] )
+  describe 'order' do
+    it 'should sort 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
+      @query = { sort: 'create', name: [:match, 'classic bootstrap skin'] }
+      is_expected.to eq(
+        ['classic bootstrap skin', 'classic bootstrap skin head']
+      )
     end
 
-    it "should sort by name" do
-      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"]
+    it 'should sort 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
-      expect(Card::Query.new( :name=> %w{ in Z T A }, :sort=>"content").run.map(&:name)).to eq(%w{ A Z T })
+    it 'should sort 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
-      expect(Card::Query.new( :match=>'Z', :type=>'Basic', :sort=>"content").run.map(&:name)).to eq(%w{ A B Z })
+    it 'should play 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 'should sort by plus card content' do
       Card::Auth.as_bot do
         c = Card.fetch('Setting+*self+*table of contents')
         c.content = '10'
         c.save
-        c = Card.create! :name=>'Basic+*type+*table of contents', :content=>'3'
-
-        w = Card::Query.new( :right_plus=>'*table of contents', :sort=>{ :right=>'*table_of_contents'}, :sort_as=>'integer'  )
-        #warn "sql from new wql = #{w.sql}"
-        expect(w.run.map(&:name)).to eq(%w{ *all Basic+*type Setting+*self })
+        Card.create! name: 'Basic+*type+*table of contents', content: '3'
+
+        @query = {
+          right_plus: '*table of contents',
+          sort: { right: '*table_of_contents' },
+          sort_as: 'integer'
+        }
+        is_expected.to eq(%w( *all Basic+*type Setting+*self ))
       end
     end
 
-    it "should sort by count" do
+    it 'should sort by count' do
       Card::Auth.as_bot do
-        w = Card::Query.new( :name=>[:in,'*always','*never','*edited'], :sort=>{ :right=>'*follow', :item=>'referred_to', :return=>'count' } )
-        expect(w.run.map(&:name)).to eq(['*never','*edited','*always'])
+        @query = {
+          name: [:in, '*always', '*never', '*edited'],
+          sort: { right: '*follow', item: 'referred_to', return: 'count' }
+        }
+        is_expected.to eq(['*never', '*edited', '*always'])
       end
     end
 
-  #  it "should sort by update" do
-  #    # do this on a restricted set so it won't change every time we add a card..
-  #    Card::Query.new( :match=>"two", :sort=>"update", :dir=>"desc").run.map(&:name).should == ["One+Two+Three", "One+Two","Two","Joe User"]
-  #    Card["Two"].update_attributes! :content=>"new bar"
-  #    Card::Query.new( :match=>"two", :sort=>"update", :dir=>"desc").run.map(&:name).should == ["Two","One+Two+Three", "One+Two","Joe User"]
-  #  end
-  #
-
+    #  it 'should sort by update' do
+    #    # do this on a restricted set so it won't change every time we
+    #    #  add a card..
+    #    Card::Query.run(
+    #    match: 'two', sort: 'update', dir: 'desc'
+    #    ).map(&:name).should == ['One+Two+Three', 'One+Two','Two','Joe User']
+    #    Card['Two'].update_attributes! content: 'new bar'
+    #    Card::Query.run(
+    #    match: 'two', sort: 'update', dir: 'desc'
+    #    ).map(&:name).should == ['Two','One+Two+Three', 'One+Two','Joe User']
+    #  end
   end
 
-  describe "params" do
-    it "should merge in params as normal WQL" do
-      expect(Card::Query.new( :params=>{:name=>"two"}).run.first.name).to eq('Two')
+  describe 'match' do
+    it 'should reach content and name via shortcut' do
+      @query = { match: 'two' }
+      is_expected.to eq(CARDS_MATCHING_TWO)
     end
-  end
-
 
-  describe "match" do
-    it "should reach content and name via shortcut" do
-      expect(Card::Query.new( :match=>"two").run.map(&:name).sort).to eq(CARDS_MATCHING_TWO)
+    it 'should get only content when content is explicit' do
+      @query = { content: [:match, 'two'] }
+      is_expected.to eq(['Joe User'])
     end
 
-    it "should get only content when content is explicit" do
-      expect(Card::Query.new( :content=>[:match, "two"] ).run.map(&:name).sort).to eq(["Joe User"])
+    it 'should get only name when name is explicit' do
+      @query = { name: [:match, 'two'] }
+      is_expected.to eq(['One+Two', 'One+Two+Three', 'Two'])
     end
+  end
 
-    it "should get only name when name is explicit" do
-      expect(Card::Query.new( :name=>[:match, "two"] ).run.map(&:name).sort).to eq(["One+Two","One+Two+Three","Two"].sort)
+  describe 'and' do
+    it 'should act as a simple passthrough with operators' do
+      @query = { and: { match: 'two' } }
+      is_expected.to eq(CARDS_MATCHING_TWO)
     end
-  end
 
-  describe "and" do
-    it "should act as a simple passthrough" do
-      expect(Card::Query.new(:and=>{:match=>'two'}).run.map(&:name).sort).to eq(CARDS_MATCHING_TWO)
-      expect(Card::Query.new(:and=>{}, :type=>"Cardtype E").run.first.name).to eq('type-e-card')
+    it 'should act 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
-      results = Card::Query.new(:or=>{:name=>'Z', :and=>{:left=>'A', :right=>'C'}}).run
-      expect(results.length).to eq(2)
-      expect(results.map(&:name).sort).to eq(['A+C','Z'])
+
+    it 'should work within "or"' do
+      @query = { or: { name: 'Z', and: { left: 'A', right: 'C' } } }
+      is_expected.to eq(['A+C', 'Z'])
     end
   end
 
-  describe "any/or" do
-    it "should work with :plus" do
-      expect(Card::Query.new(:plus=>"A", :or =>{:name=>'B', :match=>'K'}, :return=>'name').run.sort).to eq(%w{ B })
-      expect(Card::Query.new(:plus=>"A", :any=>{:name=>'B', :match=>'K'}, :return=>'name').run.sort).to eq(%w{ B })
-      expect(Card::Query.new(:or=>{:right_plus=>"A", :plus=>'B'}, :return=>'name').run.sort).to eq(%w{ A C D F })
+  describe 'any' do
+    it 'should work with :plus' do
+      @query = { plus: 'A', any: { name: 'B', match: 'K' } }
+      is_expected.to eq(['B'])
     end
-  end
 
-  describe "offset" do
-    it "should not break count" do
-      expect(Card.count_by_wql({:match=>'two', :offset=>1})).to eq(CARDS_MATCHING_TWO.length)
+    it 'should work with multiple plusses' do
+      @query = { or: { right_plus: 'A', plus: 'B' } }
+      is_expected.to eq(%w( A C D F ))
     end
   end
 
-
-  #=end
-  describe "found_by" do
+  describe 'found_by' do
     before do
-      Card::Auth.current_id = Card::WagnBotID
-      c = Card.create(:name=>'Simple Search', :type=>'Search', :content=>'{"name":"A"}')
+      Card::Auth.as_bot
+      Card.create(
+        name: 'Simple Search', type: 'Search', content: '{"name":"A"}'
+      )
     end
 
-    it "should find cards returned by search of given name" do
-      expect(Card::Query.new(:found_by=>'Simple Search').run.first.name).to eq('A')
+    it 'should find 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
-      expect(Card::Query.new(:found_by=>'Image+*type+by name').run.map(&:name).sort).to eq(Card.search(:type=>'Image').map(&:name).sort)
+
+    it 'should find 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
-      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)
-      expect(Card::Query.new(:found_by=>'A+*self', :plus=>'C').run.map(&:name)).to eq(%w{ A })
-      
+
+    it 'should play 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 be able to handle _self" do
-      expect(Card::Query.new(:context=>'Simple Search', :left=>{:found_by=>'_self'}, :right=>'B').run.first.name).to eq('A+B')
+
+    it 'should play 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
+      @query = {
+        context: 'Simple Search',
+        left: { found_by: '_self' },
+        right: 'B',
+        return: :name
+      }
+      is_expected.to eq(['A+B'])
+    end
   end
 
-
-
-  #=end
-
-  describe "relative" do
-    it "should clean wql" do
-      wql = Card::Query.new( :part=>"_self",:context=>'A' )
-      expect(wql.query[:part]).to eq('A')
+  describe 'relative' do
+    it 'should clean wql' do
+      query = Card::Query.new(part: '_self', context: 'A')
+      expect(query.statement[:part]).to eq('A')
     end
 
-    it "should find connection cards" do
-      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"])
+    it 'should find 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 'should be able to use parts of nonexistent cards in search' do
       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'])
+      @query = { left: '_right', right: '_left', context: 'B+A' }
+      is_expected.to eq(['A+B'])
     end
 
-    it "should find plus cards for _self" do
-      expect(Card::Query.new( :plus=>"_self", :context=>"A" ).run.map(&:name).sort).to eq(A_JOINEES)
+    it 'should find 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
-      expect(Card::Query.new( :plus=>"_left", :context=>"A+B" ).run.map(&:name).sort).to eq(A_JOINEES)
+    it 'should find 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
-      expect(Card::Query.new( :plus=>"_right", :context=>"C+A" ).run.map(&:name).sort).to eq(A_JOINEES)
+    it 'should find plus cards for _right' do
+      @query = { plus: '_right', context: 'C+A' }
+      is_expected.to eq(A_JOINEES)
     end
-
   end
 
-
-  describe "nested permissions" do
-    it "are generated by default" do
+  describe 'nested permissions' do
+    it 'are generated by default' do
       perm_count = 0
-      Card::Query.new( { :left=>{:name=>"X"}}).sql.scan( /read_rule_id IN \([\d\,]+\)/ ) do |m|
-        perm_count+=1
+      sql = Card::Query.new(left: { name: 'X' }).sql
+      sql.scan(/read_rule_id IN \([\d\,]+\)/) do
+        perm_count += 1
       end
       expect(perm_count).to eq(2)
     end
-
-#    it "are not generated inside .without_nested_permissions block" do
-#      perm_count = 0
-#      Card::Query.without_nested_permissions do
-#        Card::Query.new( { :left=>{:name=>"X"}}).sql.scan( /read_rule_id IN \([\d\,]+\)/ ) do |m|
-#          perm_count+=1
-#        end
-#      end
-#      perm_count.should == 1
-#    end
   end
-
-  #describe "return values" do
-  #  # FIXME: should do other return thingies here
-  #  it "returns name_content" do
-  #    Card::Query.new( { :name => "A+B", :return => "name_content" } ).run.should == {
-  #      "A+B" => "AlphaBeta"
-  #    }
-  #  end
-  #end
 end