card 1.18.6 → 1.19.0

data/spec/models/card/create_spec.rb

@@ -1,101 +1,101 @@
 # -*- encoding : utf-8 -*-
 
 # FIXME: this shouldn't be here
-describe Card::Set::Type::Cardtype, '.create with :codename' do
-  it 'should work' do
-    card = Card.create! name: 'Foo Type', codename: 'foo',
-                        type: 'Cardtype'
+describe Card::Set::Type::Cardtype, ".create with :codename" do
+  it "should work" do
+    card = Card.create! name: "Foo Type", codename: "foo",
+                        type: "Cardtype"
     expect(card.type_code).to eq(:cardtype)
   end
 end
 
-describe Card, 'created by Card.new' do
+describe Card, "created by Card.new" do
   before(:each) do
     Card::Auth.as_bot do
-      @c = Card.new name: 'New Card', content: 'Great Content'
+      @c = Card.new name: "New Card", content: "Great Content"
     end
   end
 
-  it 'should not override explicit content with default content' do
+  it "should not override explicit content with default content" do
     Card::Auth.as_bot do
-      Card.create! name: 'blue+*right+*default', content: 'joe', type: 'Pointer'
-      c = Card.new name: 'Lady+blue', content: '[[Jimmy]]'
-      expect(c.content).to eq('[[Jimmy]]')
+      Card.create! name: "blue+*right+*default", content: "joe", type: "Pointer"
+      c = Card.new name: "Lady+blue", content: "[[Jimmy]]"
+      expect(c.content).to eq("[[Jimmy]]")
     end
   end
 end
 
-describe Card, 'created by Card.create with valid attributes' do
+describe Card, "created by Card.create with valid attributes" do
   before(:each) do
     Card::Auth.as_bot do
-      @b = Card.create name: 'New Card', content: 'Great Content'
+      @b = Card.create name: "New Card", content: "Great Content"
       @c = Card.find(@b.id)
     end
   end
 
-  it 'does not have errors' do
+  it "does not have errors" do
     expect(@b.errors.size).to eq(0)
   end
-  it 'has the right class' do
+  it "has the right class" do
     expect(@c.class).to eq(Card)
   end
-  it 'has the right key'  do
-    expect(@c.key).to eq('new_card')
+  it "has the right key"  do
+    expect(@c.key).to eq("new_card")
   end
-  it 'has the right name' do
-    expect(@c.name).to eq('New Card')
+  it "has the right name" do
+    expect(@c.name).to eq("New Card")
   end
-  it 'has the right content' do
-    expect(@c.content).to eq('Great Content')
+  it "has the right content" do
+    expect(@c.content).to eq("Great Content")
   end
 
-  it 'has the right content' do
-    @c.db_content == 'Great Content'
+  it "has the right content" do
+    @c.db_content == "Great Content"
   end
 
-  it 'is findable by name' do
-    expect(Card['New Card'].class).to eq(Card)
+  it "is findable by name" do
+    expect(Card["New Card"].class).to eq(Card)
   end
 end
 
-describe Card, 'create junction two parts' do
+describe Card, "create junction two parts" do
   before(:each) do
-    @c = Card.create! name: 'Peach+Pear', content: 'juicy'
+    @c = Card.create! name: "Peach+Pear", content: "juicy"
   end
 
   it "doesn't have errors" do
     expect(@c.errors.size).to eq(0)
   end
 
-  it 'creates junction card' do
-    expect(Card['Peach+Pear'].class).to eq(Card)
+  it "creates junction card" do
+    expect(Card["Peach+Pear"].class).to eq(Card)
   end
 
-  it 'creates trunk card' do
-    expect(Card['Peach'].class).to eq(Card)
+  it "creates trunk card" do
+    expect(Card["Peach"].class).to eq(Card)
   end
 
-  it 'creates tag card' do
-    expect(Card['Pear'].class).to eq(Card)
+  it "creates tag card" do
+    expect(Card["Pear"].class).to eq(Card)
   end
 end
 
