card 1.99.2 → 1.100.0

data/mod/core/spec/set/all/chunk_spec.rb

@@ -31,6 +31,7 @@ RSpec.describe Card::Set::All::Chunk do
 
     example "absolute option", as_bot: true do
       format = format_with_edit_fields [[:self, { absolute: true }]]
+
       expect(format.render_edit).to have_tag ".card-editor", with: { card_name: "*self" }
     end
 

data/mod/core/spec/set/all/event_conditions_spec.rb

@@ -177,7 +177,9 @@ RSpec.describe Card::Set::All::EventConditions do
       def add_logging_test_event allowed, for_name
         event_args = { on: :update, skip: allowed }
         event_args[:for] = for_name if for_name
-        test_event(:validate, event_args) { add_to_log "#{name} executed" }
+        test_event(:validate, event_args) do
+          add_to_log "#{name} executed"
+        end
       end
 
       def update_with_skip force, changes, skip_key
@@ -190,16 +192,16 @@ RSpec.describe Card::Set::All::EventConditions do
         end
       end
 
-      specify "skip_event condition" do
+      specify "skip condition" do
         expect_skipping({ content: "changed" }, [], "A executed", for_name: "A")
       end
 
-      specify "skip_event condition in subcard" do
+      specify "skip condition in subcard" do
         expect_skipping({ content: "changed", subcards: { "+B" => "changed +B" } },
                         [], "A+B executed", for_name: "A+B")
       end
 
