card 1.16.6 → 1.16.7

data/mod/01_core/spec/set/all/permissions_spec.rb

@@ -36,12 +36,12 @@ module PermissionSpecHelper
 
   def assert_hidden( card, msg='' )
     assert !card.ok?(:read)
-    assert_equal [], Card.search(:id=>card.id).map(&:name), msg
+    assert_equal [], Card.search(id: card.id).map(&:name), msg
   end
 
   def assert_not_hidden( card, msg='' )
     assert card.ok?(:read)
-    assert_equal [card.name], Card.search(:id=>card.id).map(&:name), msg
+    assert_equal [card.name], Card.search(id: card.id).map(&:name), msg
   end
 
   def assert_locked( card, msg='' )
@@ -61,7 +61,7 @@ describe Card::Set::All::Permissions do
 
   describe "reader rules" do
     before do
-      @perm_card =  Card.new(:name=>'Home+*self+*read', :type=>'Pointer', :content=>'[[Anyone Signed In]]')
+      @perm_card =  Card.new(name: 'Home+*self+*read', type: 'Pointer', content: '[[Anyone Signed In]]')
     end
 
     it "should be *all+*read by default" do
@@ -109,7 +109,7 @@ describe Card::Set::All::Permissions do
     it "should revert to more general rule when more specific (right) rule is deleted" do
       pc = nil
       Card::Auth.as_bot do
-        pc=Card.create(:name=>'B+*right+*read', :type=>'Pointer', :content=>'[[Anyone Signed In]]')
+        pc=Card.create(name: 'B+*right+*read', type: 'Pointer', content: '[[Anyone Signed In]]')
       end
       expect(pc).to be
       card = Card.fetch('A+B')
@@ -139,7 +139,7 @@ describe Card::Set::All::Permissions do
         c= Card.fetch('Home')
         c.type_id = Card::PhraseID
         c.save!
-        Card.create(:name=>'Phrase+*type+*read', :type=>'Pointer', :content=>'[[Joe User]]')
+        Card.create(name: 'Phrase+*type+*read', type: 'Pointer', content: '[[Joe User]]')
       end
 
       card = Card.fetch('Home')
@@ -159,10 +159,10 @@ describe Card::Set::All::Permissions do
     it "should work with relative settings" do
       Card::Auth.as_bot do
         @perm_card.save!
-        all_plus = Card.fetch '*all plus+*read', :new=>{:content=>'_left'}
+        all_plus = Card.fetch '*all plus+*read', new: {content: '_left'}
         all_plus.save
       end
-      c = Card.new(:name=>'Home+Heart')
+      c = Card.new(name: 'Home+Heart')
       expect(c.who_can(:read)).to eq([Card::AnyoneSignedInID])
       expect(c.permission_rule_card(:read).first.id).to eq(@perm_card.id)
       c.save
@@ -171,10 +171,10 @@ describe Card::Set::All::Permissions do
 
     it "should get updated when relative settings change" do
       Card::Auth.as_bot do
-        all_plus = Card.fetch '*all plus+*read', :new=>{:content=>'_left'}
+        all_plus = Card.fetch '*all plus+*read', new: {content: '_left'}
         all_plus.save
       end
-      c = Card.new(:name=>'Home+Heart')
+      c = Card.new(name: 'Home+Heart')
       expect(c.who_can(:read)).to eq([Card::AnyoneID])
       expect(c.permission_rule_card(:read).first.id).to eq(Card.fetch('*all+*read').id)
       c.save
@@ -191,12 +191,12 @@ describe Card::Set::All::Permissions do
 
     it "should insure that class overrides work with relative settings" do
       Card::Auth.as_bot do
-        all_plus = Card.fetch '*all plus+*read', :new => { :content=>'_left' }
+        all_plus = Card.fetch '*all plus+*read', new: { content: '_left' }
         all_plus.save
         Card::Auth.as_bot { @perm_card.save! }
