card 0.0.1 → 1.15.pre

data/mod/01_core/spec/format/data_format_spec.rb

@@ -0,0 +1,5 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::DataFormat do
+  # format has no methods
+end

data/mod/01_core/spec/format/html_format_spec.rb

@@ -0,0 +1,140 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::HtmlFormat do
+
+  describe "views" do
+
+    it "content" do
+      result = render_card(:content, :name=>'A+B')
+      assert_view_select result, 'div[class="card-slot content-view card-content ALL ALL_PLUS TYPE-basic RIGHT-b TYPE_PLUS_RIGHT-basic-b SELF-a-b"]'
+    end
+
+
+    it "inclusions in multi edit" do
+      c = Card.new :name => 'ABook', :type => 'Book'
+      rendered =  c.format.render( :edit )
+
+      assert_view_select rendered, 'fieldset' do
+        assert_select 'textarea[name=?][class~="tinymce-textarea card-content"]', 'card[subcards][+illustrator][content]'
+      end
+    end
+
+    it "titled" do
+      result = render_card :titled, :name=>'A+B'
+      assert_view_select result, 'div[class~="titled-view"]' do
+        assert_select 'h3' do
+          assert_select 'span'
+        end
+        assert_select 'div[class~="card-body card-content"]', 'AlphaBeta'
+      end
+    end
+
+    context "Cards with special views" do
+
+    end
+
+    context "Simple page with Default Layout" do
+      before do
+        Card::Auth.as_bot do
+          card = Card['A+B']
+          @simple_page = card.format.render(:layout)
+          #warn "render sp: #{card.inspect} :: #{@simple_page}"
+        end
+      end
+
+
+      it "renders top menu" do
+        
+        assert_view_select @simple_page, 'div#menu' do #'nav[class="navbar navbar-default navbar-static-top"]' do
+          assert_select 'a[class="internal-link"][href="/"]', 'Home'
+          assert_select 'a[class="internal-link"][href="/recent"]', 'Recent'
+          assert_select 'form.navbox-form[action="/:search"]' do
+            assert_select 'input[name="_keyword"]'
+          end
+        end
+      end
+
+      it "renders card header" do
+        # lots of duplication here...
+        assert_view_select @simple_page, 'div[class="card-header panel-heading"]' do
+          assert_select 'h3[class="card-header-title panel-title"]'
+        end
+      end
+
+      it "renders card content" do
+        assert_view_select @simple_page, 'div[class="card-body panel-body card-content ALL ALL_PLUS TYPE-basic RIGHT-b TYPE_PLUS_RIGHT-basic-b SELF-a-b"]', 'AlphaBeta'
+      end
+ 
+      it "renders card credit" do
+        assert_view_select @simple_page, 'div[class~="SELF-Xcredit"]' do#, /Wheeled by/ do
+          assert_select 'img'
+          assert_select 'a', "Wagn v#{Card::Version.release}"
+        end
+      end
+    end
+
+    context "layout" do
+      before do
+        Card::Auth.as_bot do
+          @layout_card = Card.create(:name=>'tmp layout', :type=>'Layout')
+          #warn "layout #{@layout_card.inspect}"
+        end
+        c = Card['*all+*layout'] and c.content = '[[tmp layout]]'
+        @main_card = Card.fetch('Joe User')
+        Card::Env[:main_name] = @main_card.name
+        
+        #warn "lay #{@layout_card.inspect}, #{@main_card.inspect}"
+      end
+
+      it "should default to core view when in layout mode" do
+        @layout_card.content = "Hi {{A}}"
+        Card::Auth.as_bot { @layout_card.save }
+
+        expect(@main_card.format.render(:layout)).to match('Hi Alpha')
+      end
+
+      it "should default to open view for main card" do
+        @layout_card.content='Open up {{_main}}'
+        Card::Auth.as_bot { @layout_card.save }
+
+        result = @main_card.format.render_layout
+        expect(result).to match(/Open up/)
+        expect(result).to match(/card-header/)
+        expect(result).to match(/Joe User/)
+      end
+
+      it "should render custom view of main" do
+        @layout_card.content='Hey {{_main|name}}'
+        Card::Auth.as_bot { @layout_card.save }
+
+        result = @main_card.format.render_layout
+        expect(result).to match(/Hey.*div.*Joe User/)
+        expect(result).not_to match(/card-header/)
+      end
+
+      it "shouldn't recurse" do
+        @layout_card.content="Mainly {{_main|core}}"
+        Card::Auth.as_bot { @layout_card.save }
+
+        rendered = expect(@layout_card.format.render(:layout)).to eq( 
+          %{Mainly <div id="main"><div class="CodeRay">\n  <div class="code"><pre>Mainly {{_main|core}}</pre></div>\n</div>\n</div>}
+        )
+          #probably better to check that it matches "Mainly" exactly twice.
+      end
+      
+      
+      it "should handle nested _main references" do
+        Card::Auth.as_bot do
+          @layout_card.content="{{outer space}}"
+          @layout_card.save!
+          Card.create :name=>"outer space", :content=>"{{_main|name}}"
+        end
+        
+        expect(@layout_card.format.render(:layout)).to eq('Joe User')
+      end
+    end
+
+
+  end
+
+end

