card 1.17.4 → 1.18.0

data/spec/lib/card/reference_spec.rb

@@ -33,22 +33,22 @@ describe Card::Reference do
   end
 
   it 'in references should survive cardtype change' do
-    newcard 'Banana', '[[Yellow]]'
-    newcard 'Submarine', '[[Yellow]]'
-    newcard 'Sun', '[[Yellow]]'
-    newcard 'Yellow'
+    create! 'Banana', '[[Yellow]]'
+    create! 'Submarine', '[[Yellow]]'
+    create! 'Sun', '[[Yellow]]'
+    create! 'Yellow'
     yellow_refs = Card['Yellow'].referers.map(&:name).sort
-    expect(yellow_refs).to eq(%w{ Banana Submarine Sun })
+    expect(yellow_refs).to eq(%w( Banana Submarine Sun ))
 
     y = Card['Yellow']
     y.type_id = Card.fetch_id 'UserForm'
     y.save!
 
     yellow_refs = Card['Yellow'].referers.map(&:name).sort
-    expect(yellow_refs).to eq(%w{ Banana Submarine Sun })
+    expect(yellow_refs).to eq(%w( Banana Submarine Sun ))
   end
 
-  it 'container inclusion' do
+  it 'container nest' do
     Card.create name: 'bob+city'
     Card.create name: 'address+*right+*default', content: '{{_L+city}}'
     Card.create name: 'bob+address'
@@ -57,17 +57,17 @@ describe Card::Reference do
   end
 
   it 'pickup new links on rename' do
-    @l = newcard('L', '[[Ethan]]')  # no Ethan card yet...
-    @e = newcard('Earthman')
+    @l = create!('L', '[[Ethan]]')  # no Ethan card yet...
+    @e = create!('Earthman')
     @e.update_attributes! name: 'Ethan' # NOW there is an Ethan card
     #  do we need the links to be caught before reloading the card?
     expect(Card['Ethan'].referers.map(&:name).include?('L')).not_to eq(nil)
   end
 
   it 'should update references on rename when requested' do
-    newcard 'watermelon', 'mmmm'
-    newcard 'watermelon+seeds', 'black'
-    lew = newcard('Lew', 'likes [[watermelon]] and [[watermelon+seeds|seeds]]')
+    create! 'watermelon', 'mmmm'
+    create! 'watermelon+seeds', 'black'
+    lew = create!('Lew', 'likes [[watermelon]] and [[watermelon+seeds|seeds]]')
 
     watermelon = Card['watermelon']
     watermelon.update_referers = true
@@ -90,9 +90,9 @@ describe Card::Reference do
   end
 
   it 'should not update references when not requested' do
-    watermelon = newcard 'watermelon', 'mmmm'
-    watermelon_seeds = newcard 'watermelon+seeds', 'black'
-    lew = newcard('Lew', 'likes [[watermelon]] and [[watermelon+seeds|seeds]]')
+    watermelon = create! 'watermelon', 'mmmm'
+    watermelon_seeds = create! 'watermelon+seeds', 'black'
+    lew = create!('Lew', 'likes [[watermelon]] and [[watermelon+seeds|seeds]]')
 
     assert_equal [watermelon.id, watermelon_seeds.id],
                  lew.references_out.order(:id).map(&:referee_id),
@@ -127,11 +127,11 @@ describe Card::Reference do
     expect(@x.content).to eq('[[A]] [[A+B]] [[T]]')
   end
 
-  it 'template inclusion' do
+  it 'template nest' do
     Card.create! name: 'ColorType', type: 'Cardtype', content: ''
     Card.create! name: 'ColorType+*type+*structure', content: '{{+rgb}}'
     green = Card.create! name: 'green', type: 'ColorType'
-    newcard 'rgb'
+    create! 'rgb'
     green_rgb = Card.create! name: 'green+rgb', content: '#00ff00'
 
     expect(green.reload.includees.map(&:name)).to eq(['green+rgb'])
@@ -152,7 +152,7 @@ describe Card::Reference do
     expect(Card['alpha card'].referers.map(&:name)).to eq(['beta card'])
   end
 
