wagn 1.13.0 → 1.14.0.pre1

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

@@ -0,0 +1,65 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Set::All::Collection do
+  describe "#item_names" do
+    it "returns item for each line of basic content" do
+      expect(Card.new( :name=>"foo", :content => "X\nY" ).item_names).to eq(["X","Y"])
+    end
+
+    it "returns list of card names for search" do
+      card = Card.new( :name=>"foo", :type=>"Search", :content => %[{"name":"Z"}])
+      expect(card.item_names).to eq(["Z"])
+    end
+
+    it "handles searches relative to context card" do
+      # note: A refers to 'Z'
+      expect(Card.new(:name=>"foo", :type=>"Search", :content => %[{"referred_to_by":"_self"}]).item_names( :context=>'A' )).to eq(["Z"])
+    end
+  end
+
+  describe "#extended_list" do
+    it "returns item's content for pointer setting" do
+      c = Card.new(:name=>"foo", :type=>"Pointer", :content => "[[Z]]")
+      expect(c.extended_list).to eq(["I'm here to be referenced to"])
+    end
+  end
+  
+  describe "#extended_item_cards" do
+    it "returns the 'leaf cards' of a tree of pointer cards" do
+      Card::Auth.as_bot do
+        Card.create!(:name=>"node", :type=>"Pointer", :content=>"[[Z]]")
+      end
+      c = Card.new(:name=>"foo", :type=>"Pointer", :content => "[[node]]\n[[A]]")
+      expect(c.extended_item_cards).to eq([Card.fetch("Z"),Card.fetch("A")],)
+    end
+  end
+  
+  describe "#extended_item_contents" do
+    it "returns the content of the 'leaf cards' of a tree of pointer cards" do
+      Card::Auth.as_bot do
+        Card.create!(:name=>"node", :type=>"Pointer", :content=>"[[Z]]")
+      end
+      c = Card.new(:name=>"foo", :type=>"Pointer", :content =>  "[[node]]\n[[T]]")
+      expect(c.extended_item_contents).to eq(["I'm here to be referenced to", "Theta"])
+    end
+  end
+
+  describe "#contextual_content" do
+
+    it "processes inclusions relative to context card" do
+      context_card = Card["A"] # refers to 'Z'
+      c = Card.new(:name=>"foo", :content => "{{_self+B|core}}")
+      expect(c.contextual_content( context_card )).to eq("AlphaBeta")
+    end
+
+    it "returns content even when context card is hard templated" do #why the heck is this good?  -efm
+      context_card = Card["A"] # refers to 'Z'
+      
+      Card::Auth.as_bot do
+        Card.create! :name => "A+*self+*structure", :content => "Banana"
+      end
+      c = Card.new( :name => "foo", :content => "{{_self+B|core}}" )
+      expect(c.contextual_content( context_card )).to eq("AlphaBeta")
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Set::All::Content do
+  describe 'save_content_draft' do
+    it 'should store a draft revision' do
+      @card = Card.create! :name=>"mango", :content=>"foo"
+      @card.save_content_draft("bar")
+      expect(@card.drafts.length).to eq 1
+      @card.save_content_draft("booboo")
+      @card.reload
+      expect(@card.drafts.length).to eq 1
+      expect(@card.drafts[0].new_values[:content]).to eq "booboo"
+    end
+  end
+end

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

@@ -3,38 +3,40 @@
 describe Card::Set::All::Fetch do
   describe ".fetch" do
     it "returns and caches existing cards" do
-      Card.fetch("A").should be_instance_of(Card)
-      Card.cache.read("a").should be_instance_of(Card)
-      mock.dont_allow(Card).find_by_key
-      Card.fetch("A").should be_instance_of(Card)
+      card_double = class_double("Card")
+      expect(Card.fetch("A")).to be_instance_of(Card)
+      expect(Card.cache.read("a")).to be_instance_of(Card)
+      expect(card_double).not_to receive(:find_by_key)
+      expect(Card.fetch("A")).to be_instance_of(Card)
     end
 
     it "returns nil and caches missing cards" do
-      Card.fetch("Zork").should be_nil
-      Card.cache.read("zork").new_card?.should be_true
-      Card.fetch("Zork").should be_nil
+      expect(Card.fetch("Zork")).to be_nil
+      expect(Card.cache.read("zork").new_card?).to be_truthy
+      expect(Card.fetch("Zork")).to be_nil
     end
 
     it "returns nil and caches trash cards" do
       Card::Auth.as_bot do
+        card_double = class_double("Card")
         Card.fetch("A").delete!
