wagn 1.12.7

data/spec/mods/core/sets/all/tracked_attributes_spec.rb

@@ -0,0 +1,316 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+
+module RenameMethods
+  def name_invariant_attributes card
+    {
+      :content     => card.content,
+      #:updater_id  => card.updater_id,
+      :revisions   => card.revisions.count,
+      :referencers => card.referencers.map(&:name).sort,
+      :referees => card.referees.map(&:name).sort,
+      :dependents  => card.dependents.map(&:id)
+    }
+  end
+
+  def assert_rename card, new_name
+    attrs_before = name_invariant_attributes( card )
+    card.name=new_name
+    card.update_referencers = true
+    card.save!
+    assert_equal attrs_before, name_invariant_attributes(card)
+    assert_equal new_name, card.name
+    assert Card[new_name]
+  end
+
+  def card name
+    Card[name].refresh or raise "Couldn't find card named #{name}"
+  end
+end
+
+include RenameMethods
+
+
+describe Card::Set::All::TrackedAttributes do
+  describe 'set_name' do
+
+
+    it "should handle case variants" do
+      @c = Card.create! :name=>'chump'
+      @c.name.should == 'chump'
+      @c.name = 'Chump'
+      @c.save!
+      @c.name.should == '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
+    end
+    
+    #FIXME - following tests more about fetch than set_name.  this spec still needs lots of cleanup
+
+    it "test fetch with new when present" do
+      Card.create!(:name=>"Carrots")
+      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)
+      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)
+      end
+    end
+
+
+    it "test fetch with new when not present" 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)
+      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)
+      end
+      Card["Peach"].should be_instance_of(Card)
+      Card["Pear"].should be_instance_of(Card)
+      assert_equal "juicy", Card["Peach+Pear"].content
+    end
+
+  private
+
+    def cards_should_be_added number
+      number += Card.all.count
+      yield
+      Card.all.count.should == number
+    end
+
+  end
+
+
+
+  describe "renaming" do
+
+
+    # FIXME: these tests are TOO SLOW!  8s against server, 12s from command line.
+    # not sure if it's the card creation or the actual renaming process.
+    # Card#save needs optimized in general.
+    # Can't we just move this data to fixtures?
+
+
+    it "renaming plus card to its own child" do
+      assert_rename card("A+B"), "A+B+T"
+    end
+
+    it "clears cache for old name" do
+      assert_rename Card['Menu'], 'manure'
+      Card['Menu'].should 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
+    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
+    end
+
+    it "handles name variants" do
+      assert_rename card("B"), "b"
+    end
+
+    it "handles plus cards renamed to simple" do
+      assert_rename card("A+B"), "K"
+    end
+  
+
+    it "handles flipped parts" do
+      assert_rename card("A+B"), "B+A"
+    end
+
+    it "test_should_error_card_exists" do
+      @t=card("T"); @t.name="A+B";
+      assert !@t.save, "save should fail"
+      assert @t.errors[:name], "should have errors on key"
+    end
+
+    it "test_used_as_tag" do
+      @b=card("B"); @b.name='A+D'; @b.save
+      assert @b.errors[:name]
+    end
+
+    it "test_update_dependents" do
+      c1 =   Card["One"]
+      c12 =  Card["One+Two"]
+      c123 = Card["One+Two+Three"]
+      c41 =  Card["Four+One"]
+      c415 = Card["Four+One+Five"]
+
+      assert_equal ["One+Two","One+Two+Three","Four+One","Four+One+Five"], [c12,c123,c41,c415].map(&:name)
+      c1.name="Uno"
+      c1.save!
+      assert_equal ["Uno+Two","Uno+Two+Three","Four+Uno","Four+Uno+Five"], [c12,c123,c41,c415].map(&:reload).map(&:name)
+    end
+
+    it "test_should_error_invalid_name" do
+      @t=card("T"); @t.name="YT_o~Yo"; @t.save
+      assert @t.errors[:name]
+    end
+
+    it "test_simple_to_simple" do
+      assert_rename card("A"), "Alephant"
+    end
+
+    it "test_simple_to_junction_with_create" do
+      assert_rename card("T"), "C+J"
+    end
+
+    it "test_reset_key" do
+      c = Card["Basic Card"]
+      c.name="banana card"
+      c.save!
+      assert_equal 'banana_card', c.key
+      assert Card["Banana Card"] != nil
+    end
+
+
+
+    it "test_rename_should_not_fail_when_updating_inaccessible_referencer" do
+      Card.create! :name => "Joe Card", :content => "Whattup"
+      Account.as :joe_admin do
+        Card.create! :name => "Admin Card", :content => "[[Joe Card]]"
+      end
+      c = Card["Joe Card"]
+      c.update_attributes! :name => "Card of Joe", :update_referencers => true
+      assert_equal "[[Card of Joe]]", Card["Admin Card"].content
+    end
+
+    it "test_rename_should_update_structured_referencer" do
+      Account.as_bot do
+        c=Card.create! :name => "Pit"
+        Card.create! :name => "Orange", :type=>"Fruit", :content => "[[Pit]]"
+        Card.create! :name => "Fruit+*type+*structure", :content=>"this [[Pit]]"
+
+        assert_equal "this [[Pit]]", Card["Orange"].raw_content
+        c.update_attributes! :name => "Seed", :update_referencers => true
+        assert_equal "this [[Seed]]", Card["Orange"].raw_content
+      end
+    end
+    
+    it 'should handle plus cards that have children' do
+      Account.as_bot do
+        Card.create :name=>'a+b+c+d'
+        ab = Card['a+b']
+        assert_rename ab, 'e+f'
+      end
+    end
+    
+    
+    context "chuck" do
+      before do
+        Account.as_bot do
+          Card.create! :name => "chuck_wagn+chuck"
+        end
+      end
+      
+      it "test_rename_name_substitution" do
+        c1, c2 = Card["chuck_wagn+chuck"], Card["chuck"]
+        assert_rename c2, "buck"
+        assert_equal "chuck_wagn+buck", Card.find(c1.id).name
+      end
+      
+      it "test_reference_updates_plus_to_simple" do
+         c1 = Account.as_bot do
+           Card.create! :name=>'Huck', :content=>"[[chuck wagn+chuck]]"
+         end
+         c2 = Card["chuck_wagn+chuck"]
+         assert_rename c2, 'schmuck'
+         c1 = Card.find(c1.id)
+         assert_equal '[[schmuck]]', c1.content
+      end
+    end
+    
+    context "dairy" do
+      before do
+        Account.as_bot do
+          Card.create! :type=>"Cardtype", :name=>"Dairy", :content => "[[/new/{{_self|name}}|new]]"
+        end
+      end
+      
+      it "test_renaming_card_with_self_link_should_not_hang" do
+        c = Card["Dairy"]
+        c.name = "Buttah"
+        c.update_referencers = true
+        c.save!
+        assert_equal "[[/new/{{_self|name}}|new]]", Card["Buttah"].content
+      end
+
+      it "test_renaming_card_without_updating_references_should_not_have_errors" do
+        c = Card["Dairy"]
+        c.update_attributes "name"=>"Newt", "update_referencers"=>'false'
+        assert_equal "[[/new/{{_self|name}}|new]]", Card["Newt"].content
+      end
+    end
+    
+    
+    context "blues" do
+      before do
+        Account.as_bot do
+          Card.create! :name => "Blue"
+    
+          Card.create! :name => "blue includer 1", :content => "{{Blue}}"
+          Card.create! :name => "blue includer 2", :content => "{{blue|closed;other:stuff}}"
+    
+          Card.create! :name => "blue linker 1", :content => "[[Blue]]"
+          Card.create! :name => "blue linker 2", :content => "[[blue]]"
+        end
+      end
+      
+      
+      it "test_updates_inclusions_when_renaming" do
+        c1,c2,c3 = Card["Blue"], Card["blue includer 1"], Card["blue includer 2"]
+        c1.update_attributes :name => "Red", :update_referencers => true
+        assert_equal "{{Red}}", Card.find(c2.id).content                     
+        # NOTE these attrs pass through a hash stage that may not preserve order
+        assert_equal "{{Red|closed;other:stuff}}", Card.find(c3.id).content
+      end
+
+      it "test_updates_inclusions_when_renaming_to_plus" do
+        c1,c2 = Card["Blue"], Card["blue includer 1"]
+        c1.update_attributes :name => "blue includer 1+color", :update_referencers => true
+        assert_equal "{{blue includer 1+color}}", Card.find(c2.id).content                     
+      end
+
+      it "test_reference_updates_on_case_variants" do
+        c1,c2,c3 = Card["Blue"], Card["blue linker 1"], Card["blue linker 2"]
+        c1.reload.name = "Red"
+        c1.update_referencers = true
+        c1.save!
+        assert_equal "[[Red]]", Card.find(c2.id).content
+        assert_equal "[[Red]]", Card.find(c3.id).content
+      end
+    end
+
+  end
+  
+end

