card 1.17.4 → 1.18.0

data/spec/models/card/trash_spec.rb

@@ -11,7 +11,6 @@ describe Card, 'deleting card' do
       expect(a.errors[:permission_denied]).not_to be_empty
       expect(Card['a'].trash).to eq(false)
     end
-
   end
 end
 
@@ -28,7 +27,7 @@ describe Card, 'deleted card' 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' ]
+      c = Card['A']
       expect(c.trash).to be_falsey
     end
   end
@@ -37,20 +36,19 @@ 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: {}
+    c = Card.fetch 'Betty', new: {}
     c.save
     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']
       root.delete
-#      Rails.logger.info "ERRORS = #{root.errors.full_messages*''}"
+      #      Rails.logger.info "ERRORS = #{root.errors.full_messages*''}"
       expect(Card.find(c.id).trash).to be_truthy
       expect(Card['zz']).to be_nil
     end
@@ -60,7 +58,7 @@ end
 # FIXME: these user tests should probably be in a set of cardtype specific tests somewhere..
 describe Card do
   context 'with revisions' do
-    before do Card::Auth.as_bot { @c = Card['Wagn Bot'] } end
+    before { Card::Auth.as_bot { @c = Card['Wagn Bot'] } }
     it 'should not be removable' do
       expect(@c.delete).not_to be_truthy
     end
@@ -78,11 +76,8 @@ describe Card do
   end
 end
 
-
-
-
-#NOT WORKING, BUT IT SHOULD
-#describe Card, "a part of an unremovable card" do
+# NOT WORKING, BUT IT SHOULD
+# describe Card, "a part of an unremovable card" do
 #  before do
 #     Card::Auth.as(Card::WagnBotID)
 #     # this ugly setup makes it so A+Admin is the actual user with edits..
@@ -92,7 +87,7 @@ end
 #    @a = Card['A']
 #    @a.delete.should_not be_true
 #  end
-#end
+# end
 
 describe Card, 'dependent removal' do
   before do
@@ -115,7 +110,7 @@ describe Card, 'rename to trashed name' do
     Card::Auth.as_bot do
       @a = Card['A']
       @b = Card['B']
-      @a.delete!  #trash
+      @a.delete!  # trash
       Rails.logger.info "\n\n~~~~~~~deleted~~~~~~~~\n\n\n"
 
       @b.update_attributes! name: 'A', update_referers: true
@@ -133,7 +128,6 @@ describe Card, 'rename to trashed name' do
   end
 end
 
-
 describe Card, 'sent to trash' do
   before do
     Card::Auth.as_bot do
@@ -179,23 +173,22 @@ describe Card, 'revived from trash' do
 
   it 'should have the same content' do
     expect(@c.content).to eq('revived content')
-#    Card.fetch(@c.name).content.should == 'revived content'
+    #    Card.fetch(@c.name).content.should == 'revived content'
   end
 end
 
 describe Card, 'recreate trashed card via new' do
-#  before do
-#    Card::Auth.as(Card::WagnBotID)
-#    @c = Card.create! type: 'Basic', name: "BasicMe"
-#  end
-
-#  this test is known to be broken; we've worked around it for now
-#  it "should delete and recreate with a different cardtype" do
-#    @c.delete!
-#    @re_c = Card.new type: "Phrase", name: "BasicMe", content: "Banana"
-#    @re_c.save!
-#  end
-
+  #  before do
+  #    Card::Auth.as(Card::WagnBotID)
+  #    @c = Card.create! type: 'Basic', name: "BasicMe"
+  #  end
+
+  #  this test is known to be broken; we've worked around it for now
+  #  it "should delete and recreate with a different cardtype" do
+  #    @c.delete!
+  #    @re_c = Card.new type: "Phrase", name: "BasicMe", content: "Banana"
+  #    @re_c.save!
+  #  end
 end
 
 describe Card, 'junction revival' do
@@ -225,7 +218,6 @@ describe Card, 'junction revival' do
 end
 
 describe 'remove tests' do
-
   before do
     @a = Card['A']
   end
@@ -239,7 +231,7 @@ describe 'remove tests' do
   end
 
   it 'test_recreate_plus_card_name_variant' do
-    Card.create( name: 'rta+rtb' ).delete
+    Card.create(name: 'rta+rtb').delete
     Card['rta'].update_attributes name: 'rta!'
     c = Card.create! name: 'rta!+rtb'
     assert Card['rta!+rtb']
@@ -248,13 +240,12 @@ describe 'remove tests' do
   end
 
   it 'test_multiple_trash_collision' do
-    Card.create( name: 'alpha' ).delete
+    Card.create(name: 'alpha').delete
     3.times do
-      b = Card.create( name: 'beta' )
+      b = Card.create(name: 'beta')
       b.name = 'alpha'
       assert b.save!
       b.delete
     end
   end
 end