-        c = Card.create(:name=>'Home+Heart')
+        c = Card.create(name: 'Home+Heart')
         expect(c.read_rule_id).to eq(@perm_card.id)
-        r = Card.create(:name=>'Heart+*right+*read', :type=>'Pointer', :content=>'[[Administrator]]')
+        r = Card.create(name: 'Heart+*right+*read', type: 'Pointer', content: '[[Administrator]]')
         expect(Card.fetch('Home+Heart').read_rule_id).to eq(r.id)
       end
     end
@@ -229,8 +229,8 @@ describe Card::Set::All::Permissions do
       end
       Card::Auth.as(:joe_admin) do
         expect(Card::Auth.always_ok?).to eq(true)
-        Card.create! :name=>"Hidden"
-        Card.create(:name=>'Hidden+*self+*read', :type=>'Pointer', :content=>'[[Anyone Signed In]]')
+        Card.create! name: "Hidden"
+        Card.create(name: 'Hidden+*self+*read', type: 'Pointer', content: '[[Anyone Signed In]]')
       end
 
       Card::Auth.as(:anonymous) do
@@ -243,14 +243,14 @@ describe Card::Set::All::Permissions do
     it "should be granted to admin if to anybody" do
       Card::Auth.as_bot do
         c1 = Card['c1']
-        Card.create! :name=>'c1+*self+*comment', :type=>'Pointer', :content=>'[[r1]]'
+        Card.create! name: 'c1+*self+*comment', type: 'Pointer', content: '[[r1]]'
         expect(c1.who_can( :comment )).to eq([Card['r1'].id])
         expect(c1.ok?(:comment)).to be_truthy
       end
     end
 
     it "reader setting" do
-      Card.where(:trash=>false).each do |c|
+      Card.where(trash: false).each do |c|
         prc = c.permission_rule_card(:read)
         #warn "C #{c.inspect}, #{c.read_rule_id}, #{prc.first.id}, #{c.read_rule_class}, #{prc.second}, #{prc.first.inspect}" unless prc.last == c.read_rule_class && prc.first.id == c.read_rule_id
         expect(prc.last).to eq(c.read_rule_class)
@@ -261,12 +261,12 @@ describe Card::Set::All::Permissions do
 
     it "write user permissions" do
       Card::Auth.as_bot do
-        @u1.fetch(:trait=>:roles, :new=>{}).items = [@r1, @r2]
-        @u2.fetch(:trait=>:roles, :new=>{}).items = [@r1, @r3]
-        @u3.fetch(:trait=>:roles, :new=>{}).items = [@r1, @r2, @r3]
+        @u1.fetch(trait: :roles, new: {}).items = [@r1, @r2]
+        @u2.fetch(trait: :roles, new: {}).items = [@r1, @r3]
+        @u3.fetch(trait: :roles, new: {}).items = [@r1, @r2, @r3]
 
         cards=[1,2,3].map do |num|
-          Card.create(:name=>"c#{num}+*self+*update", :type=>'Pointer', :content=>"[[u#{num}]]")
+          Card.create(name: "c#{num}+*self+*update", type: 'Pointer', content: "[[u#{num}]]")
         end
       end
 
@@ -283,11 +283,11 @@ describe Card::Set::All::Permissions do
 
     it "read group permissions" do
       Card::Auth.as_bot do
-        @u1.fetch(:trait=>:roles).items = [@r1, @r2]
-        @u2.fetch(:trait=>:roles).items = [@r1, @r3]
+        @u1.fetch(trait: :roles).items = [@r1, @r2]
+        @u2.fetch(trait: :roles).items = [@r1, @r3]
 
         [1,2,3].each do |num|
-          Card.create(:name=>"c#{num}+*self+*read", :type=>'Pointer', :content=>"[[r#{num}]]")
+          Card.create(name: "c#{num}+*self+*read", type: 'Pointer', content: "[[r#{num}]]")
         end
       end
 
