card 1.92.2 → 1.93.0

data/mod/core/set/all/update_read_rules.rb

@@ -2,68 +2,14 @@
 # FIXME: the following don't really belong here, but they have to come after
 # the reference stuff.  we need to organize a bit!
 
-event :update_ruled_cards, :finalize do
-  if is_rule?
-    # warn "updating ruled cards for #{name}"
-    self.class.clear_rule_cache
-    set = rule_set
-
-    if right_id == Card::ReadID && (name_is_changing? || trash_is_changing?)
-      update_read_ruled_cards set
-    end
-  end
-end
-
-def update_read_rules_not_overridden_by_narrower_rules cur_index,
-                                                       rule_class_index, set
-  set.item_cards(limit: 0).each_with_object(::Set.new) do |item_card, in_set|
-    in_set << item_card.key
-    next if cur_index < rule_class_index
-    item_card.update_read_rule
-  end
-end
-
-def update_read_rules_of_set_members set
-  return ::Set.new if trash || !(class_id = id_of_set_class(set))
-  rule_class_ids = set_patterns.map(&:pattern_id)
-  Auth.as_bot do
-    if (rule_class_index = rule_class_ids.index(class_id))
-      cur_index = rule_class_ids.index Card[read_rule_class].id
-      update_read_rules_not_overridden_by_narrower_rules cur_index,
-                                                         rule_class_index, set
-    else
-      warn "No current rule index #{class_id}, #{rule_class_ids.inspect}"
-      ::Set.new
-    end
-  end
+event :update_rule_cache, :finalize, when: :is_rule? do
+  self.class.clear_rule_cache
 end
 
 def id_of_set_class set
   set && (set_class = set.tag) && set_class.id
 end
 
-def update_read_ruled_cards set
-  self.class.clear_read_rule_cache
-  Card.cache.reset # maybe be more surgical, just Auth.user related
-  expire # probably shouldn't be necessary,
-  # but was sometimes getting cached version when card should be in the
-  # trash.  could be related to other bugs?
-
-  updated = update_read_rules_of_set_members set
-
-  # then find all cards with me as read_rule_id that were not just updated
-  # and regenerate their read_rules
-  return if new_card?
-  Card.search(read_rule_id: id) do |card|
-    card.update_read_rule unless updated.include?(card.key)
-  end
-end
-
-event :process_read_rule_update_queue, :finalize do
-  Array.wrap(@read_rule_update_queue).each(&:update_read_rule)
-  @read_rule_update_queue = []
-end
-
 event :expire_related, :finalize do
   subcards.keys.each do |key|
     Card.cache.soft.delete key

data/mod/core/set_pattern/04_star.rb

@@ -7,7 +7,7 @@ def prototype_args _anchor
 end
 
 def pattern_applies? card
-  card.cardname.star?
+  card.name.star?
 end
 
 def follow_label _name

data/mod/core/set_pattern/05_rstar.rb

@@ -9,7 +9,7 @@ def prototype_args _anchor
 end
 
 def pattern_applies? card
-  card.cardname.rstar?
+  card.name.rstar?
 end
 
 def follow_label _name

data/mod/core/set_pattern/06_right.rb

@@ -12,7 +12,7 @@ def prototype_args anchor
 end
 
 def anchor_name card
-  card.cardname.tag
+  card.name.tag
 end
 
 def follow_label name

data/mod/core/set_pattern/07_type_plus_right.rb

@@ -16,9 +16,8 @@ def prototype_args anchor
 end
 
 def anchor_name card
-  left = card.left new: {}
-  type_name = (left && left.type_name) || Card[Card.default_type_id].name
-  "#{type_name}+#{card.cardname.tag}"
+  type_name = card.left(new:{})&.type_name || Card.default_type_id.cardname
+  "#{type_name}+#{card.name.tag}"
 end
 
 def follow_label name

data/mod/core/spec/format/html_format_spec.rb

@@ -52,7 +52,7 @@ describe Card::Format::HtmlFormat do
         is_expected.to have_tag "div.d0-card-body.d0-card-content" \
                                 ".ALL.ALL_PLUS" \
                                 ".TYPE-basic.RIGHT-b.TYPE_PLUS_RIGHT-basic-b" \
