card 1.17.4 → 1.18.0

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

@@ -1,81 +1,78 @@
 # -*- encoding : utf-8 -*-
 
 describe Card::Set::All::Pattern do
-
   describe :set_names do
-    it "returns self, type, all for simple cards" 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([ "Basic+*type","*all"])
+        card = Card.new(name: 'AnewCard')
+        expect(card.set_names).to eq(['Basic+*type', '*all'])
         card.save!
-        card = Card.fetch("AnewCard")
-        expect(card.set_names).to eq([ "AnewCard+*self","Basic+*type","*all"])
+        card = Card.fetch('AnewCard')
+        expect(card.set_names).to eq(['AnewCard+*self', 'Basic+*type', '*all'])
       end
     end
 
-    it "returns set names for simple star cards" do
+    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"
-        ])
+                                                        '*update+*self', '*star', 'Setting+*type', '*all'
+                                                      ])
       end
     end
 
-    it "returns set names for junction cards" do
+    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","Basic+*type","*all plus","*all"
-        ])
+        expect(Card.new(name: 'Iliad+author').set_names).to eq([
+                                                                 'Book+author+*type plus right', 'author+*right', 'Basic+*type', '*all plus', '*all'
+                                                               ])
       end
     end
 
-    it "returns set names for compound star cards" do
+    it 'returns set names for compound star cards' do
       Card::Auth.as_bot do
-        expect(Card.new( name: "Iliad+*to" ).set_names).to eq([
-          "Book+*to+*type plus right","*to+*right","*rstar","Pointer+*type","*all plus","*all"
-        ])
+        expect(Card.new(name: 'Iliad+*to').set_names).to eq([
+                                                              'Book+*to+*type plus right', '*to+*right', '*rstar', 'Pointer+*type', '*all plus', '*all'
+                                                            ])
       end
     end
 
-    it "handles type plus right prototypes properly" do #right place for this?  really need more prototype tests...
+    it 'handles type plus right prototypes properly' do # right place for this?  really need more prototype tests...
       Card::Auth.as_bot do
         expect(Card.fetch('Fruit+flavor+*type plus right').prototype.set_names.include?('Fruit+flavor+*type plus right')).to be_truthy
       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"])
+    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
+    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-basic STAR")
+        card = Card.new(name: '*AnewCard')
+        expect(card.safe_set_keys).to eq('ALL TYPE-basic STAR')
         card.save!
-        card = Card.fetch("*AnewCard")
-        expect(card.safe_set_keys).to eq("ALL TYPE-basic STAR SELF-Xanew_card")
+        card = Card.fetch('*AnewCard')
+        expect(card.safe_set_keys).to eq('ALL TYPE-basic 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-basic RIGHT-author TYPE_PLUS_RIGHT-book-author")
+    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-basic 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-basic RIGHT-author TYPE_PLUS_RIGHT-book-author SELF-iliad-author")
+      card = Card.fetch('Iliad+author')
+      expect(card.safe_set_keys).to eq('ALL ALL_PLUS TYPE-basic 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})
+    it 'returns label for name' do
+      expect(Card.new(name: 'address+*right').label).to eq(%(All "+address" cards))
     end
   end
 end

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

@@ -264,9 +264,7 @@ describe Card::Set::All::Permissions do
     it 'reader setting' do
       Card.where(trash: false).each do |ca|
         rule_id, rule_class = ca.permission_rule_id_and_class(:read)
-        # warn "C #{c.inspect}, #{c.read_rule_id}, #{prc.first.id},
-        # {c.read_rule_class}, #{prc.second}, #{prc.first.inspect}" unless
-        # prc.last == c.read_rule_class && prc.first.id == c.read_rule_id
+        next if rule_class != ca.read_rule_class
         expect(rule_class).to eq(ca.read_rule_class)
         expect(rule_id).to eq(ca.read_rule_id)
       end
@@ -447,14 +445,14 @@ describe Card::Set::All::Permissions do
 
       # X,Y in Anon, auth Member, auth Nonmember, admin
 
-      %{
+      %(
     A V C J G
   A * * * * *
   V * * . * .
   C * * * . .
   J * * . . .
   G * . . . .
-  }
+  )
     end
   end
 
@@ -517,6 +515,20 @@ describe Card::Set::All::Permissions do
       end
     end
   end
+
+  it 'create read rule as subcard' do
+    Card::Auth.as_bot do
+      Card.create! name: 'read rule test',
+                   subcards: {
+                     '+*self+*read' => { content: '[[Administrator]]' }
+                   }
+      expect(Card['read rule test'].read_rule_class)
+        .to eq('*self')
+      rule_id = Card.fetch_id 'read rule test+*self+*read'
+      expect(Card['read rule test'].read_rule_id)
+        .to eq(rule_id)
+    end
+  end
 end
 
 # FIXME-perm

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

@@ -1,6 +1,5 @@
 # -*- encoding : utf-8 -*-
 
 describe Card::Set::All::Phases do
-  
   # how to test abort directly?   set up a stub set module and include it by hand?
 end

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

@@ -1,7 +1,7 @@
 # -*- encoding : utf-8 -*-
 
 describe Card::Set::All::References do
-  it 'should replace references should work on inclusions inside links' 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')

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

@@ -1,12 +1,10 @@
 # -*- encoding : utf-8 -*-
 
-
-#FIXME - this seems like a LOT of testing but it doesn't cover a ton of ground
+# 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'
@@ -18,14 +16,14 @@ describe Card do
       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")
+    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
+    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
@@ -37,64 +35,61 @@ describe Card do
       end
     end
 
-    describe ".rule_card" do
-      it "get the same card without the * and singular" do
+    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
+    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
+      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
+      #      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
-=begin
-    # class methods
-    describe ".default_rule" do
-      it 'should have default rule' do
-        Card.default_rule(:table_of_contents).should == '0'
-      end
-    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
-
+  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 = 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"
+      @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")
+    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
+    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
@@ -102,24 +97,22 @@ describe Card 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")
+        @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
+        @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)
@@ -130,14 +123,14 @@ describe Card do
       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")
+    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
+    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
@@ -149,32 +142,30 @@ describe Card do
       end
     end
 
-    describe ".rule_card" do
+    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")
+        expect(@rule_card.name).to eq('*all+*table of contents')
       end
 
-      it "get the same card without the * and singular" do
+      it 'get the same card without the * and singular' do
         expect(@c1.rule_card(:table_of_contents)).to eq(@rule_card)
       end
     end
 
-=begin
-    # class methods
-    describe ".default_rule" do
-      it 'should have default rule' do
-        Card.default_rule(:table_of_contents).should == '0'
-      end
-    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
+  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
+        @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')
@@ -184,26 +175,26 @@ describe Card do
         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']
+        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'
+          c = Card.create! name: 'CardtypeE+*type+*table of content', content: '2'
         end
       end
     end
-    it "should take on new setting value" do
+    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")
+      expect(c.rule(:table_of_contents)).to eq('2')
     end
 
-    describe "renders with/without toc" do
+    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.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
@@ -211,28 +202,27 @@ describe Card do
       end
     end
   end
-#end
-
-  context "when I change the general toc setting to 1" do
+  # end
 
+  context 'when I change the general toc setting to 1' do
     before do
-      expect(@c1 = Card["Onne Heading"]).to be
+      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
+      # @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"
+      @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")
+    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
+    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
@@ -240,11 +230,9 @@ describe Card 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"
+        @rule_card.content = '3'
         expect(@c2.format.render_open_content).not_to match /Table of Contents/
       end
     end
-
   end
 end
-