-  it 'simple inclusion' do
+  it 'simple nest' do
     Card.create name: 'alpha'
     Card.create name: 'beta', content: 'I nest {{alpha}}'
     expect(Card['beta'].includees.map(&:name)).to eq(['alpha'])
@@ -176,7 +176,7 @@ describe Card::Reference do
     expect(y_referers).to include('search with references')
 
     search_referees = Card['search with references'].referees.map(&:name).sort
-    expect(search_referees).to eq(%w{ A B X Y })
+    expect(search_referees).to eq(%w( A B X Y ))
   end
 
   it 'handles contextual names in Basic cards' do
@@ -191,19 +191,19 @@ describe Card::Reference do
     expect(Card['search w refs'].content).to eq '{"name":"_+AAA"}'
   end
 
-  it 'should handle commented inclusion' do
-    c = Card.create name: 'inclusion comment test', content: '{{## hi mom }}'
+  it 'should handle commented nest' do
+    c = Card.create name: 'nest comment test', content: '{{## hi mom }}'
     expect(c.errors.any?).to be_falsey
   end
 
   it 'pickup new links on create' do
-    @l = newcard('woof', '[[Lewdog]]')  # no Lewdog card yet...
-    @e = newcard('Lewdog')              # now there is
+    @l = create!('woof', '[[Lewdog]]')  # no Lewdog card yet...
+    @e = create!('Lewdog')              # now there is
     # NOTE @e.referers does not work, you have to reload
     expect(@e.reload.referers.map(&:name).include?('woof')).not_to eq(nil)
   end
 
-  it 'pickup new inclusions on create' do
+  it 'pickup new nests on create' do
     @l = Card.create! name: 'woof', content: '{{Lewdog}}'
     # no Lewdog card yet...
     @e = Card.new name: 'Lewdog', content: 'grrr'

data/spec/lib/card/set_pattern_spec.rb

@@ -1,7 +1,7 @@
 # -*- encoding : utf-8 -*-
 
 module SetPatternSpecHelper
-  def it_generates( opts )
+  def it_generates opts
     name = opts[:name]
     card = opts[:from]
     it "generates name '#{name}' for card '#{card.name}'" do
@@ -15,7 +15,7 @@ include SetPatternSpecHelper
 describe Card::SetPattern do
 end
 
-#FIXME - these should probably be in pattern-specific specs, though that may not leave much to test in the base class :)
+# FIXME: - these should probably be in pattern-specific specs, though that may not leave much to test in the base class :)
 
 describe Card::RightSet do
   it_generates name: 'author+*right', from: Card.new(name: 'Iliad+author')
@@ -23,7 +23,7 @@ describe Card::RightSet do
 end
 
 describe Card::TypeSet do
-  it_generates name: 'Book+*type', from: Card.new(type: "Book")
+  it_generates name: 'Book+*type', from: Card.new(type: 'Book')
 end
 
 describe Card::TypeSet do

data/spec/lib/card/stage_director_spec.rb