data/mod/01_core/spec/format/text_format_spec.rb

@@ -0,0 +1,5 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::TextFormat do
+  # format has no methods
+end

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

@@ -0,0 +1,5 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Set::All::ActiveCard do
+  # SPECSTUB
+end

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

@@ -0,0 +1,21 @@
+# -*- encoding : utf-8 -*-
+
+# describe Card::Set::All::AttributeTracking do
+#   context "new card" do
+#     before(:each) do
+#       Card::Auth.as_bot do
+#         @c = Card.new :name=>"New Card", :content=>"Great Content"
+#       end
+#     end
+#
+#     it "should have updates" do
+#       described_class::Updates.should === @c.updates
+#     end
+#
+#     it "should track changes" do
+#       @c.name.should == 'New Card'
+#       @c.name = 'Old Card'
+#       @c.name.should == 'Old Card'
+#     end
+#   end
+# end

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/mod/01_core/spec/set/all/fetch_spec.rb

@@ -0,0 +1,204 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Set::All::Fetch do
+  describe ".fetch" do
+    it "returns and caches existing cards" do
+      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
+      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!
+        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
+      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")
+        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")
+      #cached_card.missing?.should be_true
+      #cached_card.virtual?.should be_true
+    end
+
+    it "fetches virtual cards after skipping them" do
+      expect(Card['A+*self']).to be_nil
+      expect(Card.fetch( 'A+*self' )).not_to be_nil
+    end
+    
+
+    it "fetches newly virtual cards" do
+      expect(Card.fetch( 'A+virtual')).to be_nil
+      Card::Auth.as_bot { Card.create :name=>'virtual+*right+*structure' }
+      expect(Card.fetch( 'A+virtual')).not_to be_nil
+    end
+    
+    it "handles name variants of cached cards" do
+      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
+      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
+      expect(Card.cache.local.keys).to eq([])
+
+      Card::Auth.as_bot do
+        a = Card.fetch("A")
+        expect(a).to be_instance_of(Card)
+        
+        # expires the saved card
+        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
+        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
+        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
+
+    describe "preferences" do
+      before do
+        Card::Auth.current_id = Card::WagnBotID
+      end
+
+      it "prefers db cards to pattern virtual cards" 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")
+        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")
+        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")
+        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")
+        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")
+        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")
+        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')
+        expect(card.new_record?).to be_falsey
+      end
+    end
+  end
+
+  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=>{}
+      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=>{}
+      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" }
+      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
+
+  describe "#fetch_virtual" do
+    it "should find cards with *right+*structure specified" do
+      Card::Auth.as_bot do
+        Card.create! :name=>"testsearch+*right+*structure", :content=>'{"plus":"_self"}', :type => 'Search'
+      end
+      c = Card.fetch("A+testsearch".to_name)
+      assert c.virtual?
+      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
+      expect(Card.exists?("A")).to eq(true)
+    end
+
+    it "is false for cards that arent'" do
+      expect(Card.exists?("Mumblefunk is gone")).to eq(false)
+    end
+  end
+end