-      specify "skip_event_in_action condition" do
+      specify "skip_in_action condition" do
         expect_skipping({ content: "changed", subcards: { "+B" => "changed +B" } },
                         ["A+B executed"],
                         ["A executed", "A+B executed", "A+B executed"],

data/mod/core/spec/set/all/fetch_helper_spec.rb

@@ -4,13 +4,29 @@ RSpec.describe Card::Set::All::FetchHelper do
   let(:retrieve) { test_retrieve_existing }
   let(:retrieve_from_trash) { test_retrieve_existing look_in_trash: true }
 
+  def fetch_object opts={}
+    if @fetch_object
+      @fetch_object.opts.merge! opts
+      @fetch_object
+    else
+      @fetch_object = Card::Fetch.new("A".to_name, opts)
+    end
+  end
+
   def test_retrieve_existing opts={}
-    Card.send :retrieve_existing, "A".to_name, opts
+    fetch_object(opts)&.retrieve_existing
+  end
+
+  describe "#controller fetch" do
+    it "removes underscores from new card names" do
+      expect(Card.controller_fetch(mark: "no_un_der_score").name).to eq("no un der score")
+    end
   end
 
   describe "retrieve_existing" do
     it "looks for non-cached card in database" do
-      expect_db_retrieval_with(:key, "a", nil) { retrieve }
+      # expect_db_retrieval_with(:key, "a", nil) { retrieve }
+      expect_db_retrieval { retrieve }
     end
 
     it "doesn't look in db for cached cards(real)" do
@@ -30,19 +46,20 @@ RSpec.describe Card::Set::All::FetchHelper do
 
     it "looks in db for cached cards (new) if 'look_in_trash' option used" do
       Card.cache.write "a", Card.new
-      expect_db_retrieval_with(:key, "a", true) { retrieve_from_trash }
+      # expect_db_retrieval_with(:key, "a", true) { retrieve_from_trash }
+      expect_db_retrieval { retrieve_from_trash }
     end
 
     def expect_no_db_retrieval
-      allow(Card).to receive(:retrieve_from_db)
+      allow(fetch_object).to receive(:retrieve_from_db)
       yield
-      expect(Card).not_to have_received(:retrieve_from_db)
+      expect(fetch_object).not_to have_received(:retrieve_from_db)
     end
 
-    def expect_db_retrieval_with *args
-      allow(Card).to receive(:retrieve_from_db)
+    def expect_db_retrieval
+      allow(fetch_object).to receive(:retrieve_from_db)
       yield
-      expect(Card).to have_received(:retrieve_from_db).with(*args)
+      expect(fetch_object).to have_received(:retrieve_from_db) # .with(*args)
     end
   end
 end

data/mod/core/spec/set/all/name_events_spec.rb

@@ -27,7 +27,7 @@ RSpec.describe Card::Set::All::NameEvents do
     end
   end
 
-  describe "event: set_left_and_right" do
+  describe "event: prepare_left_and_right" do
     context "when creating junctions" do
       before do
         Card.create! name: "Peach+Pear", content: "juicy"

data/mod/core/spec/set/all/name_spec.rb

@@ -1,22 +1,11 @@
 # -*- encoding : utf-8 -*-
 
-describe Card::Set::All::Name do
-  describe "#repair_key" do
-    it "fixes broken keys" do
-      a = Card["a"]
-      a.update_column "key", "broken_a"
-      a.expire
-
-      a = Card.find a.id
-      expect(a.key).to eq("broken_a")
-      a.repair_key
-      expect(a.key).to eq("a")
-    end
-  end
-
-  describe "#descendants" do
+RSpec.describe Card::Set::All::Name do
+  describe "#each_descendants" do
     it "finds descendants" do
-      expect(Card["A"].descendants.length).to be > 0
+      descendants_of_a = []
+      Card["A"].each_descendant { |card| descendants_of_a << card.name }
+      expect(descendants_of_a).to include("A+B+C")
     end
   end
 end

data/mod/core/spec/set/all/pattern_spec.rb

@@ -55,7 +55,7 @@ RSpec.describe Card::Set::All::Pattern do
     it "handles type plus right prototypes properly" do
       Card::Auth.as_bot do
         sets = Card.fetch("Fruit+flavor+*type plus right").prototype.set_names
-        expect(sets.include?("Fruit+flavor+*type plus right")).to be_truthy
+        expect(sets).to include("Fruit+flavor+*type plus right")
       end
     end
   end

data/mod/core/spec/set/all/permissions_spec.rb

@@ -98,22 +98,24 @@ RSpec.describe Card::Set::All::Permissions do
 
     it "write user permissions" do
       Card::Auth.as_bot do
-        @u1.fetch(:roles, new: {}).items = [@r1, @r2]
-        @u2.fetch(:roles, new: {}).items = [@r1, @r3]
-        @u3.fetch(:roles, new: {}).items = [@r1, @r2, @r3]
-
         (1..3).map do |num|
           Card.create name: "c#{num}+*self+*update", type: "Pointer",
                       content: "[[u#{num}]]"
         end
+
+        Card::Cache.renew
+
+        @u1.fetch(:roles, new: {}).items = [@r1, @r2]
+        @u2.fetch(:roles, new: {}).items = [@r1, @r3]
+        @u3.fetch(:roles, new: {}).items = [@r1, @r2, @r3]
       end
 
-      @c1 = Card["c1"]
+      @c1 = Card["c1"].refresh(true)
       assert_not_locked_from(@u1, @c1)
       assert_locked_from(@u2, @c1)
       assert_locked_from(@u3, @c1)
 
-      @c2 = Card["c2"]
+      @c2 = Card["c2"].refresh(true)
       assert_locked_from(@u1, @c2)
       assert_not_locked_from(@u2, @c2)
       assert_locked_from(@u3, @c2)
@@ -130,6 +132,10 @@ RSpec.describe Card::Set::All::Permissions do
         end
       end
 
+      @c1 = @c1.refresh(true)
+      @c2 = @c2.refresh(true)
+      @c3 = @c3.refresh(true)
+
       assert_not_hidden_from(@u1, @c1)
       assert_not_hidden_from(@u1, @c2)
       assert_hidden_from(@u1, @c3)
@@ -176,6 +182,8 @@ RSpec.describe Card::Set::All::Permissions do
         end
       end
 
+      @c1 = @c1.refresh(true)
+      @c2 = @c2.refresh(true)
       # NOTE: retrieving private cards is known not to work now.
       # assert_not_hidden_from(@u1, @c1)
       # assert_not_hidden_from(@u2, @c2)

data/mod/core/spec/set/all/references_spec.rb

@@ -49,5 +49,14 @@ RSpec.describe Card::Set::All::References do
       Card["A"].update! name: "AAA", update_referers: true
       expect(Card["X"].content).to eq("[[AAA]] [[AAA+B]] [[T]]")
     end
+
+    # FIXME: following should pass!
+    xit "handles reference loops" do
+      Card["A"].update! content: "[[A+B]] refers to me"
+      Card["A+B"].update! content: "[[A]] refers to me, too"
+      Card["A"].update! name: "AAA", update_referers: true
+      expect(Card["AAA+B"].content).to eq("[[AAA]] refers to me, too")
+      expect(Card["AAA"].content).to eq("[[AAA+B]] refers to me")
+    end
   end
 end

data/mod/core/spec/set/all/rename_spec.rb

@@ -2,13 +2,15 @@
 
 module RenameMethods
   def name_invariant_attributes card
+    descendant_ids = []
+    card.each_descendant { |d| descendant_ids << d.id }
     {
       content: card.db_content,
       # updater_id:  card.updater_id,
       # revisions:   card.actions.count,
       referers: card.referers.map(&:name).sort,
       referees: card.referees.map(&:name).sort,
-      descendants: card.descendants.map(&:id).sort
+      descendants: descendant_ids.sort
     }
   end
 
@@ -30,7 +32,15 @@ RSpec.describe Card::Set::All::Rename do
   include RenameMethods
   include CardExpectations
 
-  it "renaming plus card to its own child" do
+  it "renames simple card to its own child" do
+    assert_rename "F", "F+M"
+  end
+
+  it "disallows renaming simple to compound when simple is used as tag" do
+    expect { Card["A"].update! name: "A+M" }.to raise_error(/illegal name change/)
+  end
+
+  it "renames plus card to its own child" do
     assert_rename "A+B", "A+B+T"
   end
 
@@ -77,7 +87,7 @@ RSpec.describe Card::Set::All::Rename do
 
     expect(card_list.map(&:name)).to eq old_names
     update "One", name: "Uno"
-    expect(card_list.map(&:reload).map(&:name)).to eq new_names
+    expect(card_list.map(&:id).map(&:cardname)).to eq new_names
   end
 
   it "fails if name is invalid" do

data/mod/core/spec/set/all/rules_spec.rb

@@ -109,7 +109,7 @@ describe Card::Set::All::Rules do
           Card.create(name: "Book+*type+Joe User+*follow", content: "[[Home]]")
           Card::Auth.signin "Joe Admin"
           Card.create(name: "Book+*type+Joe Admin+*follow", content: "[[Home]]")
-          user_ids = Card.all_user_ids_with_rule_for(
+          user_ids = Card::Rule.all_user_ids_with_rule_for(
             Card.fetch("Book+*type"), :follow
           )
           expect(user_ids.sort).to eq(

data/mod/core/spec/set/all/subcards_spec.rb

@@ -0,0 +1,106 @@
+RSpec.describe Card::Set::All::Subcards do
+  let(:create_card) { Card.create!(name: "main card") }
+  let(:create_card_with_subcards) do
+    Card.create name: "main card",
+                subcards: { "11" => { subcards: { "111" => "A" } },
+                            "12" => { subcards: { "121" => "A" } } }
+  end
+
+  describe "add subcards" do
+    let(:transact) { ActiveRecord::Base.connection.current_transaction }
+    let(:record_names) { transact.records.map(&:name) }
+
+    context "when in integrate stage" do
+      context "with default subcard handling" do
+        it "processes all cards in one transaction" do
+          with_test_events do
+            test_event :validate, on: :create, for: "main card" do
+              transact
+              add_subcard("sub card")
+            end
+
+            test_event :finalize, on: :create, for: "main card" do
+              expect(record_names).to eq ["main card", "sub card"]
+            end
+
+            create_card
+          end
+        end
+      end
+
+      context "with delayed jobs" do
+        before { Delayed::Worker.delay_jobs = true }
+        after { Delayed::Worker.delay_jobs = false }
+
+        context "with serial subcard handling" do
+          class Card
+            def __current_trans
+              ActiveRecord::Base.connection.current_transaction
+            end
+
+            def __record_names trans=nil
+              trans ||= __current_trans
+              trans.records.map(&:name)
+            end
+          end
+
+          it "director.delay! processes subcards in separate transaction" do
+            with_test_events do
+              test_event :validate, on: :create, for: "main card" do
+                sc = add_subcard("sub card")
+                sc.director.delay!
+              end
+
+              test_event :finalize, on: :create, for: "main card" do
+                expect(__record_names).to eq ["main card"]
+                expect(subcard("sub card").director.stage).to eq nil
+              end
+
+              test_event :integrate, on: :create, for: "main card" do
+                expect(__record_names).to eq []
+                expect(subcard("sub card").director.stage).to eq nil
+              end
+
+              test_event :finalize, on: :create, for: "sub card" do
+                expect(__record_names).to eq ["sub card"]
+              end
+
+              test_event :integrate_with_delay, on: :create do
+                expect(__record_names).to eq []
+              end
+              create_card
+              expect(Delayed::Worker.new.work_off).to eq [2, 0]
+              expect(Card["sub card"]).to be_instance_of(Card)
+            end
+          end
+        end
+      end
+
+      describe "in integrate_with_delay stage" do
+        it "processes cards not in the same transaction" do
+          with_test_events do
+            test_event :integrate_with_delay, on: :create, for: "main card" do
+              Card.create! name: "sub create card"
+              add_subcard("sub card")
+            end
+
+            test_event :finalize, on: :create, for: "main card" do
+              transact
+            end
+
+            main_card = create_card
+            Delayed::Worker.new.work_off
+
+            expect(record_names).to eq ["main card"]
+            expect(Card["sub card"]).to exist
+            expect(Card["sub create card"]).to exist
+
+            act_of_main = main_card.acts.last
+            expect(act_of_main).to eq Card["sub create card"].actions.last.act
+            expect(act_of_main).to eq Card["sub card"].actions.last.act
+          end
+        end
+      end
+    end
+  end
+end

data/mod/core/spec/set/all/trash_spec.rb

@@ -1,26 +1,28 @@
 # -*- encoding : utf-8 -*-
 
-describe Card, "deleted card" do
-  before do
-    Card::Auth.as_bot do
-      @c = Card["A"]
-      @c.delete!
+RSpec.describe Card::Set::All::Trash do
+  describe "deletion basics" do
+    before do
+      Card::Auth.as_bot do
+        @c = Card["A"]
+        @c.delete!
+      end
     end
-  end
-  it "is in the trash" do
-    expect(@c.trash).to be_truthy
-  end
-  it "comes out of the trash when a plus card is created" do
-    Card::Auth.as_bot do
-      Card.create(name: "A+*acct")
-      c = Card["A"]
-      expect(c.trash).to be_falsey
+
+    it "is in the trash" do
+      expect(@c.trash).to be_truthy
+    end
+
+    it "comes out of the trash when a plus card is created" do
+      Card::Auth.as_bot do
+        Card.create(name: "A+*acct")
+        c = Card["A"]
+        expect(c.trash).to be_falsey
+      end
     end
   end
-end
 
-describe Card::Set::All::Trash do
-  it "dependent removal" do
+  it "descendant removal" do
     create! "born to die"
     create! "born to die+slowly"
     create! "slowly+born to die"
@@ -35,7 +37,7 @@ describe Card::Set::All::Trash do
     expect(Card["slowly"]).to be_a Card
     expect(Card["without regrets"]).to be_a Card
 
-    trashed_dependant = Card.find_by_name "born to die+slowly+without regrets"
+    trashed_dependant = Card.find Card::Lexicon.id("born to die+slowly+without regrets")
     expect(trashed_dependant.trash).to be_truthy
   end
 
@@ -95,8 +97,10 @@ describe Card::Set::All::Trash do
 
       context "without edits" do
         it "is removable" do
-          expect { Card["Sample User"].delete! }
-            .not_to raise_error
+          Card::Auth.as "joe_admin" do
+            expect { Card["Sample User"].delete! }
+              .not_to raise_error
+          end
         end
       end
     end

data/mod/developer/set/all/event_viz.rb

@@ -13,8 +13,7 @@
 # prevent events from showing up in the tree.
 def events action
   @action = action
-  events =
-    ActManager::Stage::STAGES.map { |stage| events_tree("#{stage}_stage") }
+  events = Director::Stages::STAGES.map { |stage| events_tree "#{stage}_stage" }
   @action = nil
   puts_events events
 end