card 1.101.2 → 1.102.0

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

@@ -13,5 +13,5 @@ def prototype_args _anchor
 end
 
 def pattern_applies? card
-  card.is_rule?
+  card.rule?
 end

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

@@ -2,7 +2,8 @@
 
 RSpec.describe Card::Set::All::AssignAttributes do
   it "assigns attributes" do
-    card = Card.new name: "#name", type: :basic, content: "#content", codename: "#codename"
+    card = Card.new name: "#name", type: :basic, content: "#content",
+                    codename: "#codename"
     expect(card.attributes).to include(
       "name" => "#name",
       "db_content" => "#content",
@@ -31,18 +32,18 @@ RSpec.describe Card::Set::All::AssignAttributes do
   end
 
   it "assigns subfields" do
-      card = Card.new name: "#name", subfields: { default: { content: "subcontent" } }
-      expect(card.subcards.first).to eq "name+*default"
-      subcard = card.subfield :default
-      expect(subcard).to be_a(Card)
-      expect(subcard.name).to eq "#name+*default"
-      expect(subcard.content).to eq "subcontent"
-    end
+    card = Card.new name: "#name", subfields: { default: { content: "subcontent" } }
+    expect(card.subcards.first).to eq "name+*default"
+    subcard = card.subfield :default
+    expect(subcard).to be_a(Card)
+    expect(subcard.name).to eq "#name+*default"
+    expect(subcard.content).to eq "subcontent"
+  end
 
   describe "set specific attributes" do
     example "file card with set specfic attribute" do
       card = Card.new name: "empty", type: :file, empty_ok: true
-      expect(card.empty_ok?).to be_truthy
+      expect(card).to be_empty_ok
     end
   end
 end

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

@@ -0,0 +1,258 @@
+# -*- encoding : utf-8 -*-
+
+# FIXME: - this seems like a LOT of testing but it doesn't cover a ton of ground
+# I think we should move the rendering tests into basic and trim this to about
+# a quarter of its current length
+
+RSpec.describe Card do
+  RSpec::Matchers.define :have_toc do
+    match do |card|
+      values_match?(/Table of Contents/, card.format.render_open_content)
+    end
+  end
+
+  let(:c1) { described_class["Onne Heading"] }
+  let(:c2) { described_class["Twwo Heading"] }
+  let(:c3) { described_class["Three Heading"] }
+  let(:rule_card) { c1.rule_card(:table_of_contents) }
+
+  context "when there is a general toc rule of 2" do
+    before do
+      Card::Auth.as_bot do
+        create %i[basic type table_of_contents], "2"
+      end
+    end
+
+    specify do
+      expect(c1.type_id).to eq(Card::BasicID)
+      expect(rule_card).to be_a described_class
+    end
+
+    describe ".rule" do
+      it "has a value of 2" do
+        expect(rule_card.content).to eq("2")
+        expect(c1.rule(:table_of_contents)).to eq("2")
+      end
+    end
+
+    describe "renders with/without toc" do
+      it "does not render for 'Onne Heading'" do
+        expect(c1).not_to have_toc
+      end
+
+      it "renders for 'Twwo Heading'" do
+        expect(c2).to have_toc
+      end
+
+      it "renders for 'Three Heading'" do
+        expect(c3).to have_toc
+      end
+    end
+
+    describe ".related_sets" do
+      it "has 1 set (right) for a simple card" do
+        sets = described_class["A"].related_sets.map { |s| s[0] }
+        expect(sets).to eq(["A+*right"])
+      end
+
+      it "has 2 sets (type, and right) for a cardtype card" do
+        sets = described_class["Cardtype A"].related_sets.map { |s| s[0] }
+        expect(sets).to eq(["Cardtype A+*type", "Cardtype A+*right"])
+      end
+      # it "shows type plus right sets when they exist" do
+      #   Card::Auth.as_bot do
+      #     Card.create name: 'RichText+A+*type plus right', content: ''
+      #   end
+      #   sets = Card['A'].related_sets
+      #   sets.should == ['A+*self', 'A+*right', 'RichText+A+*type plus right']
+      # end
+      # it "shows type plus right sets when they exist, and type" do
+      #   Card::Auth.as_bot do
+      #     Card.create name: 'RichText+Cardtype A+*type plus right', content: ''
+      #   end
+      #   sets = Card['Cardtype A'].related_sets
+      #   sets.should == ['Cardtype A+*self', 'Cardtype A+*type',
+      #     'Cardtype A+*right', 'RichText+Cardtype A+*type plus right']
+      # end
+
+      it "is empty for a non-simple card" do
+        sets = described_class["A+B"].related_sets.map { |s| s[0] }
+        expect(sets).to eq([])
+      end
+    end
+    #     # class methods
+    #     describe ".default_rule" do
+    #       it 'has default rule' do
+    #         Card.default_rule(:table_of_contents).should == '0'
+    #       end
+    #     end
+  end
+
+  context "when I change the general toc setting to 1" do
+    before do
+      rule_card.content = "1"
+    end
+
+    describe ".rule" do
+      it "has a value of 1" do
+        expect(c1.rule(:table_of_contents)).to eq("1")
+      end
+    end
+
+    describe "renders with/without toc" do
+      it "does not render toc for 'Onne Heading'" do
+        expect(c1).to have_toc
+      end
+
+      it "renders toc for 'Twwo Heading'" do
+        expect(c2).to have_toc
+      end
+
+      it "does not render for 'Twwo Heading' when changed to 3" do
+        rule_card.content = "3"
+        expect(c2.rule(:table_of_contents)).to eq("3")
+        expect(c2).not_to have_toc
+      end
+    end
+  end
+
+  context "when I use CardtypeE cards" do
+    before do
+      Card::Auth.as_bot do
+        @c1 = described_class.create name: "toc1", type: "CardtypeE",
+                                     content: described_class["Onne Heading"].content
+        @c2 = described_class.create name: "toc2", type: "CardtypeE",
+                                     content: described_class["Twwo Heading"].content
+        @c3 = described_class.create name: "toc3", type: "CardtypeE",
+                                     content: described_class["Three Heading"].content
+      end
+      expect(@c1.type_name).to eq("Cardtype E")
+      @rule_card = @c1.rule_card(:table_of_contents)
+
+      expect(@c1).to be
+      expect(@c2).to be
+      expect(@c3).to be
+      expect(@rule_card).to be
+    end
+
+    describe ".rule" do
+      it "has a value of 0" do
+        expect(@c1.rule(:table_of_contents)).to eq("0")
+        expect(@rule_card.content).to eq("0")
+      end
+    end
+
+    describe "renders without toc" do
+      it "does not render for 'Onne Heading'" do
+        expect(@c1).not_to have_toc
+      end
+
+      it "renders for 'Twwo Heading'" do
+        expect(@c2).not_to have_toc
+      end
+
+      it "renders for 'Three Heading'" do
+        expect(@c3).not_to have_toc
+      end
+    end
+
+    describe ".rule_card" do
+      it "doesn't have a type rule" do
+        expect(@rule_card).to be
+        expect(@rule_card.name).to eq("*all+*table of contents")
+      end
+
+      it "get the same card without the * and singular" do
+        expect(@c1.rule_card(:table_of_contents)).to eq(@rule_card)
+      end
+    end
+
+    #     # class methods
+    #     describe ".default_rule" do
+    #       it 'has default rule' do
+    #         Card.default_rule(:table_of_contents).should == '0'
+    #       end
+    #     end
+  end
+
+  context "when I create a new rule" do
+    before do
+      Card::Auth.as_bot do
+        described_class.create! name: "RichText+*type+*table of contents", content: "2"
+        @c1 = described_class.create! name: "toc1", type: "CardtypeE",
+                                      content: described_class["Onne Heading"].content
+        @c2 = described_class.create! name: "toc2",
+                                      content: described_class["Twwo Heading"].content
+        @c3 = described_class.create! name: "toc3",
+                                      content: described_class["Three Heading"].content
+        expect(@c1.type_name).to eq("Cardtype E")
+        @rule_card = @c1.rule_card(:table_of_contents)
+
+        expect(@c1).to be
+        expect(@c2).to be
+        expect(@c3).to be
+        expect(@rule_card.name).to eq("*all+*table of contents")
+        if (c = described_class["CardtypeE+*type+*table of content"])
+          c.content = "2"
+          c.save!
+        else
+          described_class.create! name: "CardtypeE+*type+*table of content", content: "2"
+        end
+      end
+    end
+
+    it "takes on new setting value" do
+      c = described_class["toc1"]
+      expect(c.rule_card(:table_of_contents).name)
+        .to eq("CardtypeE+*type+*table of content")
+      expect(c.rule(:table_of_contents)).to eq("2")
+    end
+
+    describe "renders with/without toc" do
+      it "does not render for 'Onne Heading'" do
+        expect(@c1).not_to have_toc
+      end
+
+      it "renders for 'Twwo Heading'" do
+        expect(@c2.rule(:table_of_contents)).to eq("2")
+        expect(@c2).to have_toc
+      end
+
+      it "renders for 'Three Heading'" do
+        expect(@c3).to have_toc
+      end
+    end
+  end
+
+  context "when I change the general toc setting to 1" do
+    let(:c1) { described_class["Onne Heading"] }
+    let(:c2) { described_class["Twwo Heading"] }
+    let(:rule_card) { c1.rule_card(:table_of_contents) }
+
+    before do
+      rule_card.content = "1"
+    end
+
+    describe ".rule" do
+      it "has a value of 1" do
+        expect(rule_card.content).to eq("1")
+        expect(c1.rule(:table_of_contents)).to eq("1")
+      end
+    end
+
+    describe "renders with/without toc" do
+      it "does not render toc for 'Onne Heading'" do
+        expect(c1).to have_toc
+      end
+
+      it "renders toc for 'Twwo Heading'" do
+        expect(c2).to have_toc
+      end
+
+      it "does not render for 'Twwo Heading' when changed to 3" do
+        rule_card.content = "3"
+        expect(c2).not_to have_toc
+      end
+    end
+  end
+end

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

@@ -18,7 +18,7 @@ RSpec.describe Card::Set::All::Collection do
     end
 
     it "handles searches relative to context card" do
-      # note: A refers to 'Z'
+      # NOTE: A refers to 'Z'
       @context = "A"
       @args = { name: "foo", type: "Search",
                 content: '{"referred_to_by":"_self"}' }

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

@@ -23,6 +23,7 @@ RSpec.describe Card::Set::All::Export do
           a_hash_including(name: "A+B", type: "RichText", content: "AlphaBeta")
         )
       end