@@ -0,0 +1,218 @@
+describe Card::StageDirector do
+  describe 'abortion' do
+    let(:create_card) { Card.create name: 'a card' }
+    subject { Card.fetch 'a card' }
+    context 'when error added' do
+      it 'stops act in validation phase' do
+        in_stage :validate,
+                 on: :save,
+                 trigger: -> { create_card } do
+          errors.add :stop, "don't do this"
+        end
+        is_expected.to be_falsey
+      end
+
+      it 'does not stop act in storage phase' do
+        in_stage :store, on: :save,
+                         trigger: -> { create_card } do
+          errors.add :stop, "don't do this"
+        end
+        is_expected.to be_truthy
+      end
+    end
+
+    context 'when exception raised' do
+      it 'rollbacks in finalize stage' do
+        begin
+          in_stage :finalize,
+                   on: :save,
+                   trigger: -> { create_card } do
+            raise Card::Error, 'rollback'
+          end
+        rescue Card::Error => e
+        ensure
+          is_expected.to be_falsey
+        end
+      end
+
+      it 'does not rollback in integrate stage' do
+        begin
+          Card::Auth.as_bot do
+            in_stage :integrate,
+                     on: :save,
+                     trigger: -> { create_card } do
+              raise Card::Abort, 'rollback'
+            end
+          end
+        rescue Card::Abort => e
+        ensure
+          is_expected.to be_truthy
+        end
+      end
+    end
+
+    context 'when abort :success called' do
+      it 'aborts storage in validation stage' do
+        in_stage :validate,
+                 on: :create,
+                 trigger: -> { create_card } do
+          abort :success
+        end
+        is_expected.to be_falsey
+      end
+
+      it 'aborts storage in store stage' do
+        in_stage :store,
+                 on: :create,
+                 trigger: -> { create_card } do
+          abort :success
+        end
+        is_expected.to be_falsey
+      end
+
+      it 'aborts storage in finalize stage' do
+        in_stage :store,
+                 on: :create,
+                 trigger: -> { create_card } do
+          abort :success
+        end
+        is_expected.to be_falsey
+      end
+
+      it 'does not abort storage in integrate stage' do
+        in_stage :integrate,
+                 on: :create,
+                 trigger: -> { create_card } do
+          abort :success
+        end
+        is_expected.to be_truthy
+      end
+    end
+  end
+
+  describe 'stage order' do
+    let(:create_card_with_subcards) do
+      Card.create name: '1',
+                  subcards: {
+                    '11' => { subcards: { '111' => 'A' } },
+                    '12' => { subcards: { '121' => 'A' } }
+                  }
+    end
+    let(:preorder) { %w(1 11 111 12 121) }
+    let(:postorder) { %w(111 11 121 12 1) }
+    describe 'validate' do
+      it 'is pre-order depth-first' do
+        order = []
+        in_stage :validate, on: :create,
+                            trigger: -> { create_card_with_subcards } do
+          order << name
+        end
+        expect(order).to eq(preorder)
+      end
+
+      it 'executes all validate stages before next stage' do
+        order = []
+        with_test_events do
+          test_event :validate, on: :create do
+            order << "v:#{name}"
+          end
+          test_event :prepare_to_store, on: :create do
+            order << "pts:#{name}"
+          end
+          create_card_with_subcards
+        end
+        expect(order).to eq(
+          %w(v:1 v:11 v:111 v:12 v:121 pts:1 pts:11 pts:111 pts:12 pts:121)
+        )
+      end
+    end
+
+    describe 'finalize' do
+      it 'is post-order depth-first' do
+        order = []
+        in_stage :finalize, on: :create,
+                            trigger: -> { create_card_with_subcards } do
+          order << name
+        end
+        expect(order).to eq(postorder)
+      end
+    end
+
+    describe 'store' do
+      it 'is pre-order depth-first' do
+        order = []
+        in_stage :store, on: :create,
+                         trigger: -> { create_card_with_subcards } do
+          order << name
+        end
+        expect(order).to eq(preorder)
+      end
+    end
+
+    describe 'store and finalize' do
+      it 'executes finalize when all subcards are stored and finalized' do
+        order = []
+        with_test_events do
+          test_event :store, on: :create do
+            order << "store:#{name}"
+          end
+          test_event :finalize, on: :create do
+            order << "finalize:#{name}"
+          end
+          create_card_with_subcards
+        end
+        expect(order).to eq(
+          %w(store:1 store:11 store:111 finalize:111 finalize:11
+             store:12 store:121 finalize:121 finalize:12 finalize:1)
+        )
+      end
+    end
+
+    describe 'complete run' do
+      it 'is in correct order' do
+        order = []
+        with_test_events do
+          test_event :initialize, on: :create do
+            order << "i:#{name}"
+          end
+          test_event :prepare_to_validate, on: :create do
+            order << "ptv:#{name}"
+          end
+          test_event :validate, on: :create do
+            order << "v:#{name}"
+            add_subcard '112v' if name == '11'
+          end
+          test_event :prepare_to_store, on: :create do
+            order << "pts:#{name}"
+          end
+          test_event :store, on: :create do
+            order << "s:#{name}"
+          end
+          test_event :finalize, on: :create do
+            order << "f:#{name}"
+          end
+          test_event :integrate, on: :create do
+            order << "ig:#{name}"
+          end
+          test_event :integrate_with_delay, on: :create do
+            order << "igwd:#{name}"
+          end
+          create_card_with_subcards
+        end
+        expect(order).to eq(
+          %w(
+            i:1 i:11 i:111 i:12 i:121
+            ptv:1 ptv:11 ptv:111 ptv:12 ptv:121
+            v:1 v:11 v:111
+            i:112v ptv:112v v:112v
+            v:12 v:121
+            pts:1 pts:11 pts:111 pts:112v pts:12 pts:121
+            s:1 s:11 s:111 f:111 s:112v f:112v f:11 s:12 s:121 f:121 f:12 f:1
+            ig:1 ig:11 ig:111 ig:112v ig:12 ig:121
+            igwd:1 igwd:11 igwd:111 igwd:112v igwd:12 igwd:121
+          )
+        )
+      end
+    end
+  end
+end