-                                ".SELF-a-b.card-block.card-text",
+                                ".SELF-a-b.card-body.card-text",
                                 text:  /AlphaBeta/
       end
 
@@ -82,7 +82,7 @@ describe Card::Format::HtmlFormat do
       #        @layout_card.content = "Hi {{A}}"
       #        Card::Auth.as_bot { @layout_card.save }
       #
-      #        expect(@main_card.format.render(:layout)).to match('Hi Alpha')
+      #        expect(@main_card.format.render!(:layout)).to match('Hi Alpha')
       #      end
 
       #      it "defaults to open view for main card" do
@@ -108,7 +108,7 @@ describe Card::Format::HtmlFormat do
         @layout_card.content = "Mainly {{_main|core}}"
         Card::Auth.as_bot { @layout_card.save }
 
-        expect(@layout_card.format.render(:layout)).to eq(
+        expect(@layout_card.format.render!(:layout)).to eq(
           "Mainly <div id=\"main\"><div class=\"CodeRay\">\n  " \
           "<div class=\"code\"><pre>Mainly {{_main|core}}</pre></div>\n" \
           "</div>\n</div>\n" \
@@ -126,7 +126,7 @@ describe Card::Format::HtmlFormat do
           Card.create name: "outer space", content: "{{_main|name}}"
         end
 
-        expect(@main_card.format.render(:layout)).to eq(
+        expect(@main_card.format.render!(:layout)).to eq(
           '<div id="main">Joe User</div>' + "\n" \
           '<div class="modal fade" role="dialog" id="modal-main-slot">' \
           '<div class="modal-dialog"><div class="modal-content">' \

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

@@ -10,72 +10,130 @@ RSpec.describe "act API" do
                 }
   end
 
-  describe "add subcard in integrate stage" do
-    class Card
-      def current_trans
-        ActiveRecord::Base.connection.current_transaction
-      end
+  describe "add subcards" do
+    def save_transaction
+      @trans = ActiveRecord::Base.connection.current_transaction
+    end
 
-      def record_names
-        current_trans.records.map(&:name)
-      end
+    def record_names
+      @trans.records.map(&:name)
     end
 
-    context "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
-            add_subcard("sub card")
+    after do
+      @trans = nil
+    end
+
+    context "in integrate stage" do
+      context "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
+              save_transaction
+              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
 
-          test_event :finalize, on: :create, for: "main card" do
-            expect(record_names).to eq ["main card", "sub card"]
+      context "serial subcard handling" do
+        before do
+          Delayed::Worker.delay_jobs = true
+        end
+        after do
+          Delayed::Worker.delay_jobs = false
+        end
+
+        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 "processes subcards in separate transaction" do
+          with_test_events do
+            test_event :validate, on: :create, for: "main card" do
+              add_subcard("sub card", transact_in_stage: :integrate_with_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
 
-          create_card
+            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
 
-    context "serial subcard handling" do
-      it "processes subcards in separate transaction" do
+    describe "in integrate_with_delay stage" do
+      before do
         Delayed::Worker.delay_jobs = true
+      end
+      after do
+        Delayed::Worker.delay_jobs = false
+      end
+
+      it "processes cards not in the same transaction" do
         with_test_events do
-          test_event :validate, on: :create, for: "main card" do
-            add_subcard("sub card", transact_in_stage: :integrate_with_delay)
-            # expect(subcard('sub card').director.transact_in_stage)
-            #  .to eq :integrate
+          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
-            expect(record_names).to eq ["main card"]
-            expect(subcard("sub card").director.stage).to eq nil
+            save_transaction
           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
+          main_card = create_card
+          Delayed::Worker.new.work_off
 
-          test_event :finalize, on: :create, for: "sub card" do
-            expect(record_names).to eq ["sub card"]
-          end
+          expect(record_names).to eq ["main card"]
+          expect("sub card").to exist
+          expect("sub create card").to exist
 
-          test_event :integrate_with_delay, on: :create do
-            expect(record_names).to eq []
-          end
-          create_card
-          # expect to finished delayed jobs
-          expect(Delayed::Worker.new.work_off).to eq [2, 0]
-          expect(Card["sub card"]).to be_instance_of(Card)
+          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
 
   describe "dirty attributes" do
+    before do
+      Delayed::Worker.delay_jobs = true
+    end
+    after do
+      Delayed::Worker.delay_jobs = false
+    end
+
     it "survives to integration phase" do
-      #Delayed::Worker.delay_jobs = true
       with_test_events do
         test_event :validate do
           self.content = "new content"
@@ -91,8 +149,8 @@ RSpec.describe "act API" do
           expect(name_before_act).to eq("A")
           expect(db_content_before_act).to eq("Alpha [[Z]]")
         end
-        Delayed::Worker.new.work_off
         Card["A"].update_attributes! name: "new name"
+        Delayed::Worker.new.work_off
       end
     end
 
@@ -116,14 +174,21 @@ RSpec.describe "act API" do
           event_called :iwd_content
         end
         Card["A"].update_attributes! name: "new name"
+        Delayed::Worker.new.work_off
+        expect(@called_events).to eq(%i[i_name iwd_name])
       end
-      expect(@called_events).to eq(%i[i_name iwd_name])
     end
   end
 
   describe "Env" do
-    it "survives to integration phase" do
+    before do
       Delayed::Worker.delay_jobs = true
+    end
+    after do
+      Delayed::Worker.delay_jobs = false
+    end
+
+    it "survives to integration phase" do
       with_test_events do
         test_event :initialize, on: :create do
           Card::Env.root("new root")

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

@@ -45,7 +45,7 @@ describe Card::Set::All::EventConditions, "event" do
             add_to_log db_content_before_act
           end
         end
-        content_before_change = [Card["A"].content] * STAGES.size
+        content_before_change = [Card["A"].db_content] * STAGES.size
         change_content
         expect(@log).to contain_exactly(*content_before_change)
       end

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

@@ -1,6 +1,6 @@
 # -*- encoding : utf-8 -*-
 
-describe Card::Set::All::Fetch do
+RSpec.describe Card::Set::All::Fetch do
   describe "#fetch" do
     it "returns and caches existing cards" do
       card_double = class_double("Card")
@@ -37,7 +37,7 @@ describe Card::Set::All::Fetch do
         expect(card).to be_a(Card).and have_name "Joe User+*email"
         expect(card.format.render_raw).to eq("joe@user.com")
       end
-      # card.raw_content.should == 'joe@user.com'
+      # card.content.should == 'joe@user.com'
       # cached_card = Card.cache.read('joe_user+*email')
       # cached_card.missing?.should be_true
       # cached_card.virtual?.should be_true
@@ -62,6 +62,15 @@ describe Card::Set::All::Fetch do
       expect(aself.set_names).to include("Set+*type")
     end
 
+    it "fetches structured cards" do
+      Card::Auth.as_bot do
+        Card.create! name: "y+*right+*structure", content: "Formatted Content"
+        Card.create! name: "a+y", content: "DB Content"
+      end
+      card = Card.fetch("a+y")
+      expect(card).to be_real.and have_content("Formatted Content").and have_db_content("DB Content")
+    end
+
     it "handles name variants of cached cards" do
       expect(Card.fetch("yomama+*self").name).to eq("yomama+*self")
       expect(Card.fetch("YOMAMA+*self").name).to eq("YOMAMA+*self")
@@ -127,7 +136,7 @@ describe Card::Set::All::Fetch do
         it "initializes new cards" do
           card = Card.fetch "non-existent",
                             new: { default_content: "default content" }
-          expect(card.content).to eq "default content"
+          expect(card.db_content).to eq "default content"
         end
       end
       context "when new card exist" do
@@ -136,7 +145,7 @@ describe Card::Set::All::Fetch do
                    "+sub" => { content: "some content" }
           card = Card.fetch "new card+sub",
                             new: { default_content: "new content" }
-          expect(card.content).to eq "some content"
+          expect(card.db_content).to eq "some content"
         end
       end
     end
@@ -151,7 +160,7 @@ describe Card::Set::All::Fetch do
                      content: "Formatted Content"
         Card.create! name: "a+y", content: "DB Content"
         card = Card.fetch("a+y")
-        expect(card).to be_not_virtual.and have_content "DB Content"
+        expect(card).to be_not_virtual.and have_db_content "DB Content"
         expect(card.rule(:structure)).to eq("Formatted Content")
       end
 
@@ -161,25 +170,25 @@ describe Card::Set::All::Fetch do
         Card.fetch("a+y").delete!
 
         card = Card.fetch("a+y")
-        expect(card).to be_virtual.and have_raw_content "Formatted Content"
+        expect(card).to be_virtual.and have_content "Formatted Content"
       end
 
       it "recognizes pattern overrides" do
         # ~~~ create right rule
         Card.create!(name: "y+*right+*structure", content: "Right Content")
         card = Card.fetch("a+y")
-        expect(card).to be_virtual.and have_raw_content "Right Content"
+        expect(card).to be_virtual.and have_content "Right Content"
 
         #        warn 'creating template'
         tpr = Card.create! name: "Basic+y+*type plus right+*structure",
                            content: "Type Plus Right Content"
         card = Card.fetch("a+y")
-        expect(card).to be_virtual.and have_raw_content "Type Plus Right Content"
+        expect(card).to be_virtual.and have_content "Type Plus Right Content"
 
         # ~~~ delete type plus right rule
         tpr.delete!
         card = Card.fetch("a+y")
-        expect(card).to be_virtual.and have_raw_content "Right Content"
+        expect(card).to be_virtual.and have_content "Right Content"
       end
 
       it "does not hit the database for every fetch_virtual lookup" do
@@ -202,7 +211,7 @@ describe Card::Set::All::Fetch do
         it "initializes card with default content" do
           card = Card.fetch "non-existent",
                             new: { default_content: "default content" }
-          expect(card).to have_content "default content"
+          expect(card).to have_db_content "default content"
         end
       end
       context "when new card exist" do
@@ -211,7 +220,7 @@ describe Card::Set::All::Fetch do
                    "+sub" => { content: "some content" }
           card = Card.fetch "new card+sub",
                             new: { default_content: "new content" }
-          expect(card).to have_content "some content"
+          expect(card).to have_db_content "some content"
         end
       end
     end
@@ -248,7 +257,7 @@ describe Card::Set::All::Fetch do
     it "finds cards with *right+*structure specified" do
       expect(Card.fetch("A+testsearch".to_name))
         .to be_virtual.and have_type(:search_type)
-                              .and have_raw_content '{"plus":"_self"}'
+                              .and have_content '{"plus":"_self"}'
     end
     context "fetched virtual card with new args" do
       it "fetchs the virtual card with type set in patterns" do
@@ -257,7 +266,7 @@ describe Card::Set::All::Fetch do
 
         c = Card.fetch("Home+testsearch".to_name)
         expect(c).to be_virtual.and have_type(:search_type)
-                                       .and have_raw_content('{"plus":"_self"}')
+                                       .and have_content('{"plus":"_self"}')
 
         patterns = c.instance_variable_get("@patterns").map(&:to_s)
         expect(patterns).to include("Search+*type")
@@ -274,4 +283,39 @@ describe Card::Set::All::Fetch do
       expect(Card.exists?("Mumblefunk is gone")).to eq(false)
     end
   end
+
+  describe "#fetch_name" do
+    example "symbol" do
+      expect(Card.fetch_name(:all)).to eq "*all"
+    end
+
+    example "string" do
+      expect(Card.fetch_name("home")).to eq "Home"
+    end
+
+    example "id" do
+      expect(Card.fetch_name(Card::BasicID)).to eq "Basic"
+    end
+
+    example "array" do
+      expect(Card.fetch_name(%w[a b])).to eq "A+B"
+    end
+
+    example "param list" do
+      expect(Card.fetch_name("fruit", :type, "*create")).to eq "Fruit+*type+*create"
+    end
+
+    example "name doesn't exist" do
+      expect(Card.fetch_name("unknown_name")).to eq nil
+    end
+
+    example "fallback policy" do
+      name = Card.fetch_name("unknown_name") { "Unknown Name" }
+      expect(name).to eq "Unknown Name"
+    end
+
+    it "doesn't fetch virtual names" do
+      expect(Card.fetch_name(:all, :self, :create)).to eq nil
+    end
+  end
 end