wagn 1.13.0 → 1.14.0.pre1

data/{spec/mod/core → mod/01_core/spec}/set/all/references_spec.rb

@@ -2,7 +2,7 @@
 
 describe Card::Set::All::References do
   it "should replace references should work on inclusions inside links" do
-    card = Card.create!(:name=>"test", :content=>"[[test_card|test{{test}}]]"  )
+    card = Card.create!(:name=>"ref test", :content=>"[[test_card|test{{test}}]]"  )
     assert_equal "[[test_card|test{{best}}]]", card.replace_references("test", "best" )
   end
 end

data/{spec/mod/core → mod/01_core/spec}/set/all/rules2_spec.rb

@@ -11,46 +11,46 @@ describe Card do
       Card::Auth.as_bot do
         Card.create! :name=>'Basic+*type+*table of contents', :content=>'2'
       end
-      (@c1 = Card['Onne Heading']).should be
-      (@c2 = Card['Twwo Heading']).should be
-      (@c3 = Card['Three Heading']).should be
-      @c1.type_id.should == Card::BasicID
-      (@rule_card = @c1.rule_card(:table_of_contents)).should be
+      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
-        @rule_card.content.should == "2"
-        @c1.rule(:table_of_contents).should == "2"
+        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
-        @c1.format.render_open_content.should_not match /Table of Contents/
+        expect(@c1.format.render_open_content).not_to match /Table of Contents/
       end
       it "should render for 'Twwo Heading'" do
-        @c2.format.render_open_content.should match /Table of Contents/
+        expect(@c2.format.render_open_content).to match /Table of Contents/
       end
       it "should render for 'Three Heading'" do
-        @c3.format.render_open_content.should match /Table of Contents/
+        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
-        @c1.rule_card(:table_of_contents).should == @rule_card
+        expect(@c1.rule_card(:table_of_contents)).to eq(@rule_card)
       end
     end
 
     describe ".related_sets" do
       it "should have 2 sets (self and right) for a simple card" do
         sets = Card['A'].related_sets.map { |s| s[0] }
-        sets.should == ['A+*self', 'A+*right']
+        expect(sets).to eq(['A+*self', 'A+*right'])
       end
       it "should have 3 sets (self, type, and right) for a cardtype card" do
         sets = Card['Cardtype A'].related_sets.map { |s| s[0] }