-describe Card, 'create junction three parts' do
-  it 'creates very left card' do
-    Card.create! name: 'Apple+Peach+Pear', content: 'juicy'
-    expect(Card['Apple'].class).to eq(Card)
+describe Card, "create junction three parts" do
+  it "creates very left card" do
+    Card.create! name: "Apple+Peach+Pear", content: "juicy"
+    expect(Card["Apple"].class).to eq(Card)
   end
 
-  it 'sets left and right ids' do
-    Card.create! name: 'Sugar+Milk+Flour', content: 'tasty'
-    sugar_milk = Card['Sugar+Milk']
-    sugar_milk_flour = Card['Sugar+Milk+Flour']
+  it "sets left and right ids" do
+    Card.create! name: "Sugar+Milk+Flour", content: "tasty"
+    sugar_milk = Card["Sugar+Milk"]
+    sugar_milk_flour = Card["Sugar+Milk+Flour"]
     expect(sugar_milk_flour.left_id).to eq(sugar_milk.id)
-    expect(sugar_milk_flour.right_id).to eq(Card.fetch_id('Flour'))
-    expect(sugar_milk.left_id).to eq(Card.fetch_id('Sugar'))
-    expect(sugar_milk.right_id).to eq(Card.fetch_id('Milk'))
+    expect(sugar_milk_flour.right_id).to eq(Card.fetch_id("Flour"))
+    expect(sugar_milk.left_id).to eq(Card.fetch_id("Sugar"))
+    expect(sugar_milk.right_id).to eq(Card.fetch_id("Milk"))
   end
 end
 
-describe Card, 'types' do
+describe Card, "types" do
 end

data/spec/models/card/trash_spec.rb

@@ -1,76 +1,76 @@
 # -*- encoding : utf-8 -*-
 
-require 'card/action'
+require "card/action"
 
-describe Card, 'deleting card' do
-  it 'should require permission' do
-    a = Card['a']
+describe Card, "deleting card" do
+  it "should require permission" do
+    a = Card["a"]
     Card::Auth.as :anonymous do
       expect(a.ok?(:delete)).to eq(false)
       expect(a.delete).to eq(false)
       expect(a.errors[:permission_denied]).not_to be_empty
-      expect(Card['a'].trash).to eq(false)
+      expect(Card["a"].trash).to eq(false)
     end
   end
 end
 
-describe Card, 'deleted card' do
+describe Card, "deleted card" do
   before do
     Card::Auth.as_bot do
-      @c = Card['A']
+      @c = Card["A"]
       @c.delete!
     end
   end
-  it 'should be in the trash' do
+  it "should be in the trash" do
     expect(@c.trash).to be_truthy
   end
-  it 'should come out of the trash when a plus card is created' do
+  it "should come out of the trash when a plus card is created" do
     Card::Auth.as_bot do
-      Card.create(name: 'A+*acct')
-      c = Card['A']
+      Card.create(name: "A+*acct")
+      c = Card["A"]
       expect(c.trash).to be_falsey
     end
   end
 end
 
-describe Card, 'in trash' do
-  it 'should be retrieved by fetch with new' do
-    Card.create(name: 'Betty').delete
-    c = Card.fetch 'Betty', new: {}
+describe Card, "in trash" do
+  it "should be retrieved by fetch with new" do
+    Card.create(name: "Betty").delete
+    c = Card.fetch "Betty", new: {}
     c.save
-    expect(Card['Betty']).to be_instance_of(Card)
+    expect(Card["Betty"]).to be_instance_of(Card)
   end
 end
 
-describe Card, 'plus cards' do
-  it 'should be deleted when root is' do
-    Card::Auth.as 'joe_admin' do
-      c = Card.create! name: 'zz+top'
-      root = Card['zz']
+describe Card, "plus cards" do
+  it "should be deleted when root is" do
+    Card::Auth.as "joe_admin" do
+      c = Card.create! name: "zz+top"
+      root = Card["zz"]
       root.delete
       #      Rails.logger.info "ERRORS = #{root.errors.full_messages*''}"
       expect(Card.find(c.id).trash).to be_truthy
