card 1.16.10 → 1.16.11

data/mod/01_core/set/all/tracked_attributes.rb

@@ -143,12 +143,10 @@ event :expire_related, after: :store do
       Card.expire name, true
     end
   end
+end
 
-  # FIXME: really shouldn't be instantiating all the following bastards.
-  # Just need the key.
-  # fix in id_cache branch
-  dependents.each       { |c| c.expire(true) }
-  # self.referencers.each      { |c| c.expire(true) }
+event :expire_related_names, before: :expire_related, changed: :name do
+  # FIXME: look for opportunities to avoid instantiating the following
+  descendants.each { |c| c.expire(true) }
   name_referencers.each { |c| c.expire(true) }
-  # FIXME: this will need review when we do the new defaults/templating system
 end

data/mod/01_core/set/all/trash.rb

@@ -28,7 +28,10 @@ event :validate_delete, before: :approve, on: :delete do
     errors.add :delete, "#{name} is is a system card. (#{codename})"
   end
 
-  undeletable_all_rules_tags = %w{ default style layout create read update delete }
+  undeletable_all_rules_tags =
+    %w{ default style layout create read update delete }
+  # FIXME: HACK! should be configured in the rule
+
   if junction? && (l = left) && l.codename == 'all' &&
      undeletable_all_rules_tags.member?(right.codename)
     errors.add :delete, "#{name} is an indestructible rule"

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

@@ -79,20 +79,21 @@ describe Card::Set::All::Fetch do
 
         # expires the saved card
         expect(Card.cache).to receive(:delete).with('a').and_call_original
-        expect(Card.cache).to receive(:delete).with(/~\d+/).at_least(12)
+        expect(Card.cache).to receive(:delete).with(/~\d+/).at_least(1)
         # expires plus cards
-        expect(Card.cache).to receive(:delete).with('c+a')
-        expect(Card.cache).to receive(:delete).with('d+a')
-        expect(Card.cache).to receive(:delete).with('f+a')
-        expect(Card.cache).to receive(:delete).with('a+b')
-        expect(Card.cache).to receive(:delete).with('a+c')
-        expect(Card.cache).to receive(:delete).with('a+d')
-        expect(Card.cache).to receive(:delete).with('a+e')
-        expect(Card.cache).to receive(:delete).with('a+b+c')
+        #expect(Card.cache).to receive(:delete).with('c+a')
+        #expect(Card.cache).to receive(:delete).with('d+a')
+        #expect(Card.cache).to receive(:delete).with('f+a')
+        #expect(Card.cache).to receive(:delete).with('a+b')
+        #expect(Card.cache).to receive(:delete).with('a+c')
+        #expect(Card.cache).to receive(:delete).with('a+d')
+        #expect(Card.cache).to receive(:delete).with('a+e')
+        #expect(Card.cache).to receive(:delete).with('a+b+c')
 
         # expired including? cards
-        expect(Card.cache).to receive(:delete).with('x').exactly(2).times
-        expect(Card.cache).to receive(:delete).with('y').exactly(2).times
+        #expect(Card.cache).to receive(:delete).with('x').exactly(2).times
+        #expect(Card.cache).to receive(:delete).with('y').exactly(2).times
+
         a.save!
       end
     end

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

@@ -1,44 +1,39 @@
 # -*- encoding : utf-8 -*-
 
-
 module RenameMethods
   def name_invariant_attributes card
     {
       content:     card.content,
-      #updater_id:  card.updater_id,
-      #revisions:   card.actions.count,
+      # updater_id:  card.updater_id,
+      # revisions:   card.actions.count,
       referencers: card.referencers.map(&:name).sort,
       referees:    card.referees.map(&:name).sort,
-      dependents:  card.dependents.map(&:id).sort
+      descendants:  card.descendants.map(&:id).sort
     }
   end
 
   def assert_rename card, new_name
-    attrs_before = name_invariant_attributes( card )
+    attrs_before = name_invariant_attributes(card)
     actions_count_before = card.actions.count
-    card.name=new_name
+    card.name = new_name
     card.update_referencers = true
     card.save!
