wagn 1.13.0 → 1.14.0.pre1

data/spec/lib/card/content_spec.rb

@@ -123,7 +123,7 @@ describe Card::Content do
           wrong_class = m[0] != v.class
           is_last = m.size == 1
           #warn "check M[#{is_last}]:#{wrong_class}, #{m[0]}, V#{v.inspect}" if wrong_class || is_last
-          wrong_class.should be_false
+          expect(wrong_class).to be_falsey
           wrong_class ? false : ( is_last ? true : m[1..-1] )
         else false end
       end
@@ -141,7 +141,7 @@ describe Card::Content do
         # note the mixed [} that are considered matching, needs some cleanup ...
         #warn "cont? #{CONTENT[:one].inspect}"
         cobj = Card::Content.new CONTENT[:one], @card
-        cobj.inject(CLASSES[:one], &@check_proc).should == true
+        expect(cobj.inject(CLASSES[:one], &@check_proc)).to eq(true)
       end
 
       it "should give just the chunks" do
@@ -149,76 +149,76 @@ describe Card::Content do
         clist = CLASSES[:one].find_all {|c| String != c }
         #warn "clist #{clist.inspect}"
         cobj.each_chunk do |chk|
-          chk.should be_instance_of clist.shift
+          expect(chk).to be_instance_of clist.shift
         end
-        clist.should be_empty
+        expect(clist).to be_empty
       end
 
       it "should find all the chunks links and trasclusions" do
         cobj = Card::Content.new CONTENT[:two], @card
-        cobj.inject(CLASSES[:two], &@check_proc).should == true
+        expect(cobj.inject(CLASSES[:two], &@check_proc)).to eq(true)
       end
 
       it "should find uri chunks " do
         # tried some tougher cases that failed, don't know the spec, so hard to form better tests for URIs here
         cobj = Card::Content.new CONTENT[:three], @card
-        cobj.inject(CLASSES[:three], &@check_proc).should == true
+        expect(cobj.inject(CLASSES[:three], &@check_proc)).to eq(true)
         clist = CLASSES[:three].find_all {|c| String != c }
         #warn "clist #{clist.inspect}, #{cobj.inspect}"
         cobj.each_chunk do |chk|
-          chk.should be_instance_of clist.shift
+          expect(chk).to be_instance_of clist.shift
         end
-        clist.should be_empty
+        expect(clist).to be_empty
       end
 
       it "should find uri chunks (b)" do
         # tried some tougher cases that failed, don't know the spec, so hard to form better tests for URIs here
         cobj = Card::Content.new CONTENT[:three_b], @card
         #warn "cobj #{cobj.inspect} #{CLASSES[:three_b].inspect}"
-        cobj.inject(CLASSES[:three_b], &@check_proc).should == true
+        expect(cobj.inject(CLASSES[:three_b], &@check_proc)).to eq(true)
         clist = CLASSES[:three_b].find_all {|c| String != c }
         #warn "clist #{clist.inspect}, #{cobj.inspect}"
         cobj.each_chunk do |chk|
-          chk.should be_instance_of clist.shift
+          expect(chk).to be_instance_of clist.shift
         end
-        clist.should be_empty
+        expect(clist).to be_empty
       end
 
       it "should parse just a string" do
         cobj = Card::Content.new CONTENT[:four], @card
-        cobj.should == RENDERED[:four]
+        expect(cobj).to eq(RENDERED[:four])
       end
 
       it "should parse a single chunk" do
         cobj = Card::Content.new CONTENT[:five], @card
-        cobj.inject(CLASSES[:five], &@check_proc).should == true
+        expect(cobj.inject(CLASSES[:five], &@check_proc)).to eq(true)
         clist = CLASSES[:five].find_all {|c| String != c }
         cobj.each_chunk do |chk|
-          chk.should be_instance_of clist.shift
+          expect(chk).to be_instance_of clist.shift
         end
-        clist.should be_empty
+        expect(clist).to be_empty
       end
     
       it "should leave css alone" do
         cobj = Card::Content.new CONTENT[:six], @card
-        cobj.should == CONTENT[:six]
+        expect(cobj).to eq(CONTENT[:six])
       end
     end
 
     describe "render" do
       it "should render all includes" do
         cobj = Card::Content.new CONTENT[:one], @card
