card 1.101.0 → 1.101.5

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

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

@@ -1,100 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-RSpec.describe Card::Set::All::Rules do
-  before do
-    Card::Auth.signin Card::WagnBotID
-  end
-
-  describe "setting data setup" do
-    it "makes Set of +*type" do
-      Card.create! name: "SpeciForm", type: "Cardtype"
-      expect(Card.create!(name: "SpeciForm+*type").type_code).to eq(:set)
-    end
-  end
-
-  describe "#rule" do
-    it "retrieves Set based value" do
-      Card.create name: "Book+*type+*help", content: "authorize"
-      help_rule = Card.new(type: "Book").rule(:help)
-      expect(help_rule).to eq("authorize")
-    end
-
-    it "retrieves single values" do
-      Card.create! name: "banana+*self+*help", content: "pebbles"
-      expect(Card["banana"].rule(:help)).to eq("pebbles")
-    end
-  end
-
-  describe "#setting_codenames_by_group" do
-    before do
-      @pointer_settings = %i[options options_label input]
-    end
-    it "doesn't fail on nonexistent trunks" do
-      codenames = Card.new(name: "foob+*right").setting_codenames_by_group
-      expect(codenames.class).to eq(Hash)
-    end
-
-    it "returns universal setting names for non-pointer set" do
-      skip "Different api, we should just put the tests in a new spec for that"
-      snbg = Card.fetch("*star").setting_codenames_by_group
-      # warn "snbg #{snbg.class} #{snbg.inspect}"
-      expect(snbg.keys.length).to eq(4)
-      expect(snbg.keys.first).to be_a Symbol
-      expect(snbg.keys.member?(:pointer)).not_to be_truthy
-    end
-  end
-
-  describe "user specific rules" do
-    before do
-      Card::Auth.signin "Joe User"
-    end
-
-    it "user rule is recognized as rule" do
-      Card::Auth.as_bot do
-        card = Card.create name: "Book+*type+Joe User+*follow",
-                           content: "[[*always]]"
-        expect(card.is_rule?).to be_truthy
-      end
-    end
-
-    it "retrieves Set based value" do
-      Card::Auth.as_bot do
-        Card.create name: "Book+*type+Joe User+*follow", content: "[[*always]]"
-      end
-      expect(Card.new(type: "Book").preference(:follow)).to eq("[[*always]]")
-    end
-
-    it "retrieves user independent Set based value" do
-      Card::Auth.as_bot do
-        Card.create name: "Book+*type+*all+*follow", content: "[[Home]]"
-      end
-      expect(Card.new(type: "Book").preference(:follow)).to eq("[[Home]]")
-    end
-
-    it "uses *all user rule when no super.s"
-
-    it "user-specific value overwrites user-independent value" do
-      Card::Auth.as_bot do
-        Card.create name: "Book+*type+Joe User+*follow", content: "[[*never]]"
-        Card.create name: "Book+*type+*all+*follow", content: "[[*always]]"
-      end
-      expect(Card.new(type: "Book").preference(:follow)).to eq("[[*never]]")
-    end
-
-    describe "#all_user_ids_with_rule_for" do
-      it "returns all user with values for the given Set and rule" do
-        Card::Auth.as_bot do
-          Card.create(name: "Book+*type+Joe User+*follow", content: "[[Home]]")
-          Card::Auth.signin "Joe Admin"
-          Card.create(name: "Book+*type+Joe Admin+*follow", content: "[[Home]]")
-          user_ids = Card::Rule.all_user_ids_with_rule_for(
-            Card.fetch("Book+*type"), :follow
-          )
-          expect(user_ids.sort).to eq(
-            [Card["Joe User"].id, Card["Joe Admin"].id].sort
-          )
-        end
-      end
-    end
-  end
-end