-

data/spec/models/card/type_transition_spec.rb

@@ -24,16 +24,32 @@ class Card
     end
 
     module CardtypeE
-      def self.included(base) Card.count = 2   end
-      def on_type_change()    decrement_count  end
-      def decrement_count()   Card.count -= 1  end
+      def self.included _base
+        Card.count = 2
+      end
+
+      def on_type_change
+        decrement_count
+      end
+
+      def decrement_count
+        Card.count -= 1
+      end
     end
 
     module CardtypeF
-      def self.included(base) Card.count = 2   end
+      def self.included _base
+        Card.count = 2
+      end
+
       # FIXME: create_extension doesn't exist anymore, need another hook
-      def create_extension()  increment_count  end
-      def increment_count()   Card.count += 1  end
+      def create_extension
+        increment_count
+      end
+
+      def increment_count
+        Card.count += 1
+      end
     end
   end
 end
@@ -50,8 +66,6 @@ describe Card, 'with role' do
   end
 end
 
-
-
 describe Card, 'with account' do
   before do
     Card::Auth.as_bot do
@@ -66,12 +80,11 @@ describe Card, 'with account' do
   it 'should allow type changes' do
     expect(@joe.type_code).to eq(:basic)
   end
-
 end
 
 describe Card, 'type transition approve create' do
   it 'should have cardtype b create role r1' do
-    expect((c=Card.fetch('Cardtype B+*type+*create')).content).to eq('[[r1]]')
+    expect((c = Card.fetch('Cardtype B+*type+*create')).content).to eq('[[r1]]')
     expect(c.type_code).to eq(:pointer)
   end
 
@@ -81,7 +94,7 @@ describe Card, 'type transition approve create' do
   end
 
   it 'should be the original type' do
-    lambda { change_card_to_type 'basicname', 'cardtype_b' }
+    -> { change_card_to_type 'basicname', 'cardtype_b' }
     expect(Card['basicname'].type_code).to eq(:basic)
   end
 end
@@ -113,48 +126,44 @@ describe Card, 'type transition validate_create' do
   end
 end
 
-describe Card, "type transition delete callback" do
+describe Card, 'type transition delete callback' do
   before do
-    @c = change_card_to_type("type-e-card", :basic)
+    @c = change_card_to_type('type-e-card', :basic)
   end
 
-  it "should decrement counter in before delete" do
-    pending "no trigger for this test anymore"
+  it 'should decrement counter in before delete' do
+    pending 'no trigger for this test anymore'
     expect(Card.count).to eq(1)
   end
 
-  it "should change type of the card" do
-    expect(Card["type-e-card"].type_code).to eq(:basic)
+  it 'should change type of the card' do
+    expect(Card['type-e-card'].type_code).to eq(:basic)
   end
 end
 
-describe Card, "type transition create callback" do
+describe Card, 'type transition create callback' do
   before do
     Card::Auth.as_bot do
-      Card.create(name: 'Basic+*type+*delete', type: 'Pointer', content: "[[Anyone Signed in]]")
+      Card.create(name: 'Basic+*type+*delete', type: 'Pointer', content: '[[Anyone Signed in]]')
     end
-    @c = change_card_to_type("basicname", :cardtype_f)
+    @c = change_card_to_type('basicname', :cardtype_f)
   end
 
-  it "should increment counter"  do
-    pending "No extensions, so no hooks for this now"
+  it 'should increment counter'  do
+    pending 'No extensions, so no hooks for this now'
     expect(Card.count).to eq(3)
   end
 
-  it "should change type of card" do
-    expect(Card["basicname"].type_code).to eq(:cardtype_f)
+  it 'should change type of card' do
+    expect(Card['basicname'].type_code).to eq(:cardtype_f)
   end
 end
 
-
 def change_card_to_type name, type
   card = Card.fetch(name)
-  tid=card.type_id = Symbol===type ? Card::Codename[type] : Card.fetch_id(type)
-  #warn "card[#{name.inspect}, T:#{type.inspect}] is #{card.inspect}, TID:#{tid}"
-  r=card.save
-  #warn "saved #{card.inspect} R#{r}"
+  tid = card.type_id = Symbol === type ? Card::Codename[type] : Card.fetch_id(type)
+  # warn "card[#{name.inspect}, T:#{type.inspect}] is #{card.inspect}, TID:#{tid}"
+  r = card.save
+  # warn "saved #{card.inspect} R#{r}"
   card
 end
-
-
-

data/spec/models/card/validation_spec.rb

@@ -1,36 +1,34 @@
 # -*- encoding : utf-8 -*-
 
-describe Card, "validate name" do
-
-  it "should error on name with /" do
-    @c = Card.create name: "testname/"
+describe Card, 'validate name' do
+  it 'should error on name with /' do
+    @c = Card.create name: 'testname/'
     expect(@c.errors[:name]).not_to be_blank
   end
 