-    expect(card.actions.count).to eq(actions_count_before+1)
+    expect(card.actions.count).to eq(actions_count_before + 1)
     assert_equal attrs_before, name_invariant_attributes(card)
     assert_equal new_name, card.name
     assert Card[new_name]
   end
 
   def card name
-    Card[name].refresh or raise "Couldn't find card named #{name}"
+    Card[name].refresh || raise("Couldn't find card named #{name}")
   end
 end
 
 include RenameMethods
 
-
 describe Card::Set::All::TrackedAttributes do
-
-
   describe 'set_name' do
-
-    it "should handle case variants" do
+    it 'should handle case variants' do
       @c = Card.create! name: 'chump'
       expect(@c.name).to eq('chump')
       @c.name = 'Chump'
@@ -46,7 +41,7 @@ describe Card::Set::All::TrackedAttributes do
       expect(@c.name).to eq('Chump')
     end
 
-    it "should handle changing from plus card to simple" do
+    it 'should handle changing from plus card to simple' do
       c = Card.create! name: 'four+five'
       c.name = 'nine'
       c.save!
@@ -55,43 +50,44 @@ describe Card::Set::All::TrackedAttributes do
       expect(c.right_id).to eq(nil)
     end
 
-    #FIXME - following tests more about fetch than set_name.  this spec still needs lots of cleanup
+    # FIXME: - following tests more about fetch than set_name.
+    # this spec still needs lots of cleanup
 
-    it "test fetch with new when present" do
-      Card.create!(name: "Carrots")
+    it 'test fetch with new when present' do
+      Card.create!(name: 'Carrots')
       cards_should_be_added 0 do
-        c=Card.fetch "Carrots", new: {}
+        c = Card.fetch 'Carrots', new: {}
         c.save
         expect(c).to be_instance_of(Card)
-        expect(Card.fetch("Carrots")).to be_instance_of(Card)
+        expect(Card.fetch('Carrots')).to be_instance_of(Card)
       end
     end
 
-    it "test_simple" do
+    it 'test_simple' do
       cards_should_be_added 1 do
         expect(Card['Boo!']).to be_nil
-        expect(Card.create(name: "Boo!")).to be_instance_of(Card)
+        expect(Card.create(name: 'Boo!')).to be_instance_of(Card)
         expect(Card['Boo!']).to be_instance_of(Card)
       end
     end
 
-
-    it "test fetch with new when not present" do
+    it 'test fetch with new when not present' do
       cards_should_be_added 1 do
-        c=Card.fetch("Tomatoes", new: {})
+        c = Card.fetch('Tomatoes', new: {})
         c.save
         expect(c).to be_instance_of(Card)
-        expect(Card.fetch("Tomatoes")).to be_instance_of(Card)
+        expect(Card.fetch('Tomatoes')).to be_instance_of(Card)
       end
     end
 
-    it "test_create_junction" do
+    it 'test_create_junction' do
       cards_should_be_added 3 do
-        expect(Card.create(name: "Peach+Pear", content: "juicy")).to be_instance_of(Card)
+        pearch = Card.create name: 'Peach+Pear', content: 'juicy'
+        expect(pearch).to be_instance_of(Card)
       end
-      expect(Card["Peach"]).to be_instance_of(Card)
-      expect(Card["Pear"]).to be_instance_of(Card)
-      assert_equal "juicy", Card["Peach+Pear"].content
+      expect(Card['Peach']).to be_instance_of(Card)
+      expect(Card['Pear']).to be_instance_of(Card)
+      assert_equal 'juicy', Card['Peach+Pear'].content
     end
 
   private
@@ -101,121 +97,121 @@ describe Card::Set::All::TrackedAttributes do
       yield
       expect(Card.all.count).to eq(number)
     end
-
   end
 
-
-
-  describe "renaming" do
-
-
-    # FIXME: these tests are TOO SLOW!  8s against server, 12s from command line.
+  describe 'renaming' do
+    # FIXME: these tests are TOO SLOW!
+    # 8s against server, 12s from command line.
     # not sure if it's the card creation or the actual renaming process.
     # Card#save needs optimized in general.
     # Can't we just move this data to fixtures?
 