+
       it "handles multi levels pointer cards" do
         inner_pointer = create "inner pointer", type: :pointer, content: "T"
         expect(export_pointer([inner_pointer.name, "A+B"])).to include(

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

@@ -54,34 +54,34 @@ describe Card::Set::All::Initialize do
 
   describe "module inclusion" do
     context "(search)" do
-      before do
-        @c = Card.new type: "Search", name: "Module Inclusion Test Card"
+      let :c do
+        Card.new type: "Search", name: "Module Inclusion Test Card"
       end
 
       it "happens after new" do
-        expect(@c.respond_to?(:query)).to be_truthy
+        expect(c).to respond_to(:query)
       end
 
       it "happens after save" do
-        expect(@c.respond_to?(:query)).to be_truthy
-        @c.save!
-        expect(@c.respond_to?(:query)).to be_truthy
+        expect(c).to respond_to(:query)
+        c.save!
+        expect(c).to respond_to(:query)
       end
 
       it "happens after fetch" do
-        @c.save!
-        c = Card.fetch(@c.name)
-        expect(c.respond_to?(:query)).to be_truthy
+        c.save!
+        f = Card.fetch(c.name)
+        expect(f).to respond_to(:query)
       end
     end
 
     context "(pointer)" do
       it "happens with explicit pointer setting" do
-        expect(Card.new(type: "Pointer").respond_to?(:add_item)).to be_truthy
+        expect(Card.new(type: "Pointer")).to respond_to(:add_item)
       end
 
       it "happens with implicit pointer setting (from template)" do
-        expect(Card.new(name: "Home+*cc").respond_to?(:add_item)).to be_truthy
+        expect(Card.new(name: "Home+*cc")).to respond_to(:add_item)
       end
     end
   end

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

@@ -1,4 +1,208 @@
 RSpec.describe Card::Set::All::NameEvents do
+  include CardExpectations
+
+  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: descendant_ids.sort
+    }
+  end
+
+  def assert_rename card, new_name
+    card = card_to_rename card
+    attrs_before = name_invariant_attributes(card)
+    actions_count_before = card.actions.count
+    old_name = card.name
+
+    update! card.name, name: new_name, update_referers: true
+    expect_action_added card, actions_count_before
+    expect_old_name_cleared old_name
+    expect_successful_rename card, attrs_before
+  end
+
+  def expect_action_added card, actions_count_before
+    expect(card.actions.count).to eq(actions_count_before + 1)
+  end
+
+  def expect_old_name_cleared old_name
+    expect(Card.cache.read(old_name)).to eq(nil)
+  end
+
+  def expect_successful_rename card, attrs_before
+    expect(name_invariant_attributes(card)).to eq(attrs_before)
+    expect(Card[card.name]).to eq(card)
+  end
+
+  def card_to_rename card
+    return card unless card.is_a? String
+
+    Card[card].refresh || raise("Couldn't find card named #{card}")
+  end
+
+  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
+
+  it "clears cache for old name" do
+    Card["A"]
+    Card["A+B"]
+    assert_rename "A", "AAA"
+    expect(Card.cache.read("a")).to be_nil
+    expect(Card.cache.read("a+b")).to be_nil
+  end
+
+  it "wipes old references by default" do
+    update "Menu", name: "manure"
+    expect(Card["manure"].references_in.size).to eq(0)
+  end
+
+  it "picks up new references" do
+    expect(Card["Z"].references_in.size).to eq(2)
+    assert_rename "Z", "Mister X"
+    expect(Card["Mister X"].references_in.size).to eq(3)
+  end
+
+  it "handles name variants" do
+    assert_rename "B", "b"
+  end
+
+  it "handles plus cards renamed to simple" do
+    assert_rename "A+B", "K"
+  end
+
+  it "handles flipped parts" do
+    assert_rename "A+B", "B+A"
+  end
+
+  it "fails if card exists" do
+    expect { update "T", name: "A+B" }.to raise_error(/Name must be unique/)
+  end
+
+  it "fails if used as tag" do
+    expect { update "B", name: "A+D" }.to raise_error(/Name must be unique/)
+  end
+
+  it "updates descendants" do
+    old_names = %w[One+Two One+Two+Three Four+One Four+One+Five]
+    new_names = %w[Uno+Two Uno+Two+Three Four+Uno Four+Uno+Five]
+    card_list = old_names.map { |name| Card[name] }
+
+    expect(card_list.map(&:name)).to eq old_names
+    update "One", name: "Uno"
+    expect(card_list.map(&:id).map(&:cardname)).to eq new_names
+  end
+
+  it "fails if name is invalid" do
+    expect { update "T", name: "" }
+      .to raise_error(/Name can't be blank/)
+  end
+
+  example "simple to simple" do
+    assert_rename "A", "Alephant"
+  end
+
+  example "simple to junction with create" do
+    assert_rename "T", "C+J"
+  end
+
+  example "reset key" do
+    c = Card["basicname"]
+    update "basicname", name: "banana card"
+    expect(c.key).to eq("banana_card")
+    expect(Card["Banana Card"]).not_to be_nil
+  end
+
+  it "does not fail when updating inaccessible referer" do
+    Card.create! name: "Joe Card", content: "Whattup"
+    Card::Auth.as "joe_admin" do
+      Card.create! name: "Admin Card", content: "[[Joe Card]]"
+    end
+
+    c = Card["Joe Card"]
+    c.update! name: "Card of Joe", update_referers: true
+    assert_equal "[[Card of Joe]]", Card["Admin Card"].content
+  end
+
+  it "test_rename_should_update_structured_referer" do
+    Card::Auth.as_bot do
+      c = Card.create! name: "Pit"
+      Card.create! name: "Orange", type: "Fruit", content: "[[Pit]]"
+      Card.create! name: "Fruit+*type+*structure", content: "this [[Pit]]"
+
+      assert_equal "this [[Pit]]", Card["Orange"].content
+      c.update! name: "Seed", update_referers: true
+      assert_equal "this [[Seed]]", Card["Orange"].content
+    end
+  end
+
+  it "handles plus cards that have children" do
+    assert_rename Card["a+b"], "e+f"
+  end
+
+  context "with self references" do
+    example "renaming card with self link should nothang" do
+      pre_content = Card["self_aware"].content
+      update "self aware", name: "buttah", update_referers: true
+      expect_card("Buttah").to have_content(pre_content)
+    end
+
+    it "renames card without updating references" do
+      pre_content = Card["self_aware"].content
+      update "self aware", name: "Newt", update_referers: false
+      expect_card("Newt").to have_content(pre_content)
+    end
+  end
+
+  context "with references" do
+    it "updates nests" do
+      update "Blue", name: "Red", update_referers: true
+      expect_card("blue includer 1").to have_content("{{Red}}")
+      expect_card("blue includer 2").to have_content("{{Red|closed;other:stuff}}")
+    end
+
+    it "updates nests when renaming to plus" do
+      update "Blue", name: "blue includer 1+color", update_referers: true
+      expect_card("blue includer 1").to have_content("{{blue includer 1+color}}")
+    end
+
+    it "reference updates on case variants" do
+      update "Blue", name: "Red", update_referers: true
+      expect_card("blue linker 1").to have_content("[[Red]]")
+      expect_card("blue linker 2").to have_content("[[Red]]")
+    end
+
+    it "handles link to and nest of same card" do
+      update "blue linker 1", content: "[[Blue]] is {{Blue|name}}"
+      update "Blue", name: "Red", update_referers: true
+      expect_card("blue linker 1").to have_content("[[Red]] is {{Red|name}}")
+    end
+
+    example "reference updates plus to simple" do
+      assert_rename Card["A+B"], "schmuck"
+      expect_card("X").to have_content("[[A]] [[schmuck]] [[T]]")
+    end
+
+    it "substitutes name part" do
+      c1 = Card["A+B"]
+      assert_rename Card["B"], "buck"
+      expect(Card.find(c1.id).name).to eq "A+buck"
+    end
+  end
+
   describe "event: set_name" do
     it "handles case variants" do
       c = Card.create! name: "chump"