wagn 1.14.9 → 1.15.pre

data/spec/lib/card/chunk_spec.rb

@@ -1,17 +0,0 @@
-# -*- encoding : utf-8 -*-
-require 'card/chunk'
-
-describe Card::Chunk, "Chunk" do
-  context "Class" do
-    it "should populate prefix map on load" do
-      expect(Card::Chunk.prefix_map.keys.size).to be > 0
-      expect(Card::Chunk.prefix_map['{'][:class]).to eq(Card::Chunk::Include)
-    end
-    
-    it "should find Chunk classes using matched prefix" do
-      expect(Card::Chunk.find_class_by_prefix('{{')).to eq(Card::Chunk::Include)
-    end
-    
-  end
-  
-end

data/spec/lib/card/codename_spec.rb

@@ -1,25 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Codename, "Codename" do
-
-  before do
-    @codename = :default
-  end
-
-  it "should be sane" do    
-    expect(Card[@codename].codename).to eq(@codename.to_s) #would prefer Symbol eventually
-    card_id = Card::Codename[@codename]
-    expect(card_id).to be_a_kind_of Integer
-    expect(Card::Codename[card_id]).to eq(@codename)
-  end
-
-  it "should make cards indestructable" do
-    Card::Auth.as_bot do
-      card = Card[@codename]
-      card.delete
-      expect(card.errors[:delete].first).to match 'is a system card'
-      expect(Card[@codename]).to be
-    end
-  end
-  
-end

data/spec/lib/card/content_spec.rb