-      expect(Card['zz']).to be_nil
+      expect(Card["zz"]).to be_nil
     end
   end
 end
 
 # FIXME: these user tests should probably be in a set of cardtype specific tests somewhere..
 describe Card do
-  context 'with revisions' do
-    before { Card::Auth.as_bot { @c = Card['Wagn Bot'] } }
-    it 'should not be removable' do
+  context "with revisions" do
+    before { Card::Auth.as_bot { @c = Card["Wagn Bot"] } }
+    it "should not be removable" do
       expect(@c.delete).not_to be_truthy
     end
   end
 
-  context 'without revisions' do
+  context "without revisions" do
     before do
       Card::Auth.as_bot do
-        @c = Card.create! name: 'User Must Die', type: 'User'
+        @c = Card.create! name: "User Must Die", type: "User"
       end
     end
-    it 'should be removable' do
+    it "should be removable" do
       expect(@c.delete!).to be_truthy
     end
   end
@@ -89,95 +89,95 @@ end
 #  end
 # end
 
-describe Card, 'dependent removal' do
+describe Card, "dependent removal" do
   before do
-    @a = Card['A']
+    @a = Card["A"]
     @a.delete!
-    @c = Card.find_by_key 'A+B+C'.to_name.key
+    @c = Card.find_by_key "A+B+C".to_name.key
   end
 
-  it 'should be trash' do
+  it "should be trash" do
     expect(@c.trash).to be_truthy
   end
 
-  it 'should not be findable by name' do
-    expect(Card['A+B+C']).to eq(nil)
+  it "should not be findable by name" do
+    expect(Card["A+B+C"]).to eq(nil)
   end
 end
 
-describe Card, 'rename to trashed name' do
+describe Card, "rename to trashed name" do
   before do
     Card::Auth.as_bot do
-      @a = Card['A']
-      @b = Card['B']
+      @a = Card["A"]
+      @b = Card["B"]
       @a.delete!  # trash
       Rails.logger.info "\n\n~~~~~~~deleted~~~~~~~~\n\n\n"
 
-      @b.update_attributes! name: 'A', update_referers: true
+      @b.update_attributes! name: "A", update_referers: true
     end
   end
 
-  it 'should rename b to a' do
-    expect(@b.name).to eq('A')
+  it "should rename b to a" do
+    expect(@b.name).to eq("A")
   end
 
-  it 'should rename a to a*trash' do
-    expect((c = Card.find(@a.id)).cardname.to_s).to eq('A*trash')
-    expect(c.name).to eq('A*trash')
-    expect(c.key).to eq('a*trash')
+  it "should rename a to a*trash" do
+    expect((c = Card.find(@a.id)).cardname.to_s).to eq("A*trash")
+    expect(c.name).to eq("A*trash")
+    expect(c.key).to eq("a*trash")
   end
 end
 
-describe Card, 'sent to trash' do
+describe Card, "sent to trash" do
   before do
     Card::Auth.as_bot do
-      @c = Card['basicname']
+      @c = Card["basicname"]
       @c.delete!
     end
   end
 
-  it 'should be trash' do
+  it "should be trash" do
     expect(@c.trash).to eq(true)
   end
 
-  it 'should not be findable by name' do
-    expect(Card['basicname']).to eq(nil)
+  it "should not be findable by name" do
+    expect(Card["basicname"]).to eq(nil)
   end
 
-  it 'should still have actions' do
+  it "should still have actions" do
     expect(@c.actions.count).to eq(2)
-    expect(@c.last_change_on(:db_content).value).to eq('basiccontent')
+    expect(@c.last_change_on(:db_content).value).to eq("basiccontent")
   end
 end
 
-describe Card, 'revived from trash' do
+describe Card, "revived from trash" do
   before do
     Card::Auth.as_bot do
-      Card['basicname'].delete!
+      Card["basicname"].delete!
 