data/spec/mods/core/sets/all/type_spec.rb

@@ -0,0 +1,49 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+describe Card::Set::All::Type do
+  
+  describe 'get_type_id (#new)' do
+    it "should accept cardtype name and casespace variant as type" do
+      Card.new( :type=>'Phrase'   ).type_id.should == Card::PhraseID
+      Card.new( :type=>'PHRASE'   ).type_id.should == Card::PhraseID
+      Card.new( :type=>'phrase'   ).type_id.should == Card::PhraseID
+      Card.new( :type=>'phrase??' ).type_id.should == Card::PhraseID
+    end
+      
+    it 'should accept type_code' do
+      Card.new( :type_code=>'phrase'   ).type_id.should == Card::PhraseID
+      Card.new( :type_code=>:phrase    ).type_id.should == Card::PhraseID
+    end
+    
+    it 'should accept type_id' do
+      Card.new( :type_id=>Card::PhraseID   ).type_code.should == :phrase
+    end
+  end
+  
+  describe 'card with wagneered type' do
+    before do
+      Account.as_bot do
+        @type = Card.create! :name=>'Hat', :type=>'Cardtype'
+      end
+      @hat =  Card.new :type=>'Hat'
+    end
+    
+    it 'should have a type_name' do
+      @hat.type_name.should == 'Hat'
+    end
+    
+    it 'should not have a type_code' do
+      @hat.type_code.should == nil
+    end
+    
+    it 'should have a type_id' do
+      @hat.type_id.should == @type.id
+    end
+    
+    it 'should have a type_card' do
+      @hat.type_card.should == @type
+    end
+
+  end
+end