-
-    it "renaming plus card to its own child" do
-      assert_rename card("A+B"), "A+B+T"
+    it 'renaming plus card to its own child' do
+      assert_rename card('A+B'), 'A+B+T'
     end
 
-    it "clears cache for old name" do
+    it 'clears cache for old name' do
       assert_rename Card['Menu'], 'manure'
       expect(Card['Menu']).to be_nil
     end
 
-    it "wipes old references by default" do
+    it 'wipes old references by default' do
       c = Card['Menu']
       c.name = 'manure'
       c.save!
       expect(Card['manure'].references_from.size).to eq(0)
     end
 
-    it "picks up new references" do
+    it 'picks up new references' do
       Card.create name: 'kinds of poop', content: '[[manure]]'
       assert_rename Card['Menu'], 'manure'
       expect(Card['manure'].references_from.size).to eq(2)
     end
 
-    it "handles name variants" do
-      assert_rename card("B"), "b"
+    it 'handles name variants' do
+      assert_rename card('B'), 'b'
     end
 
-    it "handles plus cards renamed to simple" do
-      assert_rename card("A+B"), "K"
+    it 'handles plus cards renamed to simple' do
+      assert_rename card('A+B'), 'K'
     end
 
-
-    it "handles flipped parts" do
-      assert_rename card("A+B"), "B+A"
+    it 'handles flipped parts' do
+      assert_rename card('A+B'), 'B+A'
     end
 
-    it "test_should_error_card_exists" do
-      @t=card("T"); @t.name="A+B";
-      assert !@t.save, "save should fail"
-      assert @t.errors[:name], "should have errors on key"
+    it 'test_should_error_card_exists' do
+      @t = card 'T'
+      @t.name = 'A+B'
+      assert !@t.save, 'save should fail'
+      assert @t.errors[:name], 'should have errors on key'
     end
 
-    it "test_used_as_tag" do
-      @b=card("B"); @b.name='A+D'; @b.save
+    it 'test_used_as_tag' do
+      @b = card 'B'
+      @b.name = 'A+D'
+      @b.save
       assert @b.errors[:name]
     end
 
-    it "test_update_dependents" do
-      c1 =   Card["One"]
-      c12 =  Card["One+Two"]
-      c123 = Card["One+Two+Three"]
-      c41 =  Card["Four+One"]
-      c415 = Card["Four+One+Five"]
-
-      assert_equal ["One+Two","One+Two+Three","Four+One","Four+One+Five"], [c12,c123,c41,c415].map(&:name)
-      c1.name="Uno"
-      c1.save!
-      assert_equal ["Uno+Two","Uno+Two+Three","Four+Uno","Four+Uno+Five"], [c12,c123,c41,c415].map(&:reload).map(&:name)
+    it 'test_update_descendants' do
+      card_list = [
+        Card['One+Two'],
+        Card['One+Two+Three'],
+        Card['Four+One'],
+        Card['Four+One+Five']
+      ]
+
+      old_names = %w{ One+Two One+Two+Three Four+One Four+One+Five }
+      new_names = %w{ Uno+Two Uno+Two+Three Four+Uno Four+Uno+Five }
+
+      assert_equal old_names, card_list.map(&:name)
+      Card['One'].update_attributes! name: 'Uno'
+      assert_equal new_names, card_list.map(&:reload).map(&:name)
     end
 
-    it "test_should_error_invalid_name" do
-      @t=card("T"); @t.name="YT_o~Yo"; @t.save
+    it 'test_should_error_invalid_name' do
+      @t = card 'T'
+      @t.name = 'YT_o~Yo'
+      @t.save
       assert @t.errors[:name]
     end
 
-    it "test_simple_to_simple" do
-      assert_rename card("A"), "Alephant"
+    it 'test_simple_to_simple' do
+      assert_rename card('A'), 'Alephant'
     end
 
-    it "test_simple_to_junction_with_create" do
-      assert_rename card("T"), "C+J"
+    it 'test_simple_to_junction_with_create' do
+      assert_rename card('T'), 'C+J'
     end
 
-    it "test_reset_key" do
-      c = Card["Basic Card"]
-      c.name="banana card"
+    it 'test_reset_key' do
+      c = Card['Basic Card']
+      c.name = 'banana card'
       c.save!