-        cobj.as_json.to_s.should match /not rendered/
+        expect(cobj.as_json.to_s).to match /not rendered/
         cobj.process_content_object &@render_block
-        (rdr=cobj.as_json.to_json).should_not match /not rendered/
-        rdr.should == RENDERED[:one].to_json
+        expect(rdr=cobj.as_json.to_json).not_to match /not rendered/
+        expect(rdr).to eq(RENDERED[:one].to_json)
       end
 
       it "should render links and inclusions" do
         cobj = Card::Content.new CONTENT[:two], @card
         cobj.process_content_object &@render_block
-        (rdr=cobj.as_json.to_json).should_not match /not rendered/
-        rdr.should == RENDERED[:two].to_json
+        expect(rdr=cobj.as_json.to_json).not_to match /not rendered/
+        expect(rdr).to eq(RENDERED[:two].to_json)
       end
 
       it "should not need rendering if no inclusions" do
@@ -226,15 +226,15 @@ describe Card::Content do
   #      (rdr=cobj.as_json.to_json).should match /not rendered/ # links are rendered too, but not with a block
         cobj.process_content_object &@render_block
         (rdr=cobj.as_json.to_json) #.should_not match /not rendered/
-        rdr.should == RENDERED[:three].to_json
+        expect(rdr).to eq(RENDERED[:three].to_json)
       end
 
       it "should not need rendering if no inclusions (b)" do
         cobj = Card::Content.new CONTENT[:three_b], @card
-        (rdr=cobj.as_json.to_json).should match /not rendered/ # links are rendered too, but not with a block
+        expect(rdr=cobj.as_json.to_json).to match /not rendered/ # links are rendered too, but not with a block
         cobj.process_content_object &@render_block
-        (rdr=cobj.as_json.to_json).should_not match /not rendered/
-        rdr.should == RENDERED[:three_b].to_json
+        expect(rdr=cobj.as_json.to_json).not_to match /not rendered/
+        expect(rdr).to eq(RENDERED[:three_b].to_json)
       end
     end
   end

data/spec/lib/card/diff_spec.rb

@@ -1,110 +1,110 @@
 # -*- encoding : utf-8 -*-
 #!/usr/bin/env ruby
 
