card 1.101.1 → 1.101.6

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

@@ -1,17 +0,0 @@
-#require '#benchmark/ips'
-#
-#RSpec.describe Card::Set::All::I18n do
-#  it "can access scope" do
-#    expect(Card["A"].format.t(:key))
-#      .to eq "translation missing: en.mod.spec.set.all.i18n_spec.key"
-#  end
-#
-#  it "gets correct text" do
-#    x.report('with auto_scope') do
-#      Card[:admin_info].format(:html).warning_list_with_auto_scope([])
-#    end
-#    x.report('with explicit scope') do
-#      Card[:admin_info].format(:html).warning_list([])
-#    end
-#  end
-#end

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

@@ -1,101 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-RSpec.describe Card::Set::All::Pattern do
-  describe :set_names do
-    it "returns self, type, all for simple cards" do
-      Card::Auth.as_bot do
-        card = Card.new(name: "AnewCard")
-        expect(card.set_names).to eq(["RichText+*type", "*all"])
-        card.save!
-        card = Card.fetch("AnewCard")
-        expect(card.set_names).to eq(["AnewCard+*self", "RichText+*type", "*all"])
-      end
-    end
-
-    it "returns set names for simple star cards" do
-      Card::Auth.as_bot do
-        expect(Card.fetch("*update").set_names).to eq(
-          [
-            "*update+*self", "*star", "Setting+*type", "*all"
-          ]
-        )
-      end
-    end
-
-    it "returns set names for junction cards" do
-      Card::Auth.as_bot do
-        expect(Card.new(name: "Iliad+author").set_names).to eq(
-          [
-            "Book+author+*type plus right", "author+*right", "RichText+*type",
-            "*all plus", "*all"
-          ]
-        )
-      end
-    end
-
-    it "returns set names for compound star cards", as_bot: true do
-      expect(Card.new(name: "Iliad+*to").set_names).to eq(
-        [
-          "Book+*to+*type plus right", "*to+*right", "*rstar",
-          "List+*type", "*all plus", "*all"
-        ]
-      )
-    end
-
-    it "returns set names for rule cards", as_bot: true do
-      expect(Card.new(name: "*all+*create").set_names).to eq(
-        [
-          "Set+*create+*type plus right", "*create+*right", "*rule", "*rstar",
-          "List+*type", "*all plus", "*all"
-        ]
-      )
-    end
-
-    # right place for this?  really need more prototype tests...
-    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).to include("Fruit+flavor+*type plus right")
-      end
-    end
-  end
-
-  describe :rule_set_keys do
-    it "returns correct set names for new cards" do
-      card = Card.new name: "AnewCard"
-      expect(card.rule_set_keys).to eq(["#{Card::BasicID}+type", "all"])
-    end
-  end
-
-  describe :safe_set_keys do
-    it "returns css names for simple star cards" do
-      Card::Auth.as_bot do
-        card = Card.new(name: "*AnewCard")
-        expect(card.safe_set_keys).to eq("ALL TYPE-rich_text STAR")
-        card.save!
-        card = Card.fetch("*AnewCard")
-        expect(card.safe_set_keys).to eq("ALL TYPE-rich_text STAR SELF-Xanew_card")
-      end
-    end
-
-    it "returns set names for junction cards" do
-      card = Card.new(name: "Iliad+author")
-      expect(card.safe_set_keys).to eq(
-        "ALL ALL_PLUS TYPE-rich_text RIGHT-author TYPE_PLUS_RIGHT-book-author"
-      )
-      card.save!
-      card = Card.fetch("Iliad+author")
-      expect(card.safe_set_keys).to eq(
-        "ALL ALL_PLUS TYPE-rich_text RIGHT-author TYPE_PLUS_RIGHT-book-author "\
-        "SELF-iliad-author"
-      )
-    end
-  end
-
-  describe :label do
-    it "returns label for name" do
-      expect(Card.new(name: "address+*right").label)
-        .to eq(%(All "+address" cards))
-    end
-  end
-end

data/mod/core/spec/set/all/permissions/reader_rules_spec.rb