data/spec/mods/core/sets/all/utils_spec.rb

@@ -0,0 +1,6 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+describe Card::Set::All::Utils do
+  # SPECSTUB (low priority)
+end

data/spec/mods/standard/chunks/include_spec.rb

@@ -0,0 +1,182 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+describe Card::Chunk::Include, "Inclusion" do
+  include ActionView::Helpers::TextHelper
+
+  context "syntax parsing" do
+    before do
+      @class= Card::Chunk::Include
+    end
+    
+    it "should ignore invisible comments" do
+      render_content("{{## now you see nothing}}").should==''
+    end
+
+    it "should handle visible comments" do
+      render_content("{{# now you see me}}").should == '<!-- # now you see me -->'
+      render_content("{{# -->}}").should == '<!-- # --&gt; -->'
+    end
+    
+    it "should handle empty inclusions" do
+      instance = @class.new( @class.full_match( '{{ }}' ) , nil )
+      instance.name.should == ''
+    end
+    
+    it "should handle no pipes" do
+      instance = @class.new( @class.full_match( '{{toy}}') , nil )
+      instance.name.should == 'toy'
+      instance.options[:inc_name].should == 'toy'
+      instance.options.key?(:view).should == false
+    end
+    
+    it "should strip the name" do
+      @class.new( @class.full_match( '{{ toy }}') , nil ).name.should == 'toy'
+    end
+    
+    it 'should strip html tags' do
+      @class.new( @class.full_match( '{{ <span>toy</span> }}') , nil ).name.should == 'toy'
+      instance = @class.new( @class.full_match( '{{ <span>toy|open</span> }}') , nil )
+      instance.name.should == 'toy'
+      instance.options[:view].should == 'open'
+    end
+    
+    it "should handle single pipe" do
+      options = @class.new( @class.full_match('{{toy|view:link;hide:me}}'), nil ).options
+      options[:inc_name].should == 'toy'
+      options[:view].should == 'link'
+      options[:hide].should == 'me'
+      options.key?(:items).should == false
+    end
+    
+    it "should handle multiple pipes" do
+      options = @class.new( @class.full_match('{{box|open|closed}}'), nil ).options
+      options[:inc_name].should == 'box'
+      options[:view].should == 'open'
+      options[:items][:view].should == 'closed'
+      options[:items].key?(:items).should == false      
+    end
+
+    it "should handle multiple pipes with blank lists" do
+      options = @class.new( @class.full_match('{{box||closed}}'), nil ).options
+      options[:inc_name].should == 'box'
+      options[:view].should == nil
+      options[:items][:view].should == 'closed'
+    end
+    
+    it "should treat :item as view of next level" do
+      options = @class.new( @class.full_match('{{toy|link;item:name}}'), nil ).options
+      options[:inc_name].should == 'toy'
+      options[:view].should == 'link'
+      options[:items][:view].should == 'name'
+    end
+  end
+
+  context "rendering" do
+
+    it "should handle absolute names" do
+      alpha = newcard 'Alpha', "Pooey"
+      beta = newcard 'Beta', "{{Alpha}}"
+      result = Card::Format.new(beta).render_core
+      assert_view_select result, 'div[class~="card-content"]', "Pooey"
+    end
+
+    it "should handle simple relative names" do
+      alpha = newcard 'Alpha', "{{#{Card::Name.joint}Beta}}"
+      beta = newcard 'Beta'
+      alpha_beta = Card.create :name=>"#{alpha.name}#{Card::Name.joint}Beta", :content=>"Woot"
+      assert_view_select Card::Format.new(alpha).render_core, 'div[class~=card-content]', "Woot"
+    end
+    
+    it "should handle complex relative names" do
+      bob_city = Card.create! :name=>'bob+city', :content=> "Sparta"
+      Account.as_bot { address_tmpl = Card.create! :name=>'address+*right+*structure', :content =>"{{_left+city}}" }
+      bob_address = Card.create! :name=>'bob+address'
+
+      r=Card::Format.new(bob_address.reload).render_core
+      assert_view_select r, 'div[class~=card-content]', "Sparta"
+      Card.fetch("bob+address").includees.map(&:name).should == [bob_city.name]
+    end
+
+    it "should handle nesting" do
+      alpha = newcard 'Alpha', "{{Beta}}"
+      beta = newcard 'Beta', "{{Delta}}"
+      delta = newcard 'Delta', "Booya"
+      r=Card::Format.new( alpha ).render_core
+      #warn "r=#{r}"
+      assert_view_select r, 'div[class~=card-content]'
+      r.should =~ /Booya/
+    end
+
+    it "should handle options when nesting" do
+      Card.create! :type=>'Pointer', :name=>'Livable', :content=>'[[Earth]]'
+      Card.create! :name=>'Earth'
+      
+      render_content('{{Livable|core;item:link}}').should == render_content('{{Livable|core|link}}')
+      render_content('{{Livable|core;item:name}}').should == render_content('{{Livable|core|name}}')
+    end
+    
+    it "should prevent recursion" do
+      oak = Card.create! :name=>'Oak', :content=>'{{Quentin}}'
+      qnt = Card.create! :name=>'Quentin', :content=>'{{Admin}}'
+      adm = Card['Quentin']
+      adm.update_attributes :content => "{{Oak}}"
+      result = Card::Format.new(adm).render_core
+      result.should match('too deep')
+    end
+
+    it "should handle missing cards" do
+      @a = Card.create :name=>'boo', :content=>"hey {{+there}}"
+      r=Card::Format.new(@a).render_core
+      assert_view_select r, 'div[data-card-name="boo+there"][class~="missing-view"]'
+    end
+
+    it "should handle structured cards" do
+      age = newcard('age')
+      template = Card['*template']
+      specialtype = Card.create :type_code=>'Cardtype', :name=>'SpecialType'
+    
+      specialtype_template = specialtype.fetch(:trait=>:type,:new=>{}).fetch(:trait=>:structure,:new=>{})
+      specialtype_template.content = "{{#{Card::Name.joint}age}}"
+      Account.as_bot { specialtype_template.save! }
+      assert_equal "{{#{Card::Name.joint}age}}", Card::Format.new(specialtype_template).render_raw
+    
+      wooga = Card.create! :name=>'Wooga', :type=>'SpecialType'
+      wooga_age = Card.create!( :name=>"#{wooga.name}#{Card::Name.joint}age", :content=> "39" )
+      Card::Format.new(wooga_age).render_core.should == "39"
+      #warn "cards #{wooga.inspect}, #{wooga_age.inspect}"
+      wooga_age.includers.map(&:name).should == ['Wooga']
+    end
+
+    it "should handle shading" do
+      alpha = newcard 'Alpha', "Pooey"
+      beta = newcard 'Beta', "{{Alpha|shade:off}}"
+      r=Card::Format.new(newcard('Bee', "{{Alpha|shade:off}}" )).render_core
+      assert_view_select r, 'div[style~="shade:off;"]' do
+        assert_select 'div[class~=card-content]', "Pooey"
+      end
+      r=Card::Format.new(newcard('Cee', "{{Alpha| shade: off }}" )).render_core
+      assert_view_select r, 'div[style~="shade:off;"]' do
+        assert_select 'div[class~=card-content]', "Pooey"
+      end
+      r=Card::Format.new(newcard('Dee', "{{Alpha| shade:off }}" )).render_core
+      assert_view_select r, 'div[style~="shade:off;"]' do
+        assert_select 'div[class~="card-content"]', "Pooey"
+      end
+      r=Card::Format.new(newcard('Eee', "{{Alpha| shade:on }}" )).render_core
+      assert_view_select r, 'div[style~="shade:on;"]' do
+        assert_select 'div[class~="card-content"]', "Pooey"
+      end
+    end
+
+    #FIXME - should move code and test to core_ext or some such
+    it 'Hash.new_from_semicolon_attr_list should work' do
+      Hash.new_from_semicolon_attr_list("").should == {}
+      Hash.new_from_semicolon_attr_list(nil).should == {}
+      Hash.new_from_semicolon_attr_list("a:b;c:4"  ).should == {:a=>'b', :c=>'4'}
+      Hash.new_from_semicolon_attr_list("d:b;e:4; ").should == {:d=>'b', :e=>'4'}
+    end
+
+  end
+
+end