-        Card.fetch("A").should be_nil
-        mock.dont_allow(Card).find_by_key
-        Card.fetch("A").should be_nil
+        expect(Card.fetch("A")).to be_nil
+        expect(card_double).not_to receive(:find_by_key_and_trash)
+        expect(Card.fetch("A")).to be_nil
       end
     end
 
     it "returns and caches builtin cards" do
-      Card.fetch("*head").should be_instance_of(Card)
-      Card.cache.read("*head").should_not be_nil
+      expect(Card.fetch("*head")).to be_instance_of(Card)
+      expect(Card.cache.read("*head")).not_to be_nil
     end
 
     it "returns virtual cards and caches them as missing" do
       Card::Auth.as_bot do
         card = Card.fetch("Joe User+*email")
-        card.should be_instance_of(Card)
-        card.name.should == "Joe User+*email"
-        card.format.render_raw.should == 'joe@user.com'
+        expect(card).to be_instance_of(Card)
+        expect(card.name).to eq("Joe User+*email")
+        expect(card.format.render_raw).to eq('joe@user.com')
       end
       #card.raw_content.should == 'joe@user.com'
       #cached_card = Card.cache.read("joe_user+*email")
@@ -43,56 +45,55 @@ describe Card::Set::All::Fetch do
     end
 
     it "fetches virtual cards after skipping them" do
-      Card['A+*self'].should be_nil
-      Card.fetch( 'A+*self' ).should_not be_nil
+      expect(Card['A+*self']).to be_nil
+      expect(Card.fetch( 'A+*self' )).not_to be_nil
     end
     
 
     it "fetches newly virtual cards" do
-      Card.fetch( 'A+virtual').should be_nil
+      expect(Card.fetch( 'A+virtual')).to be_nil
       Card::Auth.as_bot { Card.create :name=>'virtual+*right+*structure' }
-      Card.fetch( 'A+virtual').should_not be_nil
+      expect(Card.fetch( 'A+virtual')).not_to be_nil
     end
     
     it "handles name variants of cached cards" do
-      Card.fetch('yomama+*self').name.should == 'yomama+*self'
-      Card.fetch('YOMAMA+*self').name.should == 'YOMAMA+*self'
-      Card.fetch('yomama', :new=>{}).name.should == 'yomama'
-      Card.fetch('YOMAMA', :new=>{}).name.should == 'YOMAMA'
-      Card.fetch('yomama!', :new=>{ :name=>'Yomama'} ).name.should == 'Yomama'
+      expect(Card.fetch('yomama+*self').name).to eq('yomama+*self')
+      expect(Card.fetch('YOMAMA+*self').name).to eq('YOMAMA+*self')
+      expect(Card.fetch('yomama', :new=>{}).name).to eq('yomama')
+      expect(Card.fetch('YOMAMA', :new=>{}).name).to eq('YOMAMA')
+      expect(Card.fetch('yomama!', :new=>{ :name=>'Yomama'} ).name).to eq('Yomama')
     end
 
     it "does not recurse infinitely on template templates" do
-      Card.fetch("*structure+*right+*structure").should be_nil
+      expect(Card.fetch("*structure+*right+*structure")).to be_nil
     end
 
     it "expires card and dependencies on save" do
       #Card.cache.dump # should be empty
       Card.cache.reset_local
-      Card.cache.local.keys.should == []
+      expect(Card.cache.local.keys).to eq([])
 
       Card::Auth.as_bot do
-
         a = Card.fetch("A")
-        a.should be_instance_of(Card)
-
+        expect(a).to be_instance_of(Card)
+        
+        
         # expires the saved card
-        mock(Card.cache).delete('a')
-        mock(Card.cache).delete(/~\d+/).at_least(12)
-
+        expect(Card.cache).to receive(:delete).with('a').and_call_original
+        expect(Card.cache).to receive(:delete).with(/~\d+/).at_least(12)  
         # expires plus cards
-        mock(Card.cache).delete('c+a')
-        mock(Card.cache).delete('d+a')
-        mock(Card.cache).delete('f+a')
-        mock(Card.cache).delete('a+b')
-        mock(Card.cache).delete('a+c')
-        mock(Card.cache).delete('a+d')
-        mock(Card.cache).delete('a+e')
-        mock(Card.cache).delete('a+b+c')
+        expect(Card.cache).to receive(:delete).with('c+a')
+        expect(Card.cache).to receive(:delete).with('d+a')
+        expect(Card.cache).to receive(:delete).with('f+a')
+        expect(Card.cache).to receive(:delete).with('a+b')
+        expect(Card.cache).to receive(:delete).with('a+c')
+        expect(Card.cache).to receive(:delete).with('a+d')
+        expect(Card.cache).to receive(:delete).with('a+e')
+        expect(Card.cache).to receive(:delete).with('a+b+c')
 
         # expired including? cards