-  it "should error on junction name  with /" do
-    @c = Card.create name: "jasmin+ri/ce"
+  it 'should error on junction name  with /' do
+    @c = Card.create name: 'jasmin+ri/ce'
     expect(@c.errors[:name]).not_to be_blank
   end
 
   it "shouldn't create any new cards when name invalid" do
     original_card_count = Card.count
-    @c = Card.create name: "jasmin+ri/ce"
+    @c = Card.create name: 'jasmin+ri/ce'
     expect(Card.count).to eq(original_card_count)
   end
 
-  it "should not allow empty name" do
-    @c = Card.new name: ""
+  it 'should not allow empty name' do
+    @c = Card.new name: ''
     expect(@c.valid?).to eq(false)
     expect(@c.errors[:name]).not_to be_blank
   end
 
   # maybe the @c.key= should just throw an error, but now it doesn't take anyway
-  it "should not allow mismatched name and key" do
-    @c = Card.new name: "Test"
-    @c.key="foo"
-    #@c.key.should == 'test'
+  it 'should not allow mismatched name and key' do
+    @c = Card.new name: 'Test'
+    @c.key = 'foo'
+    # @c.key.should == 'test'
     expect(@c.valid?).to eq(false)
-    #@c.errors[:key].should_not be_blank
+    # @c.errors[:key].should_not be_blank
   end
-
 end

data/spec/models/card_spec.rb

@@ -1,39 +1,37 @@
 # -*- encoding : utf-8 -*-
 
 describe Card do
-
-  describe "test data" do
-    it "should be findable by name" do
-      expect(Card["Wagn Bot"].class).to eq(Card)
+  describe 'test data' do
+    it 'should be findable by name' do
+      expect(Card['Wagn Bot'].class).to eq(Card)
     end
   end
 
-  describe "creation" do
+  describe 'creation' 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 "should not have errors"        do expect(@b.errors.size).to eq(0)        end
-    it "should have the right class"   do expect(@c.class).to    eq(Card)        end
-    it "should have the right key"     do expect(@c.key).to      eq("new_card")  end
-    it "should have the right name"    do expect(@c.name).to     eq("New Card")  end
-    it "should have the right content" do expect(@c.content).to  eq("Great Content") end
+    it 'should not have errors'        do expect(@b.errors.size).to eq(0)        end
+    it 'should have the right class'   do expect(@c.class).to    eq(Card)        end
+    it 'should have the right key'     do expect(@c.key).to      eq('new_card')  end
+    it 'should have the right name'    do expect(@c.name).to     eq('New Card')  end
+    it 'should have the right content' do expect(@c.content).to  eq('Great Content') end
 
-    it "should have the right content" do
-      expect(@c.db_content).to eq("Great Content")
-      expect(@c.content).to eq("Great Content")
+    it 'should have the right content' do
+      expect(@c.db_content).to eq('Great Content')
+      expect(@c.content).to eq('Great Content')
     end
 
-    it "should be findable by name" do
-      expect(Card["New Card"].class).to eq(Card)
+    it 'should be findable by name' do
+      expect(Card['New Card'].class).to eq(Card)
     end
   end
 
-
-  describe "content change should create new action" do
+  describe 'content change should create new action' do
     before do
       Card::Auth.as_bot do
         @c = Card['basicname']
@@ -41,30 +39,26 @@ describe Card do
       end
     end
 
-    it "should have 2 actions"  do
+    it 'should have 2 actions'  do
       expect(@c.actions.count).to eq(2)
     end
 
-    it "should have original action" do
+    it 'should have original action' do
       expect(@c.nth_action(1).change_for(2).first.value).to eq('basiccontent')
     end
   end
 
-
-
-  describe "created a virtual card when missing and has a template" do
-    it "should be flagged as virtual" do
+  describe 'created a virtual card when missing and has a template' do
+    it 'should be flagged as virtual' do
       expect(Card.new(name: 'A+*last edited').virtual?).to be_truthy
     end
   end
 end
 
-describe "basic card tests" do
-
-
+describe 'basic card tests' do
   def assert_simple_card card
-    expect(card.name).to be, "name not null"
-    expect(card.name.empty?).to be_falsey, "name not empty"
+    expect(card.name).to be, 'name not null'
+    expect(card.name.empty?).to be_falsey, 'name not empty'
     action = card.last_action
     expect(action).to be_instance_of Card::Action
     expect(action.act.actor).to be_instance_of Card
@@ -83,35 +77,35 @@ describe "basic card tests" do
   end
 
   it 'should remove cards' do
-    forba = Card.create! name: "Forba"
-    torga = Card.create! name: "TorgA"
-    torgb = Card.create! name: "TorgB"
-    torgc = Card.create! name: "TorgC"
+    forba = Card.create! name: 'Forba'
+    torga = Card.create! name: 'TorgA'
+    torgb = Card.create! name: 'TorgB'
+    torgc = Card.create! name: 'TorgC'
 
