card 1.18.6 → 1.19.0

data/mod/01_core/spec/set/all/references_spec.rb

@@ -1,9 +0,0 @@
-# -*- 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/01_core/spec/set/all/rules2_spec.rb

@@ -1,238 +0,0 @@
-# -*- 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 { Card.create name: 'Basic+A+*type plus right', content: '' }
-      #        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 { Card.create name: 'Basic+Cardtype A+*type plus right', content: '' }
-      #        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
-          c = 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/01_core/spec/set/all/rules_spec.rb

@@ -1,137 +0,0 @@
-# -*- 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/01_core/spec/set/all/templating_spec.rb

@@ -1,119 +0,0 @@
-# -*- 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