-require 'card/diff'
-require 'diff'
-
-describe Card::Diff do
-  include Card::Diff
-
-  before do
-    @builder = Card::Diff::DiffBuilder.new 'old', 'new'
-  end
-
-  it 'should start of tag' do
-    assert @builder.start_of_tag?('<')
-    assert(!@builder.start_of_tag?('>'))
-    assert(!@builder.start_of_tag?('a'))
-  end
-
-  it 'should end of tag' do
-    assert @builder.end_of_tag?('>')
-    assert(!@builder.end_of_tag?('<'))
-    assert(!@builder.end_of_tag?('a'))
-  end
-
-  it 'should whitespace' do
-    assert @builder.whitespace?(" ")
-    assert @builder.whitespace?("\n")
-    assert @builder.whitespace?("\r")
-    assert(!@builder.whitespace?("a"))
-  end
-
-  it 'should convert html to list of words simple' do
-    assert_equal(
-        ['the', ' ', 'original', ' ', 'text'],
-        @builder.convert_html_to_list_of_words('the original text'))
-  end
-
-  it 'should convert html to list of words should separate endlines' do
-    assert_equal(
-        ['a', "\n", 'b', "\r", 'c'],
-        @builder.convert_html_to_list_of_words("a\nb\rc"))
-  end
-
-  it 'should convert html to list of words should not compress whitespace' do
-    assert_equal(
-        ['a', ' ', 'b', '  ', 'c', "\r \n ", 'd'],
-        @builder.convert_html_to_list_of_words("a b  c\r \n d"))
-  end
-
-  it 'should convert html to list of words should handle tags well' do
-    assert_equal(
-        ['<p>', 'foo', ' ', 'bar', '</p>'],
-        @builder.convert_html_to_list_of_words("<p>foo bar</p>"))
-  end
-
-  it 'should convert html to list of words interesting' do
-    assert_equal(
-        ['<p>', 'this', ' ', 'is', '</p>', "\r\n", '<p>', 'the', ' ', 'new', ' ', 'string',
-         '</p>', "\r\n", '<p>', 'around', ' ', 'the', ' ', 'world', '</p>'],
-        @builder.convert_html_to_list_of_words(
-            "<p>this is</p>\r\n<p>the new string</p>\r\n<p>around the world</p>"))
-  end
-
-  it 'should html diff simple' do
-    a = 'this was the original string'
-    b = 'this is the new string'
-    assert_equal('this <del class="diffmod">was</del><ins class="diffmod">is</ins> the ' +
-           '<del class="diffmod">original</del><ins class="diffmod">new</ins> string',
-           diff(a, b))
-  end
-
-  it 'should html diff with multiple paragraphs' do
-    a = "<p>this was the original string</p>"
-    b = "<p>this is</p>\r\n<p> the new string</p>\r\n<p>around the world</p>"
-
-    # Some of this expected result is accidental to implementation.
-    # At least it's well-formed and more or less correct.
-    assert_equal(
-        "<p>this <del class=\"diffmod\">was</del><ins class=\"diffmod\">is</ins></p>"+
-        "<ins class=\"diffmod\">\r\n</ins><p> the " +
-        "<del class=\"diffmod\">original</del><ins class=\"diffmod\">new</ins>" +
-        " string</p><ins class=\"diffins\">\r\n</ins>" +
-        "<p><ins class=\"diffins\">around the world</ins></p>",
-        diff(a, b))
-  end
-
-  # FIXME this test fails (ticket #67, http://dev.instiki.org/ticket/67)
-  it 'should html diff preserves endlines in pre' do
-    a = "<pre>\na\nb\nc\n</pre>"
-    b = "<pre>\n</pre>"
-    assert_equal(
-        "<pre>\n<del class=\"diffdel\">a\nb\nc\n</del></pre>",
-        diff(a, b))
-  end
-
-  it 'should html diff with tags' do
-    a = ""
-    b = "<div>foo</div>"
-    assert_equal '<div><ins class="diffins">foo</ins></div>', diff(a, b)
-  end
-
-  it 'should diff for tag change' do
-    a = "<a>x</a>"
-    b = "<b>x</b>"
-    # FIXME sad, but true - this case produces an invalid XML. If handle this you can, strong your foo is.
-    assert_equal '<a><b>x</a></b>', diff(a, b)
-  end
-
-end
+# require 'card/diff'
+# require 'diff'
+#
+# describe Card::Diff do
+#   include Card::Diff
+#
+#   before do
+#     @builder = Card::Diff::DiffBuilder.new 'old', 'new'
+#   end
+#
+#   it 'should start of tag' do
+#     assert @builder.start_of_tag?('<')
+#     assert(!@builder.start_of_tag?('>'))
+#     assert(!@builder.start_of_tag?('a'))
+#   end
+#
+#   it 'should end of tag' do
+#     assert @builder.end_of_tag?('>')
+#     assert(!@builder.end_of_tag?('<'))
+#     assert(!@builder.end_of_tag?('a'))
+#   end
+#
+#   it 'should whitespace' do
+#     assert @builder.whitespace?(" ")
+#     assert @builder.whitespace?("\n")
+#     assert @builder.whitespace?("\r")
+#     assert(!@builder.whitespace?("a"))
+#   end
+#
+#   it 'should convert html to list of words simple' do
+#     assert_equal(
+#         ['the', ' ', 'original', ' ', 'text'],
+#         @builder.convert_html_to_list_of_words('the original text'))
+#   end
+#
+#   it 'should convert html to list of words should separate endlines' do
+#     assert_equal(
+#         ['a', "\n", 'b', "\r", 'c'],
+#         @builder.convert_html_to_list_of_words("a\nb\rc"))
+#   end
+#
+#   it 'should convert html to list of words should not compress whitespace' do
+#     assert_equal(
+#         ['a', ' ', 'b', '  ', 'c', "\r \n ", 'd'],
+#         @builder.convert_html_to_list_of_words("a b  c\r \n d"))
+#   end
+#
+#   it 'should convert html to list of words should handle tags well' do
+#     assert_equal(
+#         ['<p>', 'foo', ' ', 'bar', '</p>'],
+#         @builder.convert_html_to_list_of_words("<p>foo bar</p>"))
+#   end
+#
+#   it 'should convert html to list of words interesting' do
+#     assert_equal(
+#         ['<p>', 'this', ' ', 'is', '</p>', "\r\n", '<p>', 'the', ' ', 'new', ' ', 'string',
+#          '</p>', "\r\n", '<p>', 'around', ' ', 'the', ' ', 'world', '</p>'],
+#         @builder.convert_html_to_list_of_words(
+#             "<p>this is</p>\r\n<p>the new string</p>\r\n<p>around the world</p>"))
+#   end
+#
+#   it 'should html diff simple' do
+#     a = 'this was the original string'
+#     b = 'this is the new string'
+#     assert_equal('this <del class="diffmod">was</del><ins class="diffmod">is</ins> the ' +
+#            '<del class="diffmod">original</del><ins class="diffmod">new</ins> string',
+#            diff(a, b))
+#   end
+#
+#   it 'should html diff with multiple paragraphs' do
+#     a = "<p>this was the original string</p>"
+#     b = "<p>this is</p>\r\n<p> the new string</p>\r\n<p>around the world</p>"
+#
+#     # Some of this expected result is accidental to implementation.
+#     # At least it's well-formed and more or less correct.
+#     assert_equal(
+#         "<p>this <del class=\"diffmod\">was</del><ins class=\"diffmod\">is</ins></p>"+
+#         "<ins class=\"diffmod\">\r\n</ins><p> the " +
+#         "<del class=\"diffmod\">original</del><ins class=\"diffmod\">new</ins>" +
+#         " string</p><ins class=\"diffins\">\r\n</ins>" +
+#         "<p><ins class=\"diffins\">around the world</ins></p>",
+#         diff(a, b))
+#   end
+#
+#   # FIXME this test fails (ticket #67, http://dev.instiki.org/ticket/67)
+#   it 'should html diff preserves endlines in pre' do
+#     a = "<pre>\na\nb\nc\n</pre>"
+#     b = "<pre>\n</pre>"
+#     assert_equal(
+#         "<pre>\n<del class=\"diffdel\">a\nb\nc\n</del></pre>",
+#         diff(a, b))
+#   end
+#
+#   it 'should html diff with tags' do
+#     a = ""
+#     b = "<div>foo</div>"
+#     assert_equal '<div><ins class="diffins">foo</ins></div>', diff(a, b)
+#   end
+#
+#   it 'should diff for tag change' do
+#     a = "<a>x</a>"
+#     b = "<b>x</b>"
+#     # FIXME sad, but true - this case produces an invalid XML. If handle this you can, strong your foo is.
+#     assert_equal '<a><b>x</a></b>', diff(a, b)
+#   end
+#
+# end