-      assert_equal 'banana_card', c.key
-      assert Card["Banana Card"] != nil
+      expect(c.key).to eq('banana_card')
+      expect(Card['Banana Card']).not_to be_nil
     end
 
-
-
-    it "test_rename_should_not_fail_when_updating_inaccessible_referencer" do
-      Card.create! name: "Joe Card", content: "Whattup"
+    it 'test_rename_should_not_fail_when_updating_inaccessible_referencer' do
+      Card.create! name: 'Joe Card', content: 'Whattup'
       Card::Auth.as :joe_admin do
-        Card.create! name: "Admin Card", content: "[[Joe Card]]"
+        Card.create! name: 'Admin Card', content: '[[Joe Card]]'
       end
-      c = Card["Joe Card"]
-      c.update_attributes! name: "Card of Joe", update_referencers: true
-      assert_equal "[[Card of Joe]]", Card["Admin Card"].content
+      c = Card['Joe Card']
+      c.update_attributes! name: 'Card of Joe', update_referencers: true
+      assert_equal '[[Card of Joe]]', Card['Admin Card'].content
     end
 
-    it "test_rename_should_update_structured_referencer" do
+    it 'test_rename_should_update_structured_referencer' do
       Card::Auth.as_bot do
-        c=Card.create! name: "Pit"
-        Card.create! name: "Orange", type: "Fruit", content: "[[Pit]]"
-        Card.create! name: "Fruit+*type+*structure", content: "this [[Pit]]"
+        c = Card.create! name: 'Pit'
+        Card.create! name: 'Orange', type: 'Fruit', content: '[[Pit]]'
+        Card.create! name: 'Fruit+*type+*structure', content: 'this [[Pit]]'
 
-        assert_equal "this [[Pit]]", Card["Orange"].raw_content
-        c.update_attributes! name: "Seed", update_referencers: true
-        assert_equal "this [[Seed]]", Card["Orange"].raw_content
+        assert_equal 'this [[Pit]]', Card['Orange'].raw_content
+        c.update_attributes! name: 'Seed', update_referencers: true
+        assert_equal 'this [[Seed]]', Card['Orange'].raw_content
       end
     end
 
@@ -227,92 +223,98 @@ describe Card::Set::All::TrackedAttributes do
       end
     end
 
-
-    context "chuck" do
+    context 'chuck' do
       before do
         Card::Auth.as_bot do
-          Card.create! name: "chuck_wagn+chuck"
+          Card.create! name: 'chuck_wagn+chuck'
         end
       end
 
-      it "test_rename_name_substitution" do
-        c1, c2 = Card["chuck_wagn+chuck"], Card["chuck"]
-        assert_rename c2, "buck"
-        assert_equal "chuck_wagn+buck", Card.find(c1.id).name
+      it 'test_rename_name_substitution' do
+        c1 = Card['chuck_wagn+chuck']
+        c2 = Card['chuck']
+        assert_rename c2, 'buck'
+        assert_equal 'chuck_wagn+buck', Card.find(c1.id).name
       end
 
-      it "test_reference_updates_plus_to_simple" do
-         c1 = Card::Auth.as_bot do
-           Card.create! name: 'Huck', content: "[[chuck wagn+chuck]]"
-         end
-         c2 = Card["chuck_wagn+chuck"]
-         assert_rename c2, 'schmuck'
-         c1 = Card.find(c1.id)
-         assert_equal '[[schmuck]]', c1.content
+      it 'test_reference_updates_plus_to_simple' do
+        c1 = Card::Auth.as_bot do
+          Card.create! name: 'Huck', content: '[[chuck wagn+chuck]]'
+        end
+        c2 = Card['chuck_wagn+chuck']
+        assert_rename c2, 'schmuck'
+        c1 = Card.find(c1.id)
+        assert_equal '[[schmuck]]', c1.content
       end
     end
 
-    context "dairy" do
+    context 'dairy' do
       before do
         Card::Auth.as_bot do
-          Card.create! type: "Cardtype", name: "Dairy", content: "[[/new/{{_self|name}}|new]]"
+          Card.create! name:    'Dairy',
+                       type:    'Cardtype',
+                       content: '[[/new/{{_self|name}}|new]]'
         end
       end
 
