card 1.99.6 → 1.100.0

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/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/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

data/mod/edit/set/all/edit_name.rb

@@ -37,6 +37,7 @@ format :html do
     end
   end
 
+  # LOCALIZE
   def rename_and_update_button
     submit_button text: "Rename and Update", disable_with: "Renaming",
                   class: "renamer-updater"
@@ -46,45 +47,12 @@ format :html do
     button_tag "Rename", data: { disable_with: "Renaming" }, class: "renamer"
   end
 
+  # LOCALIZE
   def rename_confirmation_alert
     msg = "<h5>Are you sure you want to rename <em>#{safe_name}</em>?</h5>"
-    msg << rename_effects_and_options
+    msg << %(<h6>This may change names referred to by other cards.</h6>)
+    msg << %(<p>You may choose to <em>update or ignore</em> the referers.</p>)
+    msg << hidden_field_tag(:referers, 1)
     alert("warning", false, false, class: "hidden-alert") { msg }
   end
-
-  def rename_effects_and_options
-    descendant_effect = rename_descendant_effect
-    referer_effect, referer_option = rename_referer_effect_and_option
-    effects = [descendant_effect, referer_effect].compact
-    return "" if effects.empty?
-
-    format_rename_effects_and_options effects, referer_option
-  end
-
-  def format_rename_effects_and_options effects, referer_option
-    effects = effects.map { |effect| "<li>#{effect}</li>" }.join
-    info = %(<h6>This change will...</h6>)
-    info += %(<ul>#{effects}</ul>)
-    info += %(<p>#{referer_option}</p>) if referer_option
-    info
-  end
-
-  def rename_descendant_effect
-    descendants = card.descendants
-    return unless descendants.any? # FIXME: count, don't instantiate
-
-    "automatically alter #{descendants.size} related name(s)."
-  end
-
-  def rename_referer_effect_and_option
-    referers = card.family_referers
-    return unless referers.any? # FIXME: count, don't instantiate
-
-    count = referers.size
-    refs = count == 1 ? "reference" : "references"
-    effect = "affect at least #{count} #{refs} to \"#{card.name}\""
-    effect += hidden_field_tag(:referers, count)
-    option = "You may choose to <em>update or ignore</em> the referers."
-    [effect, option]
-  end
 end

data/mod/follow/set/all/notify.rb

@@ -1,3 +1,4 @@
+attr_accessor :follower_stash
 mattr_accessor :force_notifications
 
 event :silence_notifications, :initialize, when: :silence_notifications? do
@@ -27,7 +28,7 @@ event :notify_followers_after_delete, :integrate, on: :delete, when: :notable_ch
 end
 
 def notify_followers
-  return unless (act = Card::ActManager.act)
+  return unless (act = Card::Director.act)
 
   act.reload
   notify_followers_of act

data/mod/follow/set/self/edited.rb

@@ -4,7 +4,7 @@ restrictive_follow_opts position: 2
 
 follower_candidate_ids do |card|
   # FIXME? - could optimize by not using cards table...
-  Card.search editor_of: card.name, return: :id
+  card.id ? Card.search(editor_of: card.id, return: :id) : []
 end
 
 def title

data/mod/follow/spec/set/all/notify_spec.rb

@@ -244,11 +244,11 @@ RSpec.describe Card::Set::All::Notify do
         notify_on_create "Sunglasses fan", "Sunglasses+*self", "Sunglasses+producer"
         notify_on_update "Sunglasses fan", "Sunglasses+*self", "Sunglasses+price"
 
-        context "when follow fields rule contains *include" do
+        context "when follow fields rule contains *nests" do
           notify_on_create "Sunglasses fan", "Sunglasses+*self", "Sunglasses+lens"
           notify_on_update "Sunglasses fan", "Sunglasses+*self", "Sunglasses+tint"
 
-          it "doesn't send notification of not included card" do
+          it "doesn't send notification of non-nested card" do
             expect_user("Sunglasses fan").not_to be_notified
             Card.create! name: "Sunglasses+frame"
           end

data/mod/history/lib/card/change.rb

@@ -21,7 +21,7 @@ class Card
                         inverse_of: :card_changes
 
     # lists the database fields for which changes are recorded
-    TRACKED_FIELDS = %w[name type_id db_content trash].freeze
+    TRACKED_FIELDS = %w[name type_id db_content trash left_id right_id].freeze
 
     class << self
       # delete all {Change changes} not associated with an {Action action}

data/mod/history/set/all/history/events.rb

@@ -4,7 +4,7 @@ event :assign_action, :initialize, when: :actionable? do
   act = director.need_act
   @current_action = Card::Action.create(
     card_act_id: act.id,
-    action_type: @action,
+    action_type: action,
     draft: (Env.params["draft"] == "true")
   )
   if @supercard && @supercard != self
@@ -87,14 +87,14 @@ event :rollback_actions, :prepare_to_validate, on: :update, when: :rollback_requ
 end
 
 event :finalize_act, after: :finalize_action, when: :act_card? do
-  Card::ActManager.act.update! card_id: id
+  Card::Director.act.update! card_id: id
 end
 
 event :remove_empty_act, :integrate_with_delay_final, when: :remove_empty_act? do
-  # Card::ActManager.act.delete
-  # Card::ActManager.act = nil
+  # Card::Director.act.delete
+  # Card::Director.act = nil
 end
 
 def remove_empty_act?
-  act_card? && ActManager.act&.ar_actions&.reload&.empty?
+  act_card? && Director.act&.ar_actions&.reload&.empty?
 end