card 1.99.6 → 1.100.0

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

@@ -26,23 +26,19 @@ def expire_subcards
   subcards.clear
 end
 
-def save_as_subcard!
-  self.only_storage_phase = true
-  save! validate: false
-end
-
 # phase_method :attach_subcard, before: :store do |name_or_card, args=nil|
 # TODO: handle differently in different stages
-def attach_subcard name_or_card, args={}
+def add_subcard name_or_card, args={}
   subcards.add name_or_card, args
 end
-alias_method :add_subcard, :attach_subcard
+alias_method :attach_subcard, :add_subcard
 
-def attach_subcard! name_or_card, args={}
+def add_subcard! name_or_card, args={}
   subcard = subcards.add name_or_card, args
   subcard.director.reset_stage
   subcard
 end
+alias_method :attach_subcard!, :add_subcard!
 
 # phase_method :attach_subfield, before: :approve do |name_or_card, args=nil|
 def attach_subfield name_or_card, args={}
@@ -88,7 +84,7 @@ def deep_clear_subcards
   subcards.deep_clear
 end
 
-event :handle_subcard_errors do
+def handle_subcard_errors
   subcards.each do |subcard|
     subcard.errors.each do |field, err|
       subcard_error subcard, field, err
@@ -119,18 +115,5 @@ end
 # check when renaming field that it is not actually the same field
 # (eg on a renamed trunk)
 def same_field?
-  same_field_trunk? && same_field_tag?
-end
-
-private
-
-# left is same card (even if renamed)
-def same_field_trunk?
-  l = superleft || Card[left_id]
-  lkey = name.left_name&.key
-  lkey.present? && l&.name&.key == lkey
-end
-
-def same_field_tag?
-  name.right_name.key == name_before_act.to_name.right_name.key
+  (left_id == left_id_before_act) && (right_id == right_id_before_act)
 end

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

@@ -25,15 +25,15 @@ def template
   end
 end
 
-def default_type_id default_card=nil
-  default_card ? default_card.type_id : Card.default_type_id
+def default_type_id
+  Card.default_type_id
 end
 
 def new_card_template
   default = rule_card :default, skip_modules: true
 
   dup_card = dup
-  dup_card.type_id = default_type_id default
+  dup_card.type_id = default&.type_id || default_type_id
 
   if (structure = dup_card.structure_rule_card)
     @virtual = true if junction?

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