data/spec/lib/card/subcards_spec.rb

@@ -57,22 +57,22 @@ describe Card::Subcards do
       expect(Card['supermen+pseudonym'].name).to eq 'supermen+pseudonym'
     end
 
-    it "cleans the cache for autonaming case" do
+    it 'cleans the cache for autonaming case' do
       Card::Auth.as_bot do
         Card.create!(
           name: 'Book+*type+*autoname', content: 'Book_1',
           type_id: Card::PhraseID
         )
         card = Card.create!(
-          type: "Book",
-          subcards: { '+editable' => 'yes'}
+          type: 'Book',
+          subcards: { '+editable' => 'yes' }
         )
         expect(card.errors).to be_empty
         expect(Card["#{card.name}+editable"]).to be_truthy
 
         @card = Card.create!(
-          type: "Book",
-          subcards: { '+editable' => 'sure'}
+          type: 'Book',
+          subcards: { '+editable' => 'sure' }
         )
       end
 
@@ -87,11 +87,11 @@ describe Card::Subcards do
     end
     subject { Card.fetch("#{@card.name}+sub", new: {}, local_only: true).content }
     it 'works with string' do
-      @card._add_subfield 'sub', content: 'this is a sub'
+      @card.add_subfield 'sub', content: 'this is a sub'
       is_expected.to eq 'this is a sub'
     end
     it 'works with codename' do
-      @card._add_subfield :phrase, content: 'this is a sub'
+      @card.add_subfield :phrase, content: 'this is a sub'
       subcard = Card.fetch('A+phrase', new: {}, local_only: true)
       expect(subcard.content).to eq 'this is a sub'
     end
@@ -103,12 +103,12 @@ describe Card::Subcards do
     end
     subject { Card.fetch("#{@card.name}+sub", new: {}, local_only: true).content }
     it 'works with string' do
-      @card._add_subfield 'sub', content: 'this is a sub'
+      @card.add_subfield 'sub', content: 'this is a sub'
       expect(@card.subfield('sub').content).to eq 'this is a sub'
     end
 
     it 'works with codename' do
-      @card._add_subfield :phrase, content: 'this is a sub'
+      @card.add_subfield :phrase, content: 'this is a sub'
       expect(@card.subfield(':phrase').content).to eq 'this is a sub'
     end
 
@@ -128,7 +128,7 @@ describe Card::Subcards do
       @card = Card['A']
     end
     it 'adds a subcard' do
-      @card._add_subcard 'sub', content: 'sub content'
+      @card.add_subcard 'sub', content: 'sub content'
       @card.save!
       expect(Card['sub'].content).to eq 'sub content'
     end
@@ -136,9 +136,7 @@ describe Card::Subcards do
   describe 'two levels of subcards' do
     it 'creates cards with subcards with subcards' do
       Card::Auth.as_bot do
-        in_phase before: :approve, trigger: -> {
-          Card.create! name: 'test'
-        } do
+        in_stage :validate, trigger: -> { Card.create!(name: 'test') } do
           if name == 'test'
             add_subfield('first-level')
             subfield('first-level').add_subfield 'second-level', content: 'yeah'
@@ -149,9 +147,7 @@ describe Card::Subcards do
     end
     it 'creates cards with subcards with subcards using codenames' do
       Card::Auth.as_bot do
-        in_phase before: :approve, trigger: -> {
-          Card.create! name: 'test'
-        } do
+        in_stage :validate, trigger: -> { Card.create!(name: 'test') } do
           if name == 'test'
             add_subfield :children
             subfield(:children).add_subfield :title, content: 'yeah'