-        mock(Card.cache).delete('x').times(2)
-        mock(Card.cache).delete('y').times(2)
+        expect(Card.cache).to receive(:delete).with('x').exactly(2).times
+        expect(Card.cache).to receive(:delete).with('y').exactly(2).times
         a.save!
       end
     end
@@ -106,53 +107,54 @@ describe Card::Set::All::Fetch do
         c1=Card.create!(:name => "y+*right+*structure", :content => "Formatted Content")
         c2=Card.create!(:name => "a+y", :content => "DB Content")
         card = Card.fetch("a+y")
-        card.virtual?.should be_false
-        card.rule(:structure).should == "Formatted Content"
-        card.content.should == "DB Content"
+        expect(card.virtual?).to be_falsey
+        expect(card.rule(:structure)).to eq("Formatted Content")
+        expect(card.content).to eq("DB Content")
       end
 
       it "prefers a pattern virtual card to trash cards" do
         Card.create!(:name => "y+*right+*structure", :content => "Formatted Content")
         Card.create!(:name => "a+y", :content => "DB Content")
         Card.fetch("a+y").delete!
-
+        
         card = Card.fetch("a+y")
-        card.virtual?.should be_true
-        card.content.should == "Formatted Content"
+        expect(card.virtual?).to be
+        expect(card.raw_content).to eq("Formatted Content")
       end
 
       it "should recognize pattern overrides" do
         #~~~ create right rule
         tc=Card.create!(:name => "y+*right+*structure", :content => "Right Content")
         card = Card.fetch("a+y")
-        card.virtual?.should be_true
-        card.content.should == "Right Content"
+        expect(card.virtual?).to be
+        expect(card.raw_content).to eq("Right Content")
         
 #        warn "creating template"
         tpr = Card.create!(:name => "Basic+y+*type plus right+*structure", :content => "Type Plus Right Content")
         card = Card.fetch("a+y")
-        card.virtual?.should be_true
-        card.content.should == "Type Plus Right Content"
+        expect(card.virtual?).to be
+        expect(card.raw_content).to eq("Type Plus Right Content")
 
         #~~~ delete type plus right rule
         tpr.delete!
         card = Card.fetch("a+y")
-        card.virtual?.should be_true
-        card.content.should == "Right Content"
+        expect(card.virtual?).to be
+        expect(card.raw_content).to eq("Right Content")
 
       end
 
       it "should not hit the database for every fetch_virtual lookup" do
+        card_double = class_double("Card")
         Card.create!(:name => "y+*right+*structure", :content => "Formatted Content")
         Card.fetch("a+y")
-        mock.dont_allow(Card).find_by_key
+        expect(card_double).not_to receive(:find_by_key)
         Card.fetch("a+y")
       end
 
       it "should not be a new_record after being saved" do
         Card.create!(:name=>'growing up')
         card = Card.fetch('growing up')
-        card.new_record?.should be_false
+        expect(card.new_record?).to be_falsey
       end
     end
   end
@@ -160,22 +162,22 @@ describe Card::Set::All::Fetch do
   describe "#fetch :new=>{ ... }" do
     it "returns a new card if it doesn't find one" do
       new_card = Card.fetch "Never Seen Me Before", :new=>{}
-      new_card.should be_instance_of(Card)
-      new_card.new_record?.should be_true
+      expect(new_card).to be_instance_of(Card)
+      expect(new_card.new_record?).to be_truthy
     end
 
     it "returns a card if it finds one" do
       new_card = Card.fetch "A+B", :new=>{}
-      new_card.should be_instance_of(Card)
-      new_card.new_record?.should be_false
+      expect(new_card).to be_instance_of(Card)
+      expect(new_card.new_record?).to be_falsey
     end
 
     it "takes a second hash of options as new card options" do
       new_card = Card.fetch "Never Before", :new=>{ :type => "Image" }
-      new_card.should be_instance_of(Card)
-      new_card.type_code.should == :image
-      new_card.new_record?.should be_true
-      Card.fetch( 'Never Before', :new=>{} ).type_id.should == Card::BasicID
+      expect(new_card).to be_instance_of(Card)
+      expect(new_card.type_code).to eq(:image)
+      expect(new_card.new_record?).to be_truthy
+      expect(Card.fetch( 'Never Before', :new=>{} ).type_id).to eq(Card::BasicID)
     end
   end
 