@@ -14,9 +14,11 @@ Self::Admin.add_to_basket(
 module ClassMethods
   def empty_trash
     Card.delete_trashed_files
-    Card.where(trash: true).delete_all
+    Card.where(trash: true).in_batches.update_all(left_id: nil, right_id: nil)
+    Card.where(trash: true).in_batches.delete_all
     Card::Action.delete_cardless
     Card::Change.delete_actionless
+    Card::Act.delete_actionless
     Card::Reference.unmap_if_referee_missing
     Card::Reference.delete_if_referer_missing
   end
@@ -72,13 +74,12 @@ event :manage_trash, :prepare_to_store, on: :create do
 end
 
 def pull_from_trash!
-  return unless (trashed_card = Card.find_by_key_and_trash key, true)
-  # fwiw, now we _could_ get card using fetch look_in_trash: true (not tried).
+  return unless (id = Card::Lexicon.id key) # name is already known
+  return unless (trashed_card = Card.where(id: id).take)&.trash
+  # confirm name is actually in trash
 
-  self.id = trashed_card.id
-  # following is needed so that #id_in_database returns existing card id
-  # (and record is updated correctly)
   db_attributes["id"] = trashed_card.db_attributes["id"]
+  # id_in_database returns existing card id
 
   @from_trash = true
   @new_record = false
@@ -107,7 +108,7 @@ end
 
 event :validate_delete_children, after: :validate_delete, on: :delete do
   return if errors.any?
-  children.each do |child|
+  each_child do |child|
     next unless child
     # prevents errors in cases where a child is deleted prior to this point
     # and thus is not returned by the fetch in #children

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

@@ -32,14 +32,14 @@ def type= type_name
   self.type_id = Card.fetch_id type_name
 end
 
-def type_known?
-  type_id.present?
+def type_id= card_or_id
+  write_card_or_id :type_id, card_or_id
 end
 
-def get_type_id_from_structure
+def type_id_from_template
   return unless name && (t = template)
   reset_patterns # still necessary even with new template handling?
-  t.type_id
+  self.type_id = t.type_id
 end
 
 event :validate_type_change, :validate, on: :update, changed: :type_id do

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

@@ -8,5 +8,5 @@ end
 
 event :expire_related, :finalize do
   reset_patterns
-  structuree_names.each { |name| ActManager.expirees << name } if is_structure?
+  structuree_names.each { |name| Director.expirees << name } if is_structure?
 end

data/mod/core/spec/chunk/query_reference_spec.rb

@@ -35,9 +35,9 @@ describe Card::Content::Chunk::QueryReference, "QueryReference" do
 
     it "handles nested query structures" do
       @content = '{"any":{"content":"Where", ' \
-                 '"right_plus":["is",{"name":"Waldo"}]}}'
+                 '"right_plus":["was",{"name":"Waldo"}]}}'
       expect(query_refs[0].name).to eq "Where"
-      expect(query_refs[1].name).to eq "is"
+      expect(query_refs[1].name).to eq "was"
       expect(query_refs[2].name).to eq "Waldo"
     end
 

data/mod/core/spec/chunk/uri_spec.rb

@@ -1,6 +1,6 @@
 # -*- encoding : utf-8 -*-
 
-describe Card::Content::Chunk::URI, "URI chunk tests" do
+RSpec.describe Card::Content::Chunk::URI, "URI chunk tests" do
   it "test_non_matches" do
     no_match_uri "There is no URI here"
     no_match_uri "One gemstone is the garnet:reddish in colour, like ruby"
@@ -115,10 +115,10 @@ describe Card::Content::Chunk::URI, "URI chunk tests" do
               path: "", query: nil
   end
   it "handles mailto:" do
-    match_uri "mailto:jdoe123@example.com",
+    match_uri "mailto:j.d.oe123@example.com",
               scheme: "mailto", host: nil, port: nil,
               path: nil, query: nil,
-              to: "jdoe123@example.com"
+              to: "j.d.oe123@example.com"
   end
 
   it "runs more basic cases" do
@@ -148,10 +148,10 @@ describe Card::Content::Chunk::URI, "URI chunk tests" do
   end
 
   it "test_email_uri" do
-    match_uri "mail@example.com",
-              to: "mail@example.com", host: nil,
-              text: "mail@example.com",
-              link_text: "mailto:mail@example.com"
+    match_uri "e.mail4@example.com",
+              to: "e.mail4@example.com", host: nil,
+              text: "e.mail4@example.com",
+              link_text: "mailto:e.mail4@example.com"
   end
 
   it "test_non_email" do

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

@@ -1,15 +1,6 @@
 # -*- encoding : utf-8 -*-
 
-RSpec.describe "act API" 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
-
+RSpec.describe Card::Set::All::Actify do
   describe "#act" do
     let(:card) { Card["A"] }
 
@@ -53,197 +44,14 @@ RSpec.describe "act API" do
     end
   end
 
-  describe "add subcards" do
-    def save_transaction
-      @trans = ActiveRecord::Base.connection.current_transaction
-    end
-
-    def record_names
-      @trans.records.map(&:name)
-    end
-
-    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
-
-      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
-
-            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
-      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 :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
-            save_transaction
-          end
-
-          main_card = create_card
-          Delayed::Worker.new.work_off
-
-          expect(record_names).to eq ["main card"]
-          expect("sub card").to exist
-          expect("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
-
-  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
+  describe "Card.create!" do
+    it "does not prevent validations when run as subcard" do
       with_test_events do
-        test_event :validate do
-          self.content = "new content"
-          changed_attributes
-        end
-        test_event :integrate, for: "new name" do
-          expect(name_is_changing?).to be_truthy
-          expect(name_before_act).to eq("A")
-          expect(db_content_before_act).to eq("Alpha [[Z]]")
-        end
-        test_event :integrate_with_delay, for: "new name" do
-          expect(name_is_changing?).to be_truthy
-          expect(name_before_act).to eq("A")
-          expect(db_content_before_act).to eq("Alpha [[Z]]")
-        end
-        Card["A"].update! name: "new name"
-        Delayed::Worker.new.work_off
-      end
-    end
-
-    it '"changed" option works in integration phase' do
-      @called_events = []
-      def event_called ev
-        @called_events << ev
-      end
-
-      with_test_events do
-        test_event :integrate, changed: :name, for: "new name" do
-          event_called :i_name
-        end
-        test_event :integrate, changed: :content do
-          event_called :i_content
-        end
-        test_event :integrate_with_delay, changed: :name, for: "new name" do
-          event_called :iwd_name
-        end
-        test_event :integrate_with_delay, changed: :content do
-          event_called :iwd_content
-        end
-        Card["A"].update! name: "new name"
-        Delayed::Worker.new.work_off
-        expect(@called_events).to eq(%i[i_name iwd_name])
-      end
-    end
-  end
-
-  describe "Env" 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")
-        end
-        test_event :integrate, on: :create do
-          expect(Card::Env.root).to eq("new root")
-        end
-        test_event :integrate_with_delay, on: :create do
-          expect(Card::Env.root).to eq("new root")
+        test_event :finalize do
+          expect { Card.create! name: "A" }.to raise_error(/unique/)
+          raise Card::Error, "woot"
         end
-        create_card
-        Delayed::Worker.new.work_off
+        expect { Card["B"].update! content: "what" }.to raise_error(/woot/)
       end
     end
   end

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

@@ -4,8 +4,17 @@ 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
@@ -16,7 +25,8 @@ RSpec.describe Card::Set::All::FetchHelper do
 
   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
@@ -36,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