data/spec/lib/card/format_spec.rb

@@ -8,26 +8,26 @@ describe Card::Format do
     end
     
     it "should respect defaults" do
-      @format.show_view?( :menu, :default_visibility=>:show ).should be_true
-      @format.show_view?( :menu, :default_visibility=>:hide ).should be_false
-      @format.show_view?( :menu, {}                          ).should be_true
+      expect(@format.show_view?( :menu, :default_visibility=>:show )).to be_truthy
+      expect(@format.show_view?( :menu, :default_visibility=>:hide )).to be_falsey
+      expect(@format.show_view?( :menu, {}                          )).to be_truthy
     end
     
     it "should respect developer default overrides" do
-      @format.show_view?( :menu, :optional_menu=>:show, :default_visibility=>:hide ).should be_true
-      @format.show_view?( :menu, :optional_menu=>:hide, :default_visibility=>:show ).should be_false
-      @format.show_view?( :menu, :optional_menu=>:hide                             ).should be_false
+      expect(@format.show_view?( :menu, :optional_menu=>:show, :default_visibility=>:hide )).to be_truthy
+      expect(@format.show_view?( :menu, :optional_menu=>:hide, :default_visibility=>:show )).to be_falsey
+      expect(@format.show_view?( :menu, :optional_menu=>:hide                             )).to be_falsey
     end
     
     it "should handle args from inclusions" do