-        sets.should == ['Cardtype A+*type', 'Cardtype A+*self', 'Cardtype A+*right']
+        expect(sets).to eq(['Cardtype A+*type', 'Cardtype A+*self', '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=>'' }
@@ -64,7 +64,7 @@ describe Card do
 #      end
       it "should have sets for a non-simple card" do
         sets = Card['A+B'].related_sets.map { |s| s[0] }
-        sets.should == ['A+B+*self']
+        expect(sets).to eq(['A+B+*self'])
       end
     end
 =begin
@@ -80,31 +80,31 @@ describe Card do
   context "when I change the general toc setting to 1" do
 
     before do
-      (@c1 = Card["Onne Heading"]).should be
-      (@c2 = Card["Twwo Heading"]).should be
-      @c1.type_id.should == Card::BasicID
-      (@rule_card = @c1.rule_card(:table_of_contents)).should 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"
     end
 
     describe ".rule" do
       it "should have a value of 1" do
-        @rule_card.content.should == "1"
-        @c1.rule(:table_of_contents).should == "1"
+        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
-        @c1.format.render_open_content.should match /Table of Contents/
+        expect(@c1.format.render_open_content).to match /Table of Contents/
       end
       it "should render toc for 'Twwo Heading'" do
-        @c2.format.render_open_content.should match /Table of Contents/
+        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"
-        @c2.rule(:table_of_contents).should == "3"
-        @c2.format.render_open_content.should_not match /Table of Contents/
+        expect(@c2.rule(:table_of_contents)).to eq("3")
+        expect(@c2.format.render_open_content).not_to match /Table of Contents/
       end
     end
 
@@ -121,42 +121,42 @@ describe Card do
         @c3 = Card.create :name=>'toc3', :type=>"CardtypeE",
           :content=>Card['Three Heading'].content
       end
-      @c1.type_name.should == 'Cardtype E'
+      expect(@c1.type_name).to eq('Cardtype E')
       @rule_card = @c1.rule_card(:table_of_contents)
 
-      @c1.should be
-      @c2.should be
-      @c3.should be
-      @rule_card.should be
+      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
-        @c1.rule(:table_of_contents).should == "0"
-        @rule_card.content.should == "0"
+        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
-        @c1.format.render_open_content.should_not match /Table of Contents/
+        expect(@c1.format.render_open_content).not_to match /Table of Contents/
       end
       it "should render for 'Twwo Heading'" do
-        @c2.format.render_open_content.should_not match /Table of Contents/
+        expect(@c2.format.render_open_content).not_to match /Table of Contents/
       end
       it "should render for 'Three Heading'" do
-        @c3.format.render_open_content.should_not match /Table of Contents/
+        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
-        @rule_card.should be
-        @rule_card.name.should == "*all+*table of contents"
+        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
-        @c1.rule_card(:table_of_contents).should == @rule_card
+        expect(@c1.rule_card(:table_of_contents)).to eq(@rule_card)
       end
     end
 
@@ -177,13 +177,13 @@ describe Card do
         @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
-        @c1.type_name.should == 'Cardtype E'
+        expect(@c1.type_name).to eq('Cardtype E')
         @rule_card = @c1.rule_card(:table_of_contents)
 
-        @c1.should be
-        @c2.should be
-        @c3.should be
-        @rule_card.name.should == '*all+*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!
@@ -194,20 +194,20 @@ describe Card do
     end
     it "should take on new setting value" do
       c = Card['toc1']
-      c.rule_card(:table_of_contents).name.should == 'CardtypeE+*type+*table of content'
-      c.rule(:table_of_contents).should == "2"
+      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
-        @c1.format.render_open_content.should_not match /Table of Contents/
+        expect(@c1.format.render_open_content).not_to match /Table of Contents/
       end
       it "should render for 'Twwo Heading'" do
-        @c2.rule(:table_of_contents).should == "2"
-        @c2.format.render_open_content.should match /Table of Contents/
+        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
-        @c3.format.render_open_content.should match /Table of Contents/
+        expect(@c3.format.render_open_content).to match /Table of Contents/
       end
     end
   end
@@ -216,32 +216,32 @@ describe Card do
   context "when I change the general toc setting to 1" do
 
     before do
-      (@c1 = Card["Onne Heading"]).should 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
-      (@c2 = Card["Twwo Heading"]).should be
-      @c1.type_id.should == Card::BasicID
-      (@rule_card = @c1.rule_card(:table_of_contents)).should 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
-        @rule_card.content.should == "1"
-        @c1.rule(:table_of_contents).should == "1"
+        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
-        @c1.format.render_open_content.should match /Table of Contents/
+        expect(@c1.format.render_open_content).to match /Table of Contents/
       end
       it "should render toc for 'Twwo Heading'" do
-        @c2.format.render_open_content.should match /Table of Contents/
+        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"
-        @c2.format.render_open_content.should_not match /Table of Contents/
+        expect(@c2.format.render_open_content).not_to match /Table of Contents/
       end
     end
 

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

@@ -0,0 +1,81 @@
+# -*- 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"
+      expect(Card.new( :type => "Book" ).rule(:add_help, :fallback=>:help)).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 c=Card.create(:name => "*all+*add help", :content => "lobotomize")
+#      Card.default_rule(:add_help, :fallback=>:help).should == "lobotomize"
+      expect(Card.new( :type => "Basic" ).rule(:add_help, :fallback=>:help)).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
+
+      it "retrieves default setting" do
+        expect(Card.new( :type => "Book" ).rule(:add_help, :fallback=>:help)).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(Card.new( :type => "Book" ).rule(:add_help, :fallback=>:help)).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(Card.new( :type => "Book" ).rule(:add_help, :fallback=>:help)).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
+      expect(Card.new(:name=>'foob+*right').setting_codenames_by_group.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
+end

data/{spec/mod/core → mod/01_core/spec}/set/all/templating_spec.rb

@@ -6,9 +6,9 @@ describe Card::Set::All::Templating do
     it "for User+*type+*structure should return all Users" do
       Card::Auth.as_bot do
         c=Card.create(:name=>'User+*type+*structure')
-        c.structuree_names.sort.should == [
+        expect(c.structuree_names.sort).to eq([
           "Joe Admin", "Joe Camel", "Joe User", "John", "No Count", "Sample User", "Sara", "u1", "u2", "u3"
-        ]
+        ])
       end
     end
   end
@@ -27,7 +27,7 @@ describe Card::Set::All::Templating do
     end
 
     it "should have default content" do
-      @jb.format._render_raw.should == 'Today!'
+      expect(@jb.format._render_raw).to eq('Today!')
     end
 
     it "should change type and content with template" do
@@ -37,8 +37,8 @@ describe Card::Set::All::Templating do
         @bt.save!
       end
       jb = @jb.refresh force=true
-      jb.format.render(:raw).should == 'Tomorrow'
-      jb.type_id.should == Card::PhraseID    
+      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
@@ -46,8 +46,8 @@ describe Card::Set::All::Templating do
         Card.create! :name=>'Basic+birthday+*type plus right+*structure', :type=>'PlainText', :content=>'Yesterday'
       end
       jb = @jb.refresh force=true
-      jb.raw_content.should == 'Yesterday'
-      jb.type_id.should == Card::PlainTextID
+      expect(jb.raw_content).to eq('Yesterday')
+      expect(jb.type_id).to eq(Card::PlainTextID)
     end
   end
 
@@ -61,11 +61,15 @@ describe Card::Set::All::Templating do
     end
 
     it "should have default cardtype" do
-      @jb.type_code.should == :date
+      expect(@jb.type_code).to eq(:date)
     end
 
     it "should have default content" do
-      Card['Jim+birthday'].content.should == 'Today!'
+      expect(Card['Jim+birthday'].content).to eq('Today!')
+    end
+    
+    it "should apply to new cards" do
+      expect(Card.new(:name=>"Pete+birthday").content).to eq('Today!')
     end
   end
 
@@ -77,7 +81,7 @@ describe Card::Set::All::Templating do
     end
     
     it "should return templated content even if content is passed in" do
-      Card.new(:type=>'Date', :content=>'').format._render(:raw).should == 'Tomorrow'
+      expect(Card.new(:type=>'Date', :content=>'').format._render(:raw)).to eq('Tomorrow')
     end
     
     describe 'and right structure' do
@@ -89,12 +93,12 @@ describe Card::Set::All::Templating do
       end
       
       it "*right setting should override *type setting" do
-        Card['Jim+birthday'].raw_content.should == 'Today'
+        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 { Card.create! :name=>'Jim+birthday+*self+*structure', :content=>'_self' }
-        Card['Jim+birthday'].raw_content.should == 'Yesterday'
+        expect(Card['Jim+birthday'].raw_content).to eq('Yesterday')
       end
     end
   end

data/{spec/mod/core → mod/01_core/spec}/set/all/tracked_attributes_spec.rb

@@ -6,7 +6,7 @@ module RenameMethods
     {
       :content     => card.content,
       #:updater_id  => card.updater_id,
-      :revisions   => card.revisions.count,
+      #:revisions   => card.actions.count,
       :referencers => card.referencers.map(&:name).sort,
       :referees => card.referees.map(&:name).sort,
       :dependents  => card.dependents.map(&:id)
@@ -15,9 +15,11 @@ module RenameMethods
 
   def assert_rename card, new_name
     attrs_before = name_invariant_attributes( card )
+    actions_count_before = card.actions.count
     card.name=new_name
     card.update_referencers = true
     card.save!
+    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]
@@ -37,8 +39,8 @@ describe Card::Set::All::TrackedAttributes do
     it "should move plus keys into subcard hash" do
       raw_args = { 'name'=>'test', 'subcards'=>{ '+*oldway'=>{'content'=>'old'},  }, '+*newway'=>{'content'=>'new'} }
       subcards = Card.new.extract_subcard_args! raw_args
-      raw_args['subcards'].should be_nil
-      subcards.keys.sort.should == ['+*newway', '+*oldway']
+      expect(raw_args['subcards']).to be_nil
+      expect(subcards.keys.sort).to eq(['+*newway', '+*oldway'])
     end
   end
   
@@ -48,19 +50,19 @@ describe Card::Set::All::TrackedAttributes do
 
     it "should handle case variants" do
       @c = Card.create! :name=>'chump'
-      @c.name.should == 'chump'
+      expect(@c.name).to eq('chump')
       @c.name = 'Chump'
       @c.save!
-      @c.name.should == 'Chump'
+      expect(@c.name).to eq('Chump')
     end
 
     it "should handle changing from plus card to simple" do
       c = Card.create! :name=>'four+five'
       c.name = 'nine'
       c.save!
-      c.name.should == 'nine'
-      c.left_id.should== nil
-      c.right_id.should== nil
+      expect(c.name).to eq('nine')
+      expect(c.left_id).to eq(nil)
+      expect(c.right_id).to eq(nil)
     end
     
     #FIXME - following tests more about fetch than set_name.  this spec still needs lots of cleanup
@@ -70,16 +72,16 @@ describe Card::Set::All::TrackedAttributes do
       cards_should_be_added 0 do
         c=Card.fetch "Carrots", :new=>{}
         c.save
-        c.should be_instance_of(Card)
-        Card.fetch("Carrots").should be_instance_of(Card)
+        expect(c).to be_instance_of(Card)
+        expect(Card.fetch("Carrots")).to be_instance_of(Card)
       end
     end
 
     it "test_simple" do
       cards_should_be_added 1 do
-        Card['Boo!'].should be_nil
-        Card.create(:name=>"Boo!").should be_instance_of(Card)
-        Card['Boo!'].should be_instance_of(Card)
+        expect(Card['Boo!']).to be_nil
+        expect(Card.create(:name=>"Boo!")).to be_instance_of(Card)
+        expect(Card['Boo!']).to be_instance_of(Card)
       end
     end
 
@@ -88,17 +90,17 @@ describe Card::Set::All::TrackedAttributes do
       cards_should_be_added 1 do
         c=Card.fetch("Tomatoes", :new=>{})
         c.save
-        c.should be_instance_of(Card)
-        Card.fetch("Tomatoes").should be_instance_of(Card)
+        expect(c).to be_instance_of(Card)
+        expect(Card.fetch("Tomatoes")).to be_instance_of(Card)
       end
     end
 
     it "test_create_junction" do
       cards_should_be_added 3 do
-        Card.create(:name=>"Peach+Pear", :content=>"juicy").should be_instance_of(Card)
+        expect(Card.create(:name=>"Peach+Pear", :content=>"juicy")).to be_instance_of(Card)
       end
-      Card["Peach"].should be_instance_of(Card)
-      Card["Pear"].should be_instance_of(Card)
+      expect(Card["Peach"]).to be_instance_of(Card)
+      expect(Card["Pear"]).to be_instance_of(Card)
       assert_equal "juicy", Card["Peach+Pear"].content
     end
 
@@ -107,7 +109,7 @@ describe Card::Set::All::TrackedAttributes do
     def cards_should_be_added number
       number += Card.all.count
       yield
-      Card.all.count.should == number
+      expect(Card.all.count).to eq(number)
     end
 
   end
@@ -129,20 +131,20 @@ describe Card::Set::All::TrackedAttributes do
 
     it "clears cache for old name" do
       assert_rename Card['Menu'], 'manure'
-      Card['Menu'].should be_nil
+      expect(Card['Menu']).to be_nil
     end
   
     it "wipes old references by default" do
       c = Card['Menu']
       c.name = 'manure'
       c.save!
-      Card['manure'].references_from.size.should == 0
+      expect(Card['manure'].references_from.size).to eq(0)
     end
   
     it "picks up new references" do
       Card.create :name=>'kinds of poop', :content=>'[[manure]]'
       assert_rename Card['Menu'], 'manure'
-      Card['manure'].references_from.size.should == 2
+      expect(Card['manure'].references_from.size).to eq(2)
     end
 
     it "handles name variants" do