-    forba_torga = Card.create! name: "Forba+TorgA";
-    torgb_forba = Card.create! name: "TorgB+Forba";
-    forba_torga_torgc = Card.create! name: "Forba+TorgA+TorgC";
+    forba_torga = Card.create! name: 'Forba+TorgA'
+    torgb_forba = Card.create! name: 'TorgB+Forba'
+    forba_torga_torgc = Card.create! name: 'Forba+TorgA+TorgC'
 
     Card['Forba'].delete!
 
-    expect(Card["Forba"]).to be_nil
-    expect(Card["Forba+TorgA"]).to be_nil
-    expect(Card["TorgB+Forba"]).to be_nil
-    expect(Card["Forba+TorgA+TorgC"]).to be_nil
+    expect(Card['Forba']).to be_nil
+    expect(Card['Forba+TorgA']).to be_nil
+    expect(Card['TorgB+Forba']).to be_nil
+    expect(Card['Forba+TorgA+TorgC']).to be_nil
 
     # FIXME: this is a pretty dumb test and it takes a loooooooong time
-    #while card = Card.find(:first,conditions: ["type not in (?,?,?) and trash=?", 'AccountRequest','User','Cardtype',false] )
+    # while card = Card.find(:first,conditions: ["type not in (?,?,?) and trash=?", 'AccountRequest','User','Cardtype',false] )
     #  card.delete!
-    #end
-    #assert_equal 0, Card.find_all_by_trash(false).size
+    # end
+    # assert_equal 0, Card.find_all_by_trash(false).size
   end
 
-  #test test_attribute_card
+  # test test_attribute_card
   #  alpha, beta = Card.create(name: 'alpha'), Card.create(name: 'beta')
   #  assert_nil alpha.attribute_card('beta')
   #  Card.create name: 'alpha+beta'
   #   alpha.attribute_card('beta').should be_instance_of(Card)
-  #end
+  # end
 
   it 'should create cards' do
     alpha = Card.new name: 'alpha', content: 'alpha'
@@ -121,19 +115,17 @@ describe "basic card tests" do
     assert_stable alpha
   end
 
-
   it 'should not find nonexistent' do
     expect(Card['no such card+no such tag']).to be_nil
     expect(Card['HomeCard+no such tag']).to be_nil
   end
 
-
   it 'update_should_create_subcards' do
     banana = Card.create! name: 'Banana'
-    Card.update banana.id, subcards: { "+peel" => { content: "yellow" }}
+    Card.update banana.id, subcards: { '+peel' => { content: 'yellow' } }
 
     peel = Card['Banana+peel']
-    expect(peel.content).       to eq("yellow")
+    expect(peel.content).       to eq('yellow')
     expect(Card['joe_user'].id).to eq(peel.creator_id)
   end
 
@@ -143,35 +135,32 @@ describe "basic card tests" do
     expect(Card['Banana']).not_to be
     expect(Card['Basic'].ok?(:create)).to be_falsey, "anon can't creat"
 
-    Card.create! type: "Fruit", name: 'Banana', subcards: { "+peel" => { content: "yellow" }}
+    Card.create! type: 'Fruit', name: 'Banana', subcards: { '+peel' => { content: 'yellow' } }
     expect(Card['Banana']).to be
-    peel = Card["Banana+peel"]
+    peel = Card['Banana+peel']
 
-    expect(peel.db_content).to eq("yellow")
+    expect(peel.db_content).to eq('yellow')
     expect(peel.creator_id).to eq(Card::AnonymousID)
   end
 
   it 'update_should_not_create_subcards_if_missing_main_card_permissions' do
-    b = Card.create!( name: 'Banana' )
+    b = Card.create!(name: 'Banana')
     Card::Auth.as Card::AnonymousID do
-      b.update_attributes subcards: { "+peel" => { content: "yellow" }}
+      b.update_attributes subcards: { '+peel' => { content: 'yellow' } }
       expect(b.errors[:permission_denied]).not_to be_empty
 
-
-      c = Card.update(b.id, subcards: { "+peel" => { content: "yellow" }})
+      c = Card.update(b.id, subcards: { '+peel' => { content: 'yellow' } })
       expect(c.errors[:permission_denied]).not_to be_empty
       expect(Card['Banana+peel']).to be_nil
     end
   end
 
-
   it 'create_without_read_permission' do
-    c = Card.create!({name: "Banana", type: "Fruit", content: "mush"})
+    c = Card.create!(name: 'Banana', type: 'Fruit', content: 'mush')
     Card::Auth.as Card::AnonymousID do
       assert_raises Card::PermissionDenied do
         c.ok! :read
       end
     end
   end
-
 end