card 1.18.6 → 1.19.0

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

@@ -0,0 +1,9 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Set::All::References do
+  it "should replace 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
+end

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

@@ -0,0 +1,247 @@
+# -*- 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
+
+describe Card do
+  context "when there is a general toc rule of 2" do
+    before do
+      Card::Auth.as_bot do
+        Card.create! name: "Basic+*type+*table of contents", content: "2"
+      end
+      expect(@c1 = Card["Onne Heading"]).to be
+      expect(@c2 = Card["Twwo Heading"]).to be
+      expect(@c3 = Card["Three Heading"]).to be
+      expect(@c1.type_id).to eq(Card::BasicID)
+      expect(@rule_card = @c1.rule_card(:table_of_contents)).to be
+    end
+
+    describe ".rule" do
+      it "should have 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 "should not render for 'Onne Heading'" do
+        expect(@c1.format.render_open_content).not_to match(/Table of Contents/)
+      end
+      it "should render for 'Twwo Heading'" do
+        expect(@c2.format.render_open_content).to match(/Table of Contents/)
+      end
+      it "should render for 'Three Heading'" do
+        expect(@c3.format.render_open_content).to match(/Table of Contents/)
+      end
+    end
+
+    describe ".rule_card" do
+      it "get the same card without the * and singular" do
+        expect(@c1.rule_card(:table_of_contents)).to eq(@rule_card)
+      end
+    end
+
+    describe ".related_sets" do
+      it "has 1 set (right) for a simple card" do
+        sets = Card["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 = Card["Cardtype A"].related_sets.map { |s| s[0] }
+        expect(sets).to eq(["Cardtype A+*type", "Cardtype A+*right"])
+      end
+      # it "should show type plus right sets when they exist" do
+      #   Card::Auth.as_bot do
+      #     Card.create name: 'Basic+A+*type plus right', content: ''
+      #   end
+      #   sets = Card['A'].related_sets
+      #   sets.should == ['A+*self', 'A+*right', 'Basic+A+*type plus right']
+      # end
+      # it "should show type plus right sets when they exist, and type" do
+      #   Card::Auth.as_bot do
+      #     Card.create name: 'Basic+Cardtype A+*type plus right', content: ''
+      #   end
+      #   sets = Card['Cardtype A'].related_sets
+      #   sets.should == ['Cardtype A+*self', 'Cardtype A+*type',
+      #     'Cardtype A+*right', 'Basic+Cardtype A+*type plus right']
+      # end
+      it "is empty for a non-simple card" do
+        sets = Card["A+B"].related_sets.map { |s| s[0] }
+        expect(sets).to eq([])
+      end
+    end
+    #     # class methods
+    #     describe ".default_rule" do
+    #       it 'should have 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
+      expect(@c1 = Card["Onne Heading"]).to be
+      expect(@c2 = Card["Twwo Heading"]).to be
+      expect(@c1.type_id).to eq(Card::BasicID)
+      expect(@rule_card = @c1.rule_card(:table_of_contents)).to be
+      @rule_card.content = "1"
+    end
+
+    describe ".rule" do
+      it "should have 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 "should not render toc for 'Onne Heading'" do
+        expect(@c1.format.render_open_content).to match(/Table of Contents/)
+      end
+      it "should render toc for 'Twwo Heading'" do
+        expect(@c2.format.render_open_content).to match(/Table of Contents/)
+      end
+      it "should 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.format.render_open_content).not_to match(/Table of Contents/)
+      end
+    end
+  end
+
+  context "when I use CardtypeE cards" do
+    before do
+      Card::Auth.as_bot do
+        @c1 = Card.create name: "toc1", type: "CardtypeE",
+                          content: Card["Onne Heading"].content
+        @c2 = Card.create name: "toc2", type: "CardtypeE",
+                          content: Card["Twwo Heading"].content
+        @c3 = Card.create name: "toc3", type: "CardtypeE",
+                          content: Card["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 "should have 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 "should not render for 'Onne Heading'" do
+        expect(@c1.format.render_open_content).not_to match(/Table of Contents/)
+      end
+      it "should render for 'Twwo Heading'" do
+        expect(@c2.format.render_open_content).not_to match(/Table of Contents/)
+      end
+      it "should render for 'Three Heading'" do
+        expect(@c3.format.render_open_content).not_to match(/Table of Contents/)
+      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 'should have 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
+        Card.create! name: "Basic+*type+*table of contents", content: "2"
+        @c1 = Card.create! name: "toc1", type: "CardtypeE",
+                           content: Card["Onne Heading"].content
+        @c2 = Card.create! name: "toc2", content: Card["Twwo Heading"].content
+        @c3 = Card.create! name: "toc3", content: Card["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 = Card["CardtypeE+*type+*table of content"])
+          c.content = "2"
+          c.save!
+        else
+          Card.create! name: "CardtypeE+*type+*table of content", content: "2"
+        end
+      end
+    end
+    it "should take on new setting value" do
+      c = Card["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 "should not render for 'Onne Heading'" do
+        expect(@c1.format.render_open_content).not_to match(/Table of Contents/)
+      end
+      it "should render for 'Twwo Heading'" do
+        expect(@c2.rule(:table_of_contents)).to eq("2")
+        expect(@c2.format.render_open_content).to match(/Table of Contents/)
+      end
+      it "should render for 'Three Heading'" do
+        expect(@c3.format.render_open_content).to match(/Table of Contents/)
+      end
+    end
+  end
+  # end
+
+  context "when I change the general toc setting to 1" do
+    before do
+      expect(@c1 = Card["Onne Heading"]).to be
+      # FIXME: CardtypeE should inherit from *default => Basic
+      # @c2 = Card.create name: 'toc2', type: "CardtypeE",
+      #                   content: Card['Twwo Heading'].content
+      expect(@c2 = Card["Twwo Heading"]).to be
+      expect(@c1.type_id).to eq(Card::BasicID)
+      expect(@rule_card = @c1.rule_card(:table_of_contents)).to be
+      @rule_card.content = "1"
+    end
+
+    describe ".rule" do
+      it "should have 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 "should not render toc for 'Onne Heading'" do
+        expect(@c1.format.render_open_content).to match(/Table of Contents/)
+      end
+      it "should render toc for 'Twwo Heading'" do
+        expect(@c2.format.render_open_content).to match(/Table of Contents/)
+      end
+      it "should not render for 'Twwo Heading' when changed to 3" do
+        @rule_card.content = "3"
+        expect(@c2.format.render_open_content).not_to match(/Table of Contents/)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Set::All::Rules do
+  before do
+    Card::Auth.current_id = Card::WagnBotID
+  end
+
+  describe "setting data setup" do
+    it "should make 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+*add help", content: "authorize"
+      add_help_rule = Card.new(type: "Book").rule(:add_help, fallback: :help)
+      expect(add_help_rule).to eq("authorize")
+    end
+
+    it "retrieves default values" do
+      # Card.create name: 'all Basic cards', type: 'Set',
+      #            content: "{\"type\": \"Basic\'}'
+      # defaults should work when other Sets are present
+      assert Card.create(name: "*all+*add help", content: "lobotomize")
+      # Card.default_rule(:add_help, fallback: :help).should == 'lobotomize'
+      add_help_rule = Card.new(type: "Basic").rule(:add_help, fallback: :help)
+      expect(add_help_rule).to eq("lobotomize")
+    end
+
+    it "retrieves single values" do
+      Card.create! name: "banana+*self+*help", content: "pebbles"
+      expect(Card["banana"].rule(:help)).to eq("pebbles")
+    end
+
+    context "with fallback" do
+      before do
+        Card.create name: "*all+*help", content: "edit any kind of card"
+      end
+      subject { Card.new(type: "Book").rule(:add_help, fallback: :help) }
+      it "retrieves default setting" do
+        expect(subject).to eq("edit any kind of card")
+      end
+
+      it "retrieves primary setting" do
+        Card.create name: "*all+*add help", content: "add any kind of card"
+        expect(subject).to eq("add any kind of card")
+      end
+
+      it "retrieves more specific default setting" do
+        Card.create name: "*all+*add help", content: "add any kind of card"
+        Card.create name: "*Book+*type+*help", content: "edit a Book"
+        expect(subject).to eq("add any kind of card")
+      end
+    end
+  end
+
+  describe "#setting_codenames_by_group" do
+    before do
+      @pointer_settings = [: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
+
+    it "returns pointer-specific setting names for pointer card" do
+      c = Card.fetch "Fruit+*type+*create+*self", new: {}
+      snbg = c.setting_codenames_by_group
+      expect(snbg[:pointer]).to eq(@pointer_settings)
+    end
+  end
+
+  describe "user specific rules" do
+    before do
+      Card::Auth.current_id = Card.fetch("Joe User").id
+    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").rule(:follow)).to eq("[[*always]]")
+    end
+
+    it "retrieves user indepedent Set based value" do
+      Card::Auth.as_bot do
+        Card.create name: "Book+*type+*all+*follow", content: "[[Home]]"
+      end
+      expect(Card.new(type: "Book").rule(: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").rule(: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.current_id = Card.fetch("Joe Admin").id
+          Card.create(name: "Book+*type+Joe Admin+*follow", content: "[[Home]]")
+          user_ids = Card.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

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

@@ -0,0 +1,119 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Set::All::Templating do
+  describe "#structurees" do
+    it "for User+*type+*structure should return all Users" do
+      Card::Auth.as_bot do
+        c = Card.create name: "User+*type+*structure"
+        users
+
+        expect(c.structuree_names.sort).to eq(
+          ["Big Brother", "Joe Admin", "Joe Camel", "Joe User", "John",
+           "Narcissist", "No Count", "Optic fan", "Sample User", "Sara",
+           "Sunglasses fan", "u1", "u2", "u3"]
+        )
+      end
+    end
+  end
+
+  describe "with right structure" do
+    before do
+      Card::Auth.as_bot do
+        @bt = Card.create! name: "birthday+*right+*structure",
+                           type: "Date",
+                           content: "Today!"
+      end
+      @jb = Card.create! name: "Jim+birthday"
+    end
+
+    it "should have default content" do
+      expect(@jb.format._render_raw).to eq("Today!")
+    end
+
+    it "should change type and content with template" do
+      Card::Auth.as_bot do
+        @bt.content = "Tomorrow"
+        @bt.type = "Phrase"
+        @bt.save!
+      end
+      jb = @jb.refresh true
+      expect(jb.format.render(:raw)).to eq("Tomorrow")
+      expect(jb.type_id).to eq(Card::PhraseID)
+    end
+
+    it "should have type and content overridden by (new) type_plus_right set" do
+      Card::Auth.as_bot do
+        Card.create! name: "Basic+birthday+*type plus right+*structure",
+                     type: "PlainText",
+                     content: "Yesterday"
+      end
+      jb = @jb.refresh true
+      expect(jb.raw_content).to eq("Yesterday")
+      expect(jb.type_id).to eq(Card::PlainTextID)
+    end
+  end
+
+  describe "with right default" do
+    before do
+      Card::Auth.as_bot do
+        @bt = Card.create! name: "birthday+*right+*default",
+                           type: "Date",
+                           content: "Today!"
+      end
+      @bb = Card.new name: "Bob+birthday"
+      @jb = Card.create! name: "Jim+birthday"
+    end
+
+    it "should have default cardtype" do
+      expect(@jb.type_code).to eq(:date)
+    end
+
+    it "should have default content" do
+      expect(Card["Jim+birthday"].content).to eq("Today!")
+    end
+
+    it "should apply to new cards" do
+      pb = Card.new name: "Pete+birthday"
+      expect(pb.raw_content).to eq("Today!")
+      expect(pb.content).to eq("Today!")
+    end
+  end
+
+  describe "with type structure" do
+    before do
+      Card::Auth.as_bot do
+        @dt = Card.create! name: "Date+*type+*structure",
+                           type: "Basic",
+                           content: "Tomorrow"
+      end
+    end
+
+    it "should return templated content even if content is passed in" do
+      new_date_card = Card.new type: "Date", content: ""
+      expect(new_date_card.format._render(:raw)).to eq("Tomorrow")
+    end
+
+    describe "and right structure" do
+      before do
+        Card::Auth.as_bot do
+          Card.create name: "Jim+birthday", content: "Yesterday"
+          @bt = Card.create! name: "birthday+*right+*structure",
+                             type: "Date",
+                             content: "Today"
+        end
+      end
+
+      it "*right setting should override *type setting" do
+        expect(Card["Jim+birthday"].raw_content).to eq("Today")
+      end
+
+      it "should defer to normal content " \
+         "when *structure rule's content is (exactly) '_self'" do
+        Card::Auth.as_bot do
+          Card.create! name: "Jim+birthday+*self+*structure", content: "_self"
+        end
+        expect(Card["Jim+birthday"].raw_content).to eq("Yesterday")
+      end
+    end
+  end
+end