-      @c = Card.create! name: 'basicname', content: 'revived content'
+      @c = Card.create! name: "basicname", content: "revived content"
     end
   end
 
-  it 'should not be trash' do
+  it "should not be trash" do
     expect(@c.trash).to eq(false)
   end
 
-  it 'should have 3 actions' do
+  it "should have 3 actions" do
     expect(@c.actions.count).to eq(3)
   end
 
-  it 'should still have old content' do
-    expect(@c.nth_action(1).value :db_content).to eq('basiccontent')
+  it "should still have old content" do
+    expect(@c.nth_action(1).value :db_content).to eq("basiccontent")
   end
 
-  it 'should have the same content' do
-    expect(@c.content).to eq('revived content')
+  it "should have the same content" do
+    expect(@c.content).to eq("revived content")
     #    Card.fetch(@c.name).content.should == 'revived content'
   end
 end
 
-describe Card, 'recreate trashed card via new' do
+describe Card, "recreate trashed card via new" do
   #  before do
   #    Card::Auth.as(Card::WagnBotID)
   #    @c = Card.create! type: 'Basic', name: "BasicMe"
@@ -191,59 +191,59 @@ describe Card, 'recreate trashed card via new' do
   #  end
 end
 
-describe Card, 'junction revival' do
+describe Card, "junction revival" do
   before do
     Card::Auth.as_bot do
-      @c = Card.create! name: 'basicname+woot', content: 'basiccontent'
+      @c = Card.create! name: "basicname+woot", content: "basiccontent"
       @c.delete!
-      @c = Card.create! name: 'basicname+woot', content: 'revived content'
+      @c = Card.create! name: "basicname+woot", content: "revived content"
     end
   end
 
-  it 'should not be trash' do
+  it "should not be trash" do
     expect(@c.trash).to eq(false)
   end
 
-  it 'should have 3 actions' do
+  it "should have 3 actions" do
     expect(@c.actions.count).to eq(3)
   end
 
-  it 'should still have old action' do
-    expect(@c.nth_action(1).value :db_content).to eq('basiccontent')
+  it "should still have old action" do
+    expect(@c.nth_action(1).value :db_content).to eq("basiccontent")
   end
 
-  it 'should have old content' do
-    expect(@c.db_content).to eq('revived content')
+  it "should have old content" do
+    expect(@c.db_content).to eq("revived content")
   end
 end
 
-describe 'remove tests' do
+describe "remove tests" do
   before do
-    @a = Card['A']
+    @a = Card["A"]
   end
 
   # I believe this is here to test a bug where cards with certain kinds of references
   # would fail to delete.  probably less of an issue now that delete is done through
   # trash.
-  it 'test_remove' do
-    assert @a.delete!, 'card should be deleteable'
-    assert_nil Card['A']
+  it "test_remove" do
+    assert @a.delete!, "card should be deleteable"
+    assert_nil Card["A"]
   end
 
-  it 'test_recreate_plus_card_name_variant' do
-    Card.create(name: 'rta+rtb').delete
-    Card['rta'].update_attributes name: 'rta!'
-    c = Card.create! name: 'rta!+rtb'
-    assert Card['rta!+rtb']
-    assert !Card['rta!+rtb'].trash
-    assert Card.find_by_key('rtb*trash').nil?
+  it "test_recreate_plus_card_name_variant" do
+    Card.create(name: "rta+rtb").delete
+    Card["rta"].update_attributes name: "rta!"
+    c = Card.create! name: "rta!+rtb"
+    assert Card["rta!+rtb"]
+    assert !Card["rta!+rtb"].trash
+    assert Card.find_by_key("rtb*trash").nil?
   end
 
-  it 'test_multiple_trash_collision' do
-    Card.create(name: 'alpha').delete
+  it "test_multiple_trash_collision" do
+    Card.create(name: "alpha").delete
     3.times do
-      b = Card.create(name: 'beta')
-      b.name = 'alpha'
+      b = Card.create(name: "beta")
+      b.name = "alpha"
       assert b.save!
       b.delete
     end