-      it "test_renaming_card_with_self_link_should_not_hang" do
-        c = Card["Dairy"]
-        c.name = "Buttah"
+      it 'test_renaming_card_with_self_link_should_not_hang' do
+        c = Card['Dairy']
+        c.name = 'Buttah'
         c.update_referencers = true
         c.save!
-        assert_equal "[[/new/{{_self|name}}|new]]", Card["Buttah"].content
+        assert_equal '[[/new/{{_self|name}}|new]]', Card['Buttah'].content
       end
 
-      it "test_renaming_card_without_updating_references_should_not_have_errors" do
-        c = Card["Dairy"]
-        c.update_attributes "name"=>"Newt", "update_referencers"=>'false'
-        assert_equal "[[/new/{{_self|name}}|new]]", Card["Newt"].content
+      it 'should rename card without updating references' do
+        c = Card['Dairy']
+        c.update_attributes name: 'Newt', update_referencers: false
+        assert_equal '[[/new/{{_self|name}}|new]]', Card['Newt'].content
       end
     end
 
 
-    context "blues" do
+    context 'blues' do
       before do
         Card::Auth.as_bot do
-          Card.create! name: "Blue"
-
-          Card.create! name: "blue includer 1", content: "{{Blue}}"
-          Card.create! name: "blue includer 2", content: "{{blue|closed;other:stuff}}"
-
-          Card.create! name: "blue linker 1", content: "[[Blue]]"
-          Card.create! name: "blue linker 2", content: "[[blue]]"
+          [['Blue', ''],
+           ['blue includer 1', '{{Blue}}'],
+           ['blue includer 2', '{{blue|closed;other:stuff}}'],
+           ['blue linker 1', '[[Blue]]'],
+           ['blue linker 2', '[[blue]]']
+          ].each do |name, content|
+            Card.create! name: name, content: content
+          end
         end
       end
 
-
-      it "test_updates_inclusions_when_renaming" do
-        c1,c2,c3 = Card["Blue"], Card["blue includer 1"], Card["blue includer 2"]
-        c1.update_attributes name: "Red", update_referencers: true
-        assert_equal "{{Red}}", Card.find(c2.id).content
+      it 'test_updates_inclusions_when_renaming' do
+        c1 = Card['Blue']
+        c2 = Card['blue includer 1']
+        c3 = Card['blue includer 2']
+        c1.update_attributes name: 'Red', update_referencers: true
+        assert_equal '{{Red}}', Card.find(c2.id).content
         # NOTE these attrs pass through a hash stage that may not preserve order
-        assert_equal "{{Red|closed;other:stuff}}", Card.find(c3.id).content
+        assert_equal '{{Red|closed;other:stuff}}', Card.find(c3.id).content
       end
 
-      it "test_updates_inclusions_when_renaming_to_plus" do
-        c1,c2 = Card["Blue"], Card["blue includer 1"]
-        c1.update_attributes name: "blue includer 1+color", update_referencers: true
-        assert_equal "{{blue includer 1+color}}", Card.find(c2.id).content
+      it 'test_updates_inclusions_when_renaming_to_plus' do
+        c1 = Card['Blue']
+        c2 = Card['blue includer 1']
+        c1.update_attributes name: 'blue includer 1+color',
+                             update_referencers: true
+        assert_equal '{{blue includer 1+color}}', Card.find(c2.id).content
       end
 
-      it "test_reference_updates_on_case_variants" do
-        c1,c2,c3 = Card["Blue"], Card["blue linker 1"], Card["blue linker 2"]
-        c1.reload.name = "Red"
+      it 'test_reference_updates_on_case_variants' do
+        c1 = Card['Blue']
+        c2 = Card['blue linker 1']
+        c3 = Card['blue linker 2']
+        c1.reload.name = 'Red'
         c1.update_referencers = true
         c1.save!
-        assert_equal "[[Red]]", Card.find(c2.id).content
-        assert_equal "[[Red]]", Card.find(c3.id).content
+        assert_equal '[[Red]]', Card.find(c2.id).content
+        assert_equal '[[Red]]', Card.find(c3.id).content
       end
     end
-
   end
-
 end