@@ -1,314 +0,0 @@
-# -*- encoding : utf-8 -*-
-require 'card/content'
-
-CONTENT = {
-  :one => %(Some Literals: \\[{I'm not| a link]}, and \\{{This Card|Is not Included}}, but {{this is}}, and some tail),
-  #:two => %(Some Links and includes: [[the card|the text]], and {{This Card|Is Included}}{{this too}}
-  #       more formats for links and includes: [the card][the text],
-  #       and [[http://external.wagn.org/path|link text]][This Card][Is linked]{{Included|open}}),
-  :two => %(Some Links and includes: [[the card|the text]], and {{This Card|Is Included}}{{this too}}
-        and [[http://external.wagn.org/path|link text]]{{Included|open}}),
-         
-  :three =>%(Some URIs and Links: http://a.url.com/
-        More urls: wagn.com/a/path/to.html
-        http://localhost:2020/path?cgi=foo&bar=baz  [[http://brain.org/Home|extra]]
-        [ http://gerry.wagn.com/a/path ]
-        { https://brain.org/more?args }),
-  :three_b => %(Some URIs and Links: http://a.url.com
-        More urls: wagn.com/a/path/to.html
-        [ http://gerry.wagn.com/a/path ]
-        { https://brain.org/more?args }
-        http://localhost:2020/path?cgi=foo&bar=baz  [[http://brain.org/Home|extra]]),
-   :four => "No chunks",
-   :five => "{{one inclusion|size;large}}",
-   :six  => %~
-     /* body text */
-     body {
-       color: #444444;
-     }
-
-     /* page - background image and color */
-     body#wagn {
-       background: #ffffff;
-     }
-
-     /* top bar background color; text colors */
-     #menu {
-       background: #3260a0;
-     }
-     #menu a {
-       color: #EEEEEE;
-     }
-
-     /* header text */
-     h1, h2 {
-       color: #664444;
-     }
-     h1.page-header, 
-     h2.page-header {
-       color: #222299; 
-     }
-   ~
-}
-
-CLASSES = {
-   :one => [String, :EscapedLiteral, String, :Include, String ],
-#   :two => [String, Chunk::Link, String, Chunk::Include, Chunk::Include, String, Chunk::Link, String, Chunk::Link, Chunk::Link, Chunk::Include ],
-   :two => [String, :Link, String, :Include, :Include, String, :Link, :Include ],
-   :three => [String, :URI, String, :HostURI, String, :URI, String, :Link, String, :URI, String, :URI, String ],
-   :three_b => [String, :URI, String, :HostURI, String, :URI, String, :URI, String, :URI, String, :Link ],
-   :five => [:Include]
-}
-
-CLASSES.each do |key, val|
-  CLASSES[key] = val.map do |klass|
-    Class === klass ? klass : Card::Chunk.const_get(klass)
-  end
-end
-
-RENDERED = {
-  :one => [
-    "Some Literals: \\[{I'm not| a link]}, and ",
-    "<span>{</span>{This Card|Is not Included}}",
-    ", but ",
-    {:options => {:inc_name=>"this is",:inc_syntax=>"this is"}},
-    ", and some tail"
-  ],
-  :two => [
-    "Some Links and includes: ",
-    "<a class=\"wanted-card\" href=\"/the_card?card%5Bname%5D=the+card\">the text</a>",
-    ", and ",
-    { :options => { :view => "Is Included", :inc_name=>"This Card", :inc_syntax => "This Card|Is Included"}},
-    { :options => { :inc_name=>"this too", :inc_syntax=>"this too"}},
-    "\n        and ",
-    "<a class=\"external-link\" href=\"http://external.wagn.org/path\">link text</a>",
-    { :options => { :view=>"open", :inc_name=>"Included", :inc_syntax=>"Included|open" }}
-  ],
-  :three => [
-    "Some URIs and Links: ", '<a class="external-link" href="http://a.url.com/">http://a.url.com/</a>',
-    "\n        More urls: ",
-    "<a class=\"external-link\" href=\"http://wagn.com/a/path/to.html\">wagn.com/a/path/to.html</a>",
-    "\n        ",
-    "<a class=\"external-link\" href=\"http://localhost:2020/path?cgi=foo&amp;bar=baz\">http://localhost:2020/path?cgi=foo&bar=baz</a>",
-    "  ",
-    "<a class=\"external-link\" href=\"http://brain.org/Home\">extra</a>",
-    "\n        [ ",
-    "<a class=\"external-link\" href=\"http://gerry.wagn.com/a/path\">http://gerry.wagn.com/a/path</a>",
-    " ]\n        { ",
-    "<a class=\"external-link\" href=\"https://brain.org/more?args\">https://brain.org/more?args</a>",
-    " }"
-  ],
-  :three_b => [
-    "Some URIs and Links: ","<a class=\"external-link\" href=\"http://a.url.com\">http://a.url.com</a>",
-    "\n        More urls: ",
-    "<a class=\"external-link\" href=\"http://wagn.com/a/path/to.html\">wagn.com/a/path/to.html</a>",
-    "\n        [ ",
-    "<a class=\"external-link\" href=\"http://gerry.wagn.com/a/path\">http://gerry.wagn.com/a/path</a>",
-    " ]\n        { ",
-    "<a class=\"external-link\" href=\"https://brain.org/more?args\">https://brain.org/more?args</a>",
-    " }\n        ",
-    "<a class=\"external-link\" href=\"http://localhost:2020/path?cgi=foo&amp;bar=baz\">http://localhost:2020/path?cgi=foo&bar=baz</a>",
-    "  ",
-    "<a class=\"external-link\" href=\"http://brain.org/Home\">extra</a>"
-  ],
-  :four => "No chunks"
-}
-TEXT_RENDERED = {
-  :three => [
-    "Some URIs and Links: ", 'http://a.url.com/',
-    "\n        More urls: ",
-    "wagn.com/a/path/to.html[http://wagn.com/a/path/to.html]",
-    "\n        ",
-    "http://localhost:2020/path?cgi=foo&bar=baz",
-    "  ",
-    "extra[http://brain.org/Home]",
-    "\n        [ ",
-    "http://gerry.wagn.com/a/path",
-    " ]\n        { ",
-    "https://brain.org/more?args",
-    " }"
-  ],
-}
-
-describe Card::Content do
-  context "instance" do
-
-    before do
-      @check_proc = Proc.new do |m, v|
-        if Array===m
-          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
-          expect(wrong_class).to be_falsey
-          wrong_class ? false : ( is_last ? true : m[1..-1] )
-        else false end
-      end
-
-      assert card = Card["One"]
-      @card = card
-
-      # non-nil valued opts only ...
-      @render_block =  Proc.new do |opts| {:options => opts.inject({}) {|i,v| !v[1].nil? && i[v[0]]=v[1]; i } } end
-    end
-
-
-    describe 'parse' do
-      it "should find all the chunks and strings" do
-        # note the mixed [} that are considered matching, needs some cleanup ...
-        #warn "cont? #{CONTENT[:one].inspect}"
-        cobj = Card::Content.new CONTENT[:one], @card
-        expect(cobj.inject(CLASSES[:one], &@check_proc)).to eq(true)
-      end
-
-      it "should give just the chunks" do
-        cobj = Card::Content.new CONTENT[:one], @card
-        clist = CLASSES[:one].find_all {|c| String != c }
-        #warn "clist #{clist.inspect}"
-        cobj.each_chunk do |chk|
-          expect(chk).to be_instance_of clist.shift
-        end
-        expect(clist).to be_empty
-      end
-
-      it "should find all the chunks links and trasclusions" do
-        cobj = Card::Content.new CONTENT[:two], @card
-        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
-        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|
-          expect(chk).to be_instance_of clist.shift
-        end
-        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}"
-        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|
-          expect(chk).to be_instance_of clist.shift
-        end
-        expect(clist).to be_empty
-      end
-
-      it "should parse just a string" do
-        cobj = Card::Content.new CONTENT[:four], @card
-        expect(cobj).to eq(RENDERED[:four])
-      end
-
-      it "should parse a single chunk" do
-        cobj = Card::Content.new CONTENT[:five], @card
-        expect(cobj.inject(CLASSES[:five], &@check_proc)).to eq(true)
-        clist = CLASSES[:five].find_all {|c| String != c }
-        cobj.each_chunk do |chk|
-          expect(chk).to be_instance_of clist.shift
-        end
-        expect(clist).to be_empty
-      end
-    
-      it "should leave css alone" do
-        cobj = Card::Content.new CONTENT[:six], @card
-        expect(cobj).to eq(CONTENT[:six])
-      end
-    end
-
-    describe "render" do
-      it "should render all includes" do
-        cobj = Card::Content.new CONTENT[:one], @card
-        expect(cobj.as_json.to_s).to match /not rendered/
-        cobj.process_content_object &@render_block
-        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
-        expect(rdr=cobj.as_json.to_json).not_to match /not rendered/
-        expect(rdr).to eq(RENDERED[:two].to_json)
-      end
-
-      it "renders links correctly for text formatters" do
-        card2 = Card[@card.id]
-        format = card2.format :format => :text
-        cobj = Card::Content.new CONTENT[:three], format
-        cobj.process_content_object &@render_block
-        expect(cobj.as_json.to_json).to eq(TEXT_RENDERED[:three].to_json)
-      end
-
-      it "should not need rendering if no inclusions" do
-        cobj = Card::Content.new CONTENT[:three], @card
-        cobj.process_content_object &@render_block
-        expect(cobj.as_json.to_json).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
-        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
-        expect(rdr=cobj.as_json.to_json).not_to match /not rendered/
-        expect(rdr).to eq(RENDERED[:three_b].to_json)
-      end
-    end
-  end
-  
-  UNTAGGED_CASES = [ ' [grrew][/wiki/grrew]ss ', ' {{this is a test}}, {{this|view|is:too}} and',
-    ' so is http://foo.bar.come//', ' and foo="my attr, not int a tag" <not a=tag ', ' p class"foobar"> and more' ]
-
-  context "class" do
-    describe '#clean!' do
-      it 'should not alter untagged content' do
-        UNTAGGED_CASES.each do |test_case|
-          assert_equal test_case,Card::Content.clean!(test_case)
-        end
-      end
-    
-      it 'should strip disallowed html class attributes' do
-        assert_equal '<p>html<div>with</div> funky tags</p>', Card::Content.clean!('<p>html<div class="boo">with</div><monkey>funky</butts>tags</p>')
-        assert_equal '<span>foo</span>', Card::Content.clean!('<span class="banana">foo</span>')
-      end
-
-      it 'should not strip permitted_classes' do
-        assert_equal '<span class="w-spotlight">foo</span>', Card::Content.clean!('<span class="w-spotlight">foo</span>')
-        assert_equal '<p class="w-highlight w-ok">foo</p>', Card::Content.clean!('<p class="w-highlight w-ok">foo</p>')
-      end
-
-      it 'should strip permitted_classes but not permitted ones when both are present' do
-        assert_equal "<span class='w-spotlight w-ok'>foo</span>", Card::Content.clean!("<span class='w-spotlight banana w-ok'>foo</span>")
-        assert_equal '<p class="w-highlight">foo</p>', Card::Content.clean!('<p class="w-highlight bad-at end">foo</p>')
-        assert_equal '<p class="w-highlight">foo</p>', Card::Content.clean!('<p class="bad-class w-highlight">foo</p>')
-      end
-
-      it 'should allow permitted attributes' do
-        assert_equal '<img src="foo">',   Card::Content.clean!('<img src="foo">')
-        assert_equal "<img alt='foo'>",   Card::Content.clean!("<img alt='foo'>")
-        assert_equal '<img title="foo">', Card::Content.clean!('<img title=foo>')
-        assert_equal '<a href="foo">',    Card::Content.clean!('<a href="foo">')
-        assert_equal '<code lang="foo">', Card::Content.clean!('<code lang="foo">')
-        assert_equal '<blockquote cite="foo">', Card::Content.clean!('<blockquote cite="foo">')
-      end
-
-      it 'should not allow nonpermitted attributes' do
-        assert_equal '<img>', Card::Content.clean!('<img size="25">')
-        assert_equal '<p>',   Card::Content.clean!('<p font="blah">')
-      end
-
-      it 'should remove comments' do
-        assert_equal 'yo', Card::Content.clean!('<!-- not me -->yo')
-        assert_equal 'joe', Card::Content.clean!('<!-- not me -->joe<!-- not me -->')
-      end
-    end
-  end
-  
-  
-end
-

data/spec/lib/card/diff_spec.rb

@@ -1,210 +0,0 @@
-# -*- encoding : utf-8 -*-
-#!/usr/bin/env ruby
-
-require 'card/diff'
-
-describe Card::Diff do
-
-  def del text
-    "<del class='diffdel diff-red'>#{text}</del>"
-  end
-  def ins text
-    "<ins class='diffins diff-green'>#{text}</ins>"
-  end
-  def tag text
-    "&lt;#{text}&gt;"
-  end
-  def diff old_s, new_s, opts=@opts
-    Card::Diff.complete(old_s, new_s, opts)
-  end
-  
-  def summary old_s, new_s, opts=@opts
-    Card::Diff.summary(old_s, new_s, opts)
-  end
-  
-  
-  old_p = '<p>old</p>'
-  new_p = '<p>new</p>'
-  new_h = '<h1>new</h1>'
-  def p_diff
-    diff '<p>old</p>', '<p>new</p>'
-  end
-
-  describe 'traffic light' do
-    it 'is green for addition' do
-      a = "a"
-      b = "a b" 
-      db = Card::Diff::DiffBuilder.new(a,b)
-      expect(db.green?).to be_truthy
-      expect(db.red?).to be_falsey
-    end
-    it 'is red for deletion' do
-      a = "a"
-      b = "" 
-      db = Card::Diff::DiffBuilder.new(a,b)
-      expect(db.green?).to be_falsey
-      expect(db.red?).to be_truthy
-    end
-    it 'is green and red for change' do
-      a = "a"
-      b = "b" 
-      db = Card::Diff::DiffBuilder.new(a,b)
-      expect(db.green?).to be_truthy
-      expect(db.red?).to be_truthy
-    end
-    it 'is off for no change' do
-      a = "a"
-      b = "a" 
-      db = Card::Diff::DiffBuilder.new(a,b)
-      expect(db.green?).to be_falsey
-      expect(db.red?).to be_falsey
-    end
-  end
-  
-  
-  describe 'summary' do
-    before(:all) do
-      @opts = {:format=>:html}
-    end
-    
-    it 'omits unchanged text' do
-      a = "<p>this was the original string</p>"
-      b = "<p>this is the new string</p>" 
-      expect(summary a, b).to eq(
-        "...#{del 'was'}#{ins 'is'}...#{del 'original'}#{ins 'new'}..."
-      )
-    end
-    
-    it 'no ellipsis if changes fit exactly' do
-      a = "123"
-      b = "456" 
-      expect(summary a, b, :summary=>{:length=>6}).to eq(
-        "#{del '123'}#{ins '456'}"
-      )
-    end
-    
-    it 'green ellipsis if added text does not fit' do
-      a = "123"
-      b = "5678" 
-      expect(summary a, b, :summary=>{:length=>6}).to eq(
-        "#{del '123'}#{ins '...'}"
-      )
-    end
-    
-    it 'neutral ellipsis if complete change does not fit' do
-      a = "123 123"
-      b = "456 456" 
-      expect(summary a, b, :summary=>{:length=>9}).to eq(
-        "#{del '123'}#{ins '456'}..."
-      )
-    end
-    
-    it 'red ellipsis if deleted text partially fits' do
-      a = "123456"
-      b = "567" 
-      expect(summary a, b, :summary=>{:length=>4}).to eq(
-        "#{del '1...'}"
-      )
-    end
-    
-    it 'green ellipsis if added text partially fits' do
-      a = "1234"
-      b = "56789" 
-      expect(summary a, b, :summary=>{:length=>8}).to eq(
-        "#{del '1234'}#{ins '5...'}"
-      )
-    end
-    
-    it 'removes html tags' do
-      a = "<a>A</a>"
-      b = "<b>B</b>" 
-      expect(summary a, b, :format=>:html).to eq(
-        "#{del 'A'}#{ins 'B'}"
-      )
-    end
-    
-    it 'with html tags in raw format' do
-      a = "<a>1</a>"
-      b = "<b>1</b>" 
-      expect(summary a, b, :format=>:raw).to eq(
-        "#{del( tag 'a' )}#{ins(tag 'b')}...#{del( tag '/a' )}#{ins(tag '/b')}"
-      )
-    end
-    
-  end
-  
-  context "html format" do
-    before(:all) do
-      @opts = {:format=>:html}
-    end
-    
-    it "doesn't change a text without changes" do
-      text = "Hello World!\n How are you?"
-      expect(diff text, text).to eq(text)
-    end
-    it 'preserves html' do
-      expect(p_diff).to eq("<p>#{del 'old'}#{ins 'new'}</p>")
-    end
-    it 'ignores html changes' do
-      expect(diff old_p, new_h).to eq("<h1>#{del 'old'}#{ins 'new'}</h1>")
-    end
-    
-    it 'diff with multiple paragraphs' do
-      a = "<p>this was the original string</p>"
-      b = "<p>this is</p>\n<p> the new string</p>\n<p>around the world</p>" 
-
-      expect(diff a, b).to eq(
-          "<p>this #{del 'was'}#{ins 'is'}</p>"+
-          "\n<p> the " +
-          "#{del 'original'}#{ins 'new'}" +
-          " string</p>\n" +
-          "<p>#{ins 'around the world'}</p>"
-          )
-    end
-  end
-  
-  context "text format" do
-    before(:all) do
-      @opts = {:format=>:text}
-    end
-  
-    it 'removes html' do
-      expect(p_diff).to eq("#{del 'old'}#{ins 'new'}")
-    end
-    
-    it 'compares complete links' do
-      diff = Card::Diff.complete("[[A]]\n[[B]]", "[[A]]\n[[C]]", :format=>:html)
-      expect(diff).to eq( "[[A]]\n#{del '[[B]]'}#{ins '[[C]]'}")
-    end
-    
-    it 'compares complete inclusions' do
-      diff = Card::Diff.complete("{{A}}\n{{B}}", "{{A}}\n{{C}}", :format=>:html)
-      expect(diff).to eq( "{{A}}\n#{del '{{B}}'}#{ins '{{C}}'}")
-    end
-    
-  end
-  
-  context "raw format" do
-    before(:all) do
-      @opts = {:format=>:raw}
-    end
-  
-    it 'excapes html' do
-      expect(p_diff).to eq("#{tag 'p'}#{del 'old'}#{ins 'new'}#{tag '/p'}")
-    end
-    
-    it 'diff for tag change' do
-      expect(diff old_p, new_h).to eq( del("#{tag 'p'}old#{tag '/p'}") + ins("#{tag 'h1'}new#{tag '/h1'}") )
-    end    
-  end
-  
-  context 'pointer format' do
-    before(:all) do
-      @opts = {:format=>:pointer}
-    end
-    
-    it 'removes square brackets' do
-      expect(diff "[[Hello]]", "[[Hi]]").to eq( del('Hello') + ins('Hi') )
-    end 
-  end
-end