@@ -1,166 +0,0 @@
-describe Card::Set::All::Permissions do
-  describe "reader rules" do
-    before do
-      @perm_card = Card.new name: "Home+*self+*read", type: "Pointer",
-                            content: "[[Anyone Signed In]]"
-    end
-
-    it "is *all+*read by default" do
-      card = Card.fetch("Home")
-      expect(card.read_rule_id).to eq(Card.fetch("*all+*read").id)
-      expect(card.who_can(:read)).to eq([Card::AnyoneID])
-      Card::Auth.as(:anonymous) { expect(card.ok?(:read)).to be_truthy }
-    end
-
-    it "updates to role ('Anyone Signed In')" do
-      name = @perm_card.name
-      Card::Auth.as_bot { @perm_card.save! }
-      pc = Card[name]
-      card = Card["Home"]
-      # warn "card #{name}, #{card.inspect}, #{pc.inspect}"
-      expect(pc).to be
-      expect(card.read_rule_id).to eq(pc.id)
-      expect(card.who_can(:read)).to eq([Card::AnyoneSignedInID])
-      Card::Auth.as(:anonymous) { expect(card.ok?(:read)).to be_falsey }
-    end
-
-    it "updates to user ('Joe Admin')" do
-      @perm_card.db_content = "[[Joe Admin]]"
-      Card::Auth.as_bot { @perm_card.save! }
-
-      card = Card.fetch("Home")
-      expect(card.read_rule_id).to eq(@perm_card.id)
-      expect(card.who_can(:read)).to eq([Card["joe_admin"].id])
-      Card::Auth.as(:anonymous) { expect(card.ok?(:read)).to be_falsey }
-      Card::Auth.as("joe_user")  { expect(card.ok?(:read)).to be_falsey }
-      Card::Auth.as("joe_admin") { expect(card.ok?(:read)).to be_truthy  }
-      Card::Auth.as_bot         { expect(card.ok?(:read)).to be_truthy  }
-    end
-
-    context "when more specific (self) rule is deleted" do
-      it "reverts to more general rule"  do
-        Card::Auth.as_bot do
-          @perm_card.save!
-          @perm_card.delete!
-        end
-        card = Card.fetch("Home")
-        expect(card.read_rule_id).to eq(Card.fetch("*all+*read").id)
-      end
-    end
-
-    context "when more specific (right) rule is deleted" do
-      it "reverts to more general rule" do
-        pc = nil
-        Card::Auth.as_bot do
-          pc = Card.create name: "B+*right+*read", type: "Pointer",
-                           content: "[[Anyone Signed In]]"
-        end
-        expect(pc).to be
-        card = Card.fetch("A+B")
-        expect(card.read_rule_id).to eq(pc.id)
-        # important to re-fetch to catch issues
-        # with detecting change in trash status.
-        pc = Card.fetch(pc.name)
-        Card::Auth.as_bot { pc.delete }
-        card = Card.fetch("A+B")
-        expect(card.read_rule_id).to eq(Card.fetch("*all+*read").id)
-      end
-    end
-
-    context "when more specific rule is renamed" do
-      it "reverts to more general rule" do
-        Card::Auth.as_bot do
-          @perm_card.save!
-          @perm_card = Card[@perm_card.name]
-          @perm_card.name = "Something else+*self+*read"
-          @perm_card.save!
-        end
-
-        card = Card.fetch("Home")
-        expect(card.read_rule_id).to eq(Card.fetch("*all+*read").id)
-      end
-    end
-
-    it "gets not overruled by a more general rule added later" do
-      Card::Auth.as_bot do
-        @perm_card.save!
-        c = Card.fetch("Home")
-        c.type_id = Card::PhraseID
-        c.save!
-        Card.create name: "Phrase+*type+*read", type: "Pointer",
-                    content: "[[Joe User]]"
-      end
-
-      card = Card.fetch("Home")
-      expect(card.read_rule_id).to eq(@perm_card.id)
-    end
-
-    it "gets updated when trunk type change makes " \
-       "type-plus-right apply / unapply" do
-      @perm_card.name = "Phrase+B+*type plus right+*read"
-      Card::Auth.as_bot { @perm_card.save! }
-      expect(Card.fetch("A+B").read_rule_id).to eq(Card.fetch("*all+*read").id)
-      c = Card.fetch("A")
-      c.type_id = Card::PhraseID
-      c.save!
-      expect(Card.fetch("A+B").read_rule_id).to eq(@perm_card.id)
-    end
-
-    it "works with relative settings" do
-      Card::Auth.as_bot do
-        @perm_card.save!
-        all_plus = Card.fetch "*all plus+*read", new: { content: "_left" }
-        all_plus.save
-      end
-      c = Card.new(name: "Home+Heart")
-      expect(c.who_can(:read)).to eq([Card::AnyoneSignedInID])
-      expect(c.permission_rule_id(:read)).to eq(@perm_card.id)
-      c.save
-      expect(c.read_rule_id).to eq(@perm_card.id)
-    end
-
-    it "gets updated when relative settings change" do
-      Card::Auth.as_bot do
-        all_plus = Card.fetch "*all plus+*read", new: { content: "_left" }
-        all_plus.save
-      end
-      c = Card.new(name: "Home+Heart")
-      expect(c.who_can(:read)).to eq([Card::AnyoneID])
-      expect(c.permission_rule_id(:read)).to(
-        eq(Card.fetch("*all+*read").id)
-      )
-      c.save
-      expect(c.read_rule_id).to eq(Card.fetch("*all+*read").id)
-      Card::Auth.as_bot { @perm_card.save! }
-      c2 = Card.fetch("Home+Heart")
-      expect(c2.who_can(:read)).to eq([Card::AnyoneSignedInID])
-      expect(c2.read_rule_id).to eq(@perm_card.id)
-      expect(Card.fetch("Home+Heart").read_rule_id).to(
-        eq(@perm_card.id)
-      )
-      Card::Auth.as_bot { @perm_card.delete }
-      expect(Card.fetch("Home").read_rule_id).to eq(Card.fetch("*all+*read").id)
-      expect(Card.fetch("Home+Heart").read_rule_id).to(
-        eq(Card.fetch("*all+*read").id)
-      )
-    end
-
-    it "insures that class overrides work with relative settings" do
-      Card::Auth.as_bot do
-        all_plus = Card.fetch "*all plus+*read", new: { content: "_left" }
-        all_plus.save
-        Card::Auth.as_bot { @perm_card.save! }
-        c = Card.create(name: "Home+Heart")
-        expect(c.read_rule_id).to eq(@perm_card.id)
-        r = Card.create name: "Heart+*right+*read", type: "Pointer",
-                        content: "[[Administrator]]"
-        expect(Card.fetch("Home+Heart").read_rule_id).to eq(r.id)
-      end
-    end
-
-    it "works on virtual+virtual cards" do
-      c = Card.fetch("Number+*type+by name")
-      expect(c.ok?(:read)).to be_truthy
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-RSpec.describe Card::Set::All::References do
-  it "replaces references should work on nests inside links" do
-    card = Card.create! name: "ref test", content: "[[test_card|test{{test}}]]"
-    assert_equal "[[test_card|test{{best}}]]",
-                 card.replace_reference_syntax("test", "best")
-  end
-
-  describe "#referers" do
-    it "returns all cards that refer to card" do
-      expect(Card["Blue"].referers.map(&:name))
-        .to contain_exactly(
-          "blue includer 1", "blue includer 2", "blue linker 1", "blue linker 2"
-        )
-    end
-  end
-
-  describe "#nesters" do
-    it "returns all cards that nest card" do
-      expect(Card["Blue"].nesters.map(&:name))
-        .to contain_exactly("blue includer 1", "blue includer 2")
-    end
-  end
-
-  describe "#referee" do
-    it "returns all cards that card nests" do
-      expect(Card["Y"].referees.map(&:name)).to contain_exactly("A", "A+B", "B", "T")
-    end
-
-    it "returns all cards that card links to and their ancestors" do
-      # NOTE: B is not directly referred to; the reference is implied by the link to A+B
-      expect(Card["X"].referees.map(&:name)).to contain_exactly("A", "A+B", "B", "T")
-    end
-  end
-
-  describe "#nestee" do
-    it "returns all cards that card nests" do
-      expect(Card["Y"].nestees.map(&:name)).to contain_exactly("A", "A+B", "B", "T")
-    end
-
-    it "returns all cards that card links to" do
-      expect(Card["X"].nestees.map(&:name)).to eq([])
-    end
-  end
-
-  describe "event :update_referer_content" do
-    it "handles self 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

@@ -1,189 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-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: descendant_ids.sort
-    }
-  end
-
-  def assert_rename card, new_name
-    if card.is_a? String
-      card = Card[card].refresh || raise("Couldn't find card named #{card}")
-    end
-    attrs_before = name_invariant_attributes(card)
-    actions_count_before = card.actions.count
-    update! card.name, name: new_name, update_referers: true
-    expect(card.actions.count).to eq(actions_count_before + 1)
-    assert_equal attrs_before, name_invariant_attributes(card)
-    assert_equal new_name, card.name
-    assert Card[new_name]
-  end
-end
-
-RSpec.describe Card::Set::All::Rename do
-  include RenameMethods
-  include CardExpectations
-
-  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
-    assert_rename "Menu", "manure"
-    expect(Card["Menu"]).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 "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 "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
-end