@@ -303,10 +303,10 @@ describe Card::Set::All::Permissions do
     it "write group permissions" do
       Card::Auth.as_bot do
         [1,2,3].each do |num|
-          Card.create(:name=>"c#{num}+*self+*update", :type=>'Pointer', :content=>"[[r#{num}]]")
+          Card.create(name: "c#{num}+*self+*update", type: 'Pointer', content: "[[r#{num}]]")
         end
 
-        @u3.fetch(:trait=>:roles, :new=>{}).items = [@r1]
+        @u3.fetch(trait: :roles, new: {}).items = [@r1]
       end
 
       %{        u1 u2 u3
@@ -328,12 +328,12 @@ describe Card::Set::All::Permissions do
 
     it "read user permissions" do
       Card::Auth.as_bot {
-        @u1.fetch(:trait=>:roles, :new=>{}).items = [@r1, @r2]
-        @u2.fetch(:trait=>:roles, :new=>{}).items = [@r1, @r3]
-        @u3.fetch(:trait=>:roles, :new=>{}).items = [@r1, @r2, @r3]
+        @u1.fetch(trait: :roles, new: {}).items = [@r1, @r2]
+        @u2.fetch(trait: :roles, new: {}).items = [@r1, @r3]
+        @u3.fetch(trait: :roles, new: {}).items = [@r1, @r2, @r3]
 
         [1,2,3].each do |num|
-          Card.create(:name=>"c#{num}+*self+*read", :type=>'Pointer', :content=>"[[u#{num}]]")
+          Card.create(name: "c#{num}+*self+*read", type: 'Pointer', content: "[[u#{num}]]")
         end
       }
 
@@ -351,8 +351,8 @@ describe Card::Set::All::Permissions do
     context "create permissions" do
       before do
         Card::Auth.as_bot do
-          Card.create! :name=>'*structure+*right+*create', :type=>'Pointer', :content=>'[[Anyone Signed In]]'
-          Card.create! :name=>'*self+*right+*create',      :type=>'Pointer', :content=>'[[Anyone Signed In]]'
+          Card.create! name: '*structure+*right+*create', type: 'Pointer', content: '[[Anyone Signed In]]'
+          Card.create! name: '*self+*right+*create',      type: 'Pointer', content: '[[Anyone Signed In]]'
         end
       end
 
@@ -361,8 +361,8 @@ describe Card::Set::All::Permissions do
           expect(Card.fetch( 'A+*self' ).ok?(:create)).to be_truthy #explicitly granted above
           expect(Card.fetch( 'A+*right').ok?(:create)).to be_falsey #by default restricted
 
-          expect(Card.fetch( 'A+*self+*structure',  :new=>{} ).ok?(:create)).to be_truthy # +*structure granted;
-          expect(Card.fetch( 'A+*right+*structure', :new=>{} ).ok?(:create)).to be_falsey # can't create A+B, therefore can't create A+B+C
+          expect(Card.fetch( 'A+*self+*structure',  new: {} ).ok?(:create)).to be_truthy # +*structure granted;
+          expect(Card.fetch( 'A+*right+*structure', new: {} ).ok?(:create)).to be_falsey # can't create A+B, therefore can't create A+B+C
         end
       end
 
@@ -373,36 +373,36 @@ describe Card::Set::All::Permissions do
       # set up cards of type TestType, 2 with nil reader, 1 with role1 reader
        Card::Auth.as_bot do
          [@c1,@c2,@c3].each do |c|
-           c.update_attributes :content => 'WeirdWord'
+           c.update_attributes content: 'WeirdWord'
          end
-         Card.create(:name=>"c1+*self+*read", :type=>'Pointer', :content=>"[[u1]]")
+         Card.create(name: "c1+*self+*read", type: 'Pointer', content: "[[u1]]")
        end
 
        Card::Auth.as(@u1) do
-         expect(Card.search(:content=>'WeirdWord').map(&:name).sort).to eq(%w( c1 c2 c3 ))
+         expect(Card.search(content: 'WeirdWord').map(&:name).sort).to eq(%w( c1 c2 c3 ))
        end
        Card::Auth.as(@u2) do
-         expect(Card.search(:content=>'WeirdWord').map(&:name).sort).to eq(%w( c2 c3 ))
+         expect(Card.search(content: 'WeirdWord').map(&:name).sort).to eq(%w( c2 c3 ))
        end
     end
 
     it "role wql" do
-      #warn "u1 roles #{Card[ @u1.id ].fetch(:trait=>:roles).item_names.inspect}"
+      #warn "u1 roles #{Card[ @u1.id ].fetch(trait: :roles).item_names.inspect}"
 
       # set up cards of type TestType, 2 with nil reader, 1 with role1 reader
       Card::Auth.as_bot do
         [@c1,@c2,@c3].each do |c|
-          c.update_attributes :content => 'WeirdWord'
+          c.update_attributes content: 'WeirdWord'
         end
-        Card.create(:name=>"c1+*self+*read", :type=>'Pointer', :content=>"[[r3]]")
+        Card.create(name: "c1+*self+*read", type: 'Pointer', content: "[[r3]]")
       end
 
       Card::Auth.as(@u1) do
-        expect(Card.search(:content=>'WeirdWord').map(&:name).sort).to eq(%w( c1 c2 c3 ))
+        expect(Card.search(content: 'WeirdWord').map(&:name).sort).to eq(%w( c1 c2 c3 ))
       end
       Card::Auth.current_id =nil # for Card::Auth.as to be effective, you can't have a logged in user
       Card::Auth.as(@u2) do
-        expect(Card.search(:content=>'WeirdWord').map(&:name).sort).to eq(%w( c2 c3 ))
+        expect(Card.search(content: 'WeirdWord').map(&:name).sort).to eq(%w( c2 c3 ))
       end
     end
 
@@ -438,7 +438,7 @@ describe Card::Set::All::Permissions do
 
   context "default permissions" do
     before do
-      @c = Card.create! :name=>"sky blue"
+      @c = Card.create! name: "sky blue"
     end
 
     it "should let anonymous users view basic cards" do
@@ -469,7 +469,7 @@ describe Card::Set::All::Permissions do
   context "settings based permissions" do
     before do
       Card::Auth.as_bot do
-        @delete_rule_card = Card.fetch '*all+*delete', :new=>{}
+        @delete_rule_card = Card.fetch '*all+*delete', new: {}
         @delete_rule_card.type_id = Card::PointerID
         @delete_rule_card.content = '[[Joe_User]]'
         @delete_rule_card.save!
@@ -477,7 +477,7 @@ describe Card::Set::All::Permissions do
     end
 
     it "should handle delete as a setting" do
-      c = Card.new :name=>'whatever'
+      c = Card.new name: 'whatever'
       expect(c.who_can(:delete)).to eq([Card['joe_user'].id])
       Card::Auth.as(:joe_user) do
         expect(c.ok?(:delete)).to eq(true)

data/mod/01_core/spec/set/all/references_spec.rb

@@ -2,7 +2,7 @@
 
 describe Card::Set::All::References do
   it "should replace references should work on inclusions inside links" do
-    card = Card.create!(:name=>"ref test", :content=>"[[test_card|test{{test}}]]"  )
+    card = Card.create!(name: "ref test", content: "[[test_card|test{{test}}]]"  )
     assert_equal "[[test_card|test{{best}}]]", card.replace_references("test", "best" )
   end
 end

data/mod/01_core/spec/set/all/rules2_spec.rb

@@ -9,7 +9,7 @@ describe Card do
 
     before do
       Card::Auth.as_bot do
-        Card.create! :name=>'Basic+*type+*table of contents', :content=>'2'
+        Card.create! name: 'Basic+*type+*table of contents', content: '2'
       end
       expect(@c1 = Card['Onne Heading']).to be
       expect(@c2 = Card['Twwo Heading']).to be
@@ -53,12 +53,12 @@ describe Card do
         expect(sets).to eq(['Cardtype A+*type', 'Cardtype A+*right'])
       end
 #      it "should show type plus right sets when they exist" do
-#        Card::Auth.as_bot { Card.create :name=>'Basic+A+*type plus right', :content=>'' }
+#        Card::Auth.as_bot { Card.create name: 'Basic+A+*type plus right', content: '' }
 #        sets = Card['A'].related_sets
 #        sets.should == ['A+*self', 'A+*right', 'Basic+A+*type plus right']
 #      end
 #      it "should show type plus right sets when they exist, and type" do
-#        Card::Auth.as_bot { Card.create :name=>'Basic+Cardtype A+*type plus right', :content=>'' }
+#        Card::Auth.as_bot { Card.create name: 'Basic+Cardtype A+*type plus right', content: '' }
 #        sets = Card['Cardtype A'].related_sets
 #        sets.should == ['Cardtype A+*self', 'Cardtype A+*type', 'Cardtype A+*right', 'Basic+Cardtype A+*type plus right']
 #      end
@@ -114,12 +114,12 @@ describe Card do
 
     before do
       Card::Auth.as_bot do
-        @c1 = Card.create :name=>'toc1', :type=>"CardtypeE",
-          :content=>Card['Onne Heading'].content
-        @c2 = Card.create :name=>'toc2', :type=>"CardtypeE",
-          :content=>Card['Twwo Heading'].content
-        @c3 = Card.create :name=>'toc3', :type=>"CardtypeE",
-          :content=>Card['Three Heading'].content
+        @c1 = Card.create name: 'toc1', type: "CardtypeE",
+          content: Card['Onne Heading'].content
+        @c2 = Card.create name: 'toc2', type: "CardtypeE",
+          content: Card['Twwo Heading'].content
+        @c3 = Card.create name: 'toc3', type: "CardtypeE",
+          content: Card['Three Heading'].content
       end
       expect(@c1.type_name).to eq('Cardtype E')
       @rule_card = @c1.rule_card(:table_of_contents)
@@ -173,10 +173,10 @@ describe Card do
   context "when I create a new rule" do
     before do
       Card::Auth.as_bot do
-        Card.create! :name=>'Basic+*type+*table of contents', :content=>'2'
-        @c1 = Card.create! :name=>'toc1', :type=>"CardtypeE", :content=>Card['Onne Heading'].content
-        @c2 = Card.create! :name=>'toc2', :content=>Card['Twwo Heading'].content
-        @c3 = Card.create! :name=>'toc3', :content=>Card['Three Heading'].content
+        Card.create! name: 'Basic+*type+*table of contents', content: '2'
+        @c1 = Card.create! name: 'toc1', type: "CardtypeE", content: Card['Onne Heading'].content
+        @c2 = Card.create! name: 'toc2', content: Card['Twwo Heading'].content
+        @c3 = Card.create! name: 'toc3', content: Card['Three Heading'].content
         expect(@c1.type_name).to eq('Cardtype E')
         @rule_card = @c1.rule_card(:table_of_contents)
 
@@ -188,7 +188,7 @@ describe Card do
           c.content = '2'
           c.save!
         else
-          c=Card.create! :name=>'CardtypeE+*type+*table of content', :content=>'2'
+          c=Card.create! name: 'CardtypeE+*type+*table of content', content: '2'
         end
       end
     end
@@ -218,7 +218,7 @@ describe Card do
     before do
       expect(@c1 = Card["Onne Heading"]).to be
       # FIXME: CardtypeE should inherit from *default => Basic
-      #@c2 = Card.create :name=>'toc2', :type=>"CardtypeE", :content=>Card['Twwo Heading'].content
+      #@c2 = Card.create name: 'toc2', type: "CardtypeE", content: Card['Twwo Heading'].content
       expect(@c2 = Card["Twwo Heading"]).to be
       expect(@c1.type_id).to eq(Card::BasicID)
       expect(@rule_card = @c1.rule_card(:table_of_contents)).to be

data/mod/01_core/spec/set/all/rules_spec.rb

@@ -7,47 +7,47 @@ describe Card::Set::All::Rules do
 
   describe "setting data setup" do
     it "should make Set of +*type" do
-      Card.create! :name=>"SpeciForm", :type=>'Cardtype'
-      expect(Card.create!( :name=>"SpeciForm+*type" ).type_code).to eq(:set)
+      Card.create! name: "SpeciForm", type: 'Cardtype'
+      expect(Card.create!( name: "SpeciForm+*type" ).type_code).to eq(:set)
     end
   end
 
   describe "#rule" do
     it "retrieves Set based value" do
-      Card.create :name => "Book+*type+*add help", :content => "authorize"
-      expect(Card.new( :type => "Book" ).rule(:add_help, :fallback=>:help)).to eq("authorize")
+      Card.create name: "Book+*type+*add help", content: "authorize"
+      expect(Card.new( type: "Book" ).rule(:add_help, fallback: :help)).to eq("authorize")
     end
 
     it "retrieves default values" do
-      #Card.create :name => "all Basic cards", :type => "Set", :content => "{\"type\": \"Basic\"}"  #defaults should work when other Sets are present
-      assert c=Card.create(:name => "*all+*add help", :content => "lobotomize")
-#      Card.default_rule(:add_help, :fallback=>:help).should == "lobotomize"
-      expect(Card.new( :type => "Basic" ).rule(:add_help, :fallback=>:help)).to eq("lobotomize")
+      #Card.create name: "all Basic cards", type: "Set", content: "{\"type\": \"Basic\"}"  #defaults should work when other Sets are present
+      assert c=Card.create(name: "*all+*add help", content: "lobotomize")
+#      Card.default_rule(:add_help, fallback: :help).should == "lobotomize"
+      expect(Card.new( type: "Basic" ).rule(:add_help, fallback: :help)).to eq("lobotomize")
     end
 
     it "retrieves single values" do
-      Card.create! :name => "banana+*self+*help", :content => "pebbles"
+      Card.create! name: "banana+*self+*help", content: "pebbles"
       expect(Card["banana"].rule(:help)).to eq("pebbles")
     end
-    
+
     context 'with fallback' do
       before do
-        Card.create :name => "*all+*help", :content => "edit any kind of card"
+        Card.create name: "*all+*help", content: "edit any kind of card"
       end
 
       it "retrieves default setting" do
-        expect(Card.new( :type => "Book" ).rule(:add_help, :fallback=>:help)).to eq("edit any kind of card")
+        expect(Card.new( type: "Book" ).rule(:add_help, fallback: :help)).to eq("edit any kind of card")
       end
 
       it "retrieves primary setting" do
-        Card.create :name => "*all+*add help", :content => "add any kind of card"
-        expect(Card.new( :type => "Book" ).rule(:add_help, :fallback=>:help)).to eq("add any kind of card")
+        Card.create name: "*all+*add help", content: "add any kind of card"
+        expect(Card.new( type: "Book" ).rule(:add_help, fallback: :help)).to eq("add any kind of card")
       end
 
       it "retrieves more specific default setting" do
-        Card.create :name => "*all+*add help", :content => "add any kind of card"
-        Card.create :name => "*Book+*type+*help", :content => "edit a Book"
-        expect(Card.new( :type => "Book" ).rule(:add_help, :fallback=>:help)).to eq("add any kind of card")
+        Card.create name: "*all+*add help", content: "add any kind of card"
+        Card.create name: "*Book+*type+*help", content: "edit a Book"
+        expect(Card.new( type: "Book" ).rule(:add_help, fallback: :help)).to eq("add any kind of card")
       end
     end
   end
@@ -58,9 +58,9 @@ describe Card::Set::All::Rules do
       @pointer_settings =  [ :options, :options_label, :input ]
     end
     it "doesn't fail on nonexistent trunks" do
-      expect(Card.new(:name=>'foob+*right').setting_codenames_by_group.class).to eq(Hash)
+      expect(Card.new(name: 'foob+*right').setting_codenames_by_group.class).to eq(Hash)
     end
-    
+
     it "returns universal setting names for non-pointer set" do
       skip "Different api, we should just put the tests in a new spec for that"
       snbg = Card.fetch('*star').setting_codenames_by_group
@@ -72,55 +72,55 @@ describe Card::Set::All::Rules do
 
 
     it "returns pointer-specific setting names for pointer card" do
-      c = Card.fetch 'Fruit+*type+*create+*self', :new=>{}
+      c = Card.fetch 'Fruit+*type+*create+*self', new: {}
       snbg = c.setting_codenames_by_group
       expect(snbg[:pointer]).to eq(@pointer_settings)
     end
 
   end
-  
+
   describe 'user specific rules' do
     before do
       Card::Auth.current_id = Card.fetch('Joe User').id
     end
-    
+
     it "user rule is recognized as rule" do
       Card::Auth.as_bot do
-        card = Card.create(:name => "Book+*type+Joe User+*follow", :content => "[[*always]]")
+        card = Card.create(name: "Book+*type+Joe User+*follow", content: "[[*always]]")
         expect(card.is_rule?).to be_truthy
       end
     end
-    
+
     it "retrieves Set based value" do
       Card::Auth.as_bot do
-        Card.create :name => "Book+*type+Joe User+*follow", :content => "[[*always]]"
+        Card.create name: "Book+*type+Joe User+*follow", content: "[[*always]]"
       end
-      expect(Card.new( :type => "Book" ).rule(:follow)).to eq("[[*always]]")
+      expect(Card.new( type: "Book" ).rule(:follow)).to eq("[[*always]]")
     end
-    
+
     it "retrieves user indepedent Set based value" do
       Card::Auth.as_bot do
-        Card.create :name => "Book+*type+*all+*follow", :content => "[[Home]]"
+        Card.create name: "Book+*type+*all+*follow", content: "[[Home]]"
       end
-      expect(Card.new( :type => "Book" ).rule(:follow)).to eq("[[Home]]")
+      expect(Card.new( type: "Book" ).rule(:follow)).to eq("[[Home]]")
     end
-    
+
     it "uses *all user rule when no super.s"
-    
+
     it "user-specific value overwrites user-independent value" do
       Card::Auth.as_bot do
-        Card.create :name => "Book+*type+Joe User+*follow", :content => "[[*never]]"
-        Card.create :name => "Book+*type+*all+*follow", :content => "[[*always]]"
+        Card.create name: "Book+*type+Joe User+*follow", content: "[[*never]]"
+        Card.create name: "Book+*type+*all+*follow", content: "[[*always]]"
       end
-      expect(Card.new( :type => "Book" ).rule(:follow)).to eq("[[*never]]")
+      expect(Card.new( type: "Book" ).rule(:follow)).to eq("[[*never]]")
     end
-    
+
     describe '#all_user_ids_with_rule_for' do
       it "returns all user with values for the given Set and rule" do
         Card::Auth.as_bot do
-          Card.create(:name => "Book+*type+Joe User+*follow", :content => "[[Home]]")
+          Card.create(name: "Book+*type+Joe User+*follow", content: "[[Home]]")
           Card::Auth.current_id = Card.fetch('Joe Admin').id
-          Card.create(:name => "Book+*type+Joe Admin+*follow", :content => "[[Home]]")
+          Card.create(name: "Book+*type+Joe Admin+*follow", content: "[[Home]]")
           user_ids = Card.all_user_ids_with_rule_for( Card.fetch("Book+*type"), :follow ).sort
           expect(user_ids).to eq [Card['Joe User'].id, Card['Joe Admin'].id].sort
         end