-      @format.show_view?( :menu, :show=>'menu', :default_visibility=>:hide         ).should be_true
-      @format.show_view?( :menu, :hide=>'menu, paging', :default_visibility=>:show ).should be_false
-      @format.show_view?( :menu, :show=>'menu', :optional_menu=>:hide              ).should be_true      
+      expect(@format.show_view?( :menu, :show=>'menu', :default_visibility=>:hide         )).to be_truthy
+      expect(@format.show_view?( :menu, :hide=>'menu, paging', :default_visibility=>:show )).to be_falsey
+      expect(@format.show_view?( :menu, :show=>'menu', :optional_menu=>:hide              )).to be_truthy      
     end
     
     it "should handle hard developer overrides" do
-      @format.show_view?( :menu, :optional_menu=>:always, :hide=>'menu' ).should be_true
-      @format.show_view?( :menu, :optional_menu=>:never,  :show=>'menu' ).should be_false
+      expect(@format.show_view?( :menu, :optional_menu=>:always, :hide=>'menu' )).to be_truthy
+      expect(@format.show_view?( :menu, :optional_menu=>:never,  :show=>'menu' )).to be_falsey
     end
     
   end

data/spec/lib/card/loader_spec.rb

@@ -1,31 +1,37 @@
-
+=begin
 describe Card::Loader do
-  let(:card_double) { proxy Card }
-  let(:pat_all_double) { proxy Card::AllSet }
-  let(:format_double) { proxy Card::Format }
-  let(:html_format_double) { proxy Card::HtmlFormat }
-  it "should auto-load Card class methods from lib/wagn and mods" do
-    card_double.should_receive(:load_set_modules)
-    card_double.should_receive(:load_formats)
-    card_double.should_receive(:load_sets)
-    card_double.should_receive(:tracks).with(:any_args) # so Card still loads without core in failure testing
-    card_double.method(:version).should be
-    card_double.method(:type_card).should be
-    card_double.method(:file_path).should be
-  end
-  it "should define Card methods from modules" do
-    pat_all_double.method(:set_modules).should be
-  end
-  it "should define Formatter methods from modules" do
-    format_double.method(:render_core).should be
-    format_double.method(:_render_raw).should be
-    format_double.method(:render_core).should be
-    format_double.method(:_render_raw).should be
-  end
-  it "should define Formatter methods from modules" do
-    html_format_double.method(:render_core).should be
-    html_format_double.method(:_render_raw).should be
-    html_format_double.method(:render_core).should be
-    html_format_double.method(:_render_raw).should be
-  end
+  # let(:card_double) { double "Card" }
+  # let(:pat_all_double) { proxy Card::AllSet }
+  # let(:format_double) { proxy Card::Format }
+  # let(:html_format_double) { proxy Card::HtmlFormat }
+  # it "should auto-load Card class methods from lib/wagn and mods" do
+  #   #xpect(Card).to receive(:load_mods)
+  #   #
+  #   card = Card[:all]
+  #   expect(card_double).to receive(:load_formats)
+  #   #expect(Card).to receive(:load_sets)
+  #   #expect(Card).to receive(:tracks).with(:any_args) # so Card still loads without core in failure testing
+  #   Card[:all]
+  #   #expect(Card.instance_method(:version)).to be
+  #   # allow(Card).to receive(:version)
+  #   # expect(Card.instance_method(:type_card)).to be
+  #   # allow(Card).to receive(:file_path_sdfs)
+  #   #expect(Card.instance_method(:file_path)).to be
+  # end
+  # it "should define Card methods from modules" do
+  #   expect(Card.instance_method(:set_modules)).to be
+  # end
+  # it "should define Formatter methods from modules" do
+  #   #expect(Card.instance_method(:render_core)).to be
+  #   expect(Card.instance_method(:_render_raw)).to be
+  #   expect(Card.instance_method(:render_core)).to be
+  #   expect(Card.instance_method(:_render_raw)).to be
+  # end
+  # it "should define Formatter methods from modules" do
+  #   expect(html_format_double.method(:render_core)).to be
+  #   expect(html_format_double.method(:_render_raw)).to be
+  #   expect(html_format_double.method(:render_core)).to be
+  #   expect(html_format_double.method(:_render_raw)).to be
+  # end
 end
+=end