@@ -186,18 +188,18 @@ describe Card::Set::All::Fetch do
       end
       c = Card.fetch("A+testsearch".to_name)
       assert c.virtual?
-      c.type_code.should == :search_type
-      c.content.should ==  "{\"plus\":\"_self\"}"
+      expect(c.type_code).to eq(:search_type)
+      expect(c.raw_content).to eq("{\"plus\":\"_self\"}")
     end
   end
 
   describe "#exists?" do
     it "is true for cards that are there" do
-      Card.exists?("A").should == true
+      expect(Card.exists?("A")).to eq(true)
     end
 
     it "is false for cards that arent'" do
-      Card.exists?("Mumblefunk is gone").should == false
+      expect(Card.exists?("Mumblefunk is gone")).to eq(false)
     end
   end
 end

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

@@ -4,20 +4,20 @@ describe Card::Set::All::Initialize do
   describe "new" do
     it "handles explicit nil as parameters" do
       c = Card.new nil
-      c.should be_instance_of(Card)
-      c.name.should == ''
+      expect(c).to be_instance_of(Card)
+      expect(c.name).to eq('')
     end
 
     it "handles nil name" do
       c = Card.new :name => nil
-      c.should be_instance_of(Card)
-      c.name.should == ''
+      expect(c).to be_instance_of(Card)
+      expect(c.name).to eq('')
     end
     
     it 'handles legit name' do
       c = Card.new :name => 'Ceee'
-      c.should be_instance_of(Card)
-      c.name.should == 'Ceee'
+      expect(c).to be_instance_of(Card)
+      expect(c.name).to eq('Ceee')
     end    
   end
   
@@ -29,29 +29,29 @@ describe Card::Set::All::Initialize do
       end
 
       it "happens after new" do
-        @c.respond_to?( :get_spec ).should be_true
+        expect(@c.respond_to?( :get_spec )).to be_truthy
       end
 
       it "happens after save" do
-        @c.respond_to?( :get_spec ).should be_true
+        expect(@c.respond_to?( :get_spec )).to be_truthy
         @c.save!
-        @c.respond_to?( :get_spec ).should be_true
+        expect(@c.respond_to?( :get_spec )).to be_truthy
       end
 
       it "happens after fetch" do
         @c.save!
         c = Card.fetch(@c.name)
-        c.respond_to?( :get_spec ).should be_true
+        expect(c.respond_to?( :get_spec )).to be_truthy
       end
     end
 
     context '(pointer)' do
       it "happens with explicit pointer setting" do
-        Card.new(:type=>'Pointer').respond_to?(:add_item).should be_true
+        expect(Card.new(:type=>'Pointer').respond_to?(:add_item)).to be_truthy
       end
 
       it "happens with implicit pointer setting (from template)" do
-        Card.new(:name=>'Home+*watchers').should be_true
+        expect(Card.new(:name=>'Home+*watchers')).to be_truthy
       end
     end
   end

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

@@ -10,20 +10,20 @@ describe Card::Set::All::Name do
 
     it "should handle cards without names" do
       c = Card.create! :type=>'Book'
-      c.name.should== 'b1'
+      expect(c.name).to eq('b1')
     end
 
     it "should increment again if name already exists" do
       b1 = Card.create! :type=>'Book'
       b2 = Card.create! :type=>'Book'
-      b2.name.should== 'b2'
+      expect(b2.name).to eq('b2')
     end
 
     it "should handle trashed names" do
       b1 = Card.create! :type=>'Book'
       Card::Auth.as_bot { b1.delete }
       b1 = Card.create! :type=>'Book'
-      b1.name.should== 'b1'
+      expect(b1.name).to eq('b1')
     end
   end
   
@@ -34,13 +34,13 @@ describe Card::Set::All::Name do
     
     it 'should require admin permission' do
       @card.update_attributes :codename=>'structure'
-      @card.errors[:codename].first.should =~ /only admins/
+      expect(@card.errors[:codename].first).to match(/only admins/)
     end
     
     it 'should check uniqueness' do
       Card::Auth.as_bot do
         @card.update_attributes :codename=>'structure'
-        @card.errors[:codename].first.should =~ /already in use/
+        expect(@card.errors[:codename].first).to match(/already in use/)
       end
     end
     
@@ -53,9 +53,9 @@ describe Card::Set::All::Name do
       a.expire
       
       a = Card.find a.id
-      a.key.should == 'broken_a'
+      expect(a.key).to eq('broken_a')
       a.repair_key
-      a.key.should == 'a'
+      expect(a.key).to eq('a')
     end
   end
 end