wagn 1.14.9 → 1.15.pre

data/mod/01_core/set/all/trash.rb

@@ -1,50 +0,0 @@
-def delete
-  update_attributes :trash => true unless new_card?
-end
-
-def delete!
-  update_attributes! :trash => true unless new_card?
-end
-
-
-event :pull_from_trash, :before=>:store, :on=>:create do
-  if trashed_card = Card.find_by_key_and_trash(key, true)
-    # a. (Rails way) tried Card.where(:key=>'wagn_bot').select(:id), but it wouldn't work.  This #select
-    #    generally breaks on cards. I think our initialization process screws with something
-    # b. (Wagn way) we could get card directly from fetch if we add :include_trashed (eg).
-    #    likely low ROI, but would be nice to have interface to retrieve cards from trash...
-    self.id = trashed_card.id
-    @from_trash = true
-    @new_record = false
-  end
-  self.trash = false
-  true
-end
-
-event :validate_delete, :before=>:approve, :on=>:delete do
-  if !codename.blank?
-    errors.add :delete, "#{name} is is a system card. (#{codename})"
-  end
-  
-  undeletable_all_rules_tags = %w{ default style layout create read update delete }
-  if junction? and l=left and l.codename == 'all' and undeletable_all_rules_tags.member? right.codename
-    errors.add :delete, "#{name} is an indestructible rule"
-  end
-  
-  if account && Card::Act.find_by_actor_id( self.id )
-    errors.add :delete, "Edits have been made with #{name}'s user account.\nDeleting this card would mess up our history."
-  end
-end
-
-event :validate_delete_children, :after=>:approve, :on=>:delete do
-  children.each do |child|
-    child.supercard = self
-    subcards[child.name]=child
-    child.trash = true
-    unless child.valid?
-      child.errors.each do |field, message|
-        errors.add field, "can't delete #{child.name}: #{message}"
-      end
-    end
-  end
-end

data/mod/01_core/set/all/type.rb

@@ -1,85 +0,0 @@
-
-module ClassMethods
-  def default_type_id
-    @@default_type_id ||= Card[:all].fetch( :trait=>:default ).type_id
-  end
-end
-
-def type_card
-  return if type_id.nil?
-  Card.fetch type_id.to_i, :skip_modules=>true
-end
-
-def type_code
-  Card::Codename[ type_id.to_i ]
-end
-
-def type_name
-  type_card.try :name
-end
-
-def type_cardname
-  type_card.try :cardname
-end
-
-def type= type_name
-  self.type_id = Card.fetch_id type_name
-end
-
-def get_type_id args={}
-  return if args[:type_id] # type_id was set explicitly.  no need to set again.
-  
-  type_id = case
-    when args[:type_code]
-      if code=args[:type_code]
-        Card::Codename[code] || ( c=Card[code] and c.id)
-      end
-    when args[:type]
-      Card.fetch_id args[:type]
-    else :noop
-    end
-
-  case type_id
-  when :noop
-  when false, nil
-    errors.add :type, "#{args[:type] || args[:type_code]} is not a known type."
-  else
-    return type_id
-  end
-
-  if name && t=template
-    reset_patterns #still necessary even with new template handling?
-    t.type_id
-  end
-end
-
-
-event :validate_type_change, :before=>:approve, :on=>:update, :changed=>:type_id do
-  if c = dup and c.action == :create and !c.valid?
-    errors.add :type, "of #{ name } can't be changed; errors creating new #{ type_id }: #{ c.errors.full_messages * ', ' }"
-  end
-end
-
-event :validate_type, :before=>:approve, :changed=>:type_id do    
-  if !type_name
-    errors.add :type, "No such type"
-  end
-  
-  if rt = structure and rt.assigns_type? and type_id!=rt.type_id
-    errors.add :type, "can't be changed because #{name} is hard templated to #{rt.type_name}"
-  end
-end
-
-event :reset_type_specific_fields, :after=>:store do
-  Auth.as_bot do
-    Card.search :left=>{ :left=>type_name }, :right=>{:codename=>'type_plus_right'} do |set_card|
-      set_card.reset_set_patterns
-    end
-  end
-end
-
-#    Card.search :left_plus=>[ type_name, :right_plus=>{:codename=>'type_plus_right'}] do |right_anchor|
-#      Card["#{lef}"]
-#      set_card.reset_set_patterns
-#    end
-  

data/mod/01_core/set/all/utils.rb

@@ -1,94 +0,0 @@
-
-module ClassMethods
-  
-  def empty_trash
-    Card.where(:trash=>true).delete_all
-    Card::Action.delete_cardless
-    Card::Reference.repair_missing_referees
-    Card::Reference.delete_missing_referers
-    Card.delete_trashed_files
-  end
-  
-  def delete_trashed_files #deletes any file not associated with a real card.
-    dir = Wagn.paths['files'].existent.first
-    trashed_card_sql = %{ select id from cards where trash is true }
-    trashed_card_ids = Card.connection.select_all( trashed_card_sql ).map( &:values ).flatten.map &:to_i
-    file_ids = Dir.entries( dir )[2..-1].map( &:to_i )
-    file_ids.each do |file_id|
-      if trashed_card_ids.member?(file_id)
-        raise Card::Error, "Narrowly averted deleting current file" if Card.exists?(file_id) #double check!
-        FileUtils.rm_rf "#{dir}/#{file_id}", :secure => true
-      end
-    end
-  end
-  
-  def delete_tmp_files id=nil
-    dir = Wagn.paths['files'].existent.first + '/tmp'
-    dir += "/#{id}" if id
-    FileUtils.rm_rf dir, :secure=>true
-  rescue
-    Rails.logger.info "failed to remove tmp files"
-  end
-  
-  
-  def merge_list attribs, opts
-    unmerged = []
-    attribs.each do |row|
-      result = begin
-        merge row['name'], row, opts
-#      rescue => e
-#        Rails.logger.info "merge_list problem: #{ e.message }"
-#        false
-      end
-      unmerged.push row unless result == true
-    end
-            
-    if unmerged.empty?
-      Rails.logger.info "successfully merged all!"
-    else
-      unmerged_json = JSON.pretty_generate unmerged
-      if output_file = opts[:output_file]
-        ::File.open output_file, 'w' do |f|
-          f.write unmerged_json
-        end
-      else
-        Rails.logger.info "failed to merge:\n\n#{ unmerged_json }"
-      end
-    end
-  end    
-    
-  
-  def merge name, attribs={}, opts={}
-    puts "merging #{ name }"
-    card = fetch name, :new=>{}
-    
-    if opts[:pristine] && !card.pristine?
-      false
-    else
-      card.attributes = attribs
-      card.save!
-    end
-  end
-  
-end
-
-def debug_type
-  "#{type_code||'no code'}:#{type_id}"
-end
-
-def to_s
-  "#<#{self.class.name}[#{debug_type}]#{self.attributes['name']}>"
-end
-
-def inspect
-  "#<#{self.class.name}" + "##{id}" +
-  "###{object_id}" + #"l#{left_id}r#{right_id}" +
-  "[#{debug_type}]" + "(#{self.name})" + #"#{object_id}" +
-  #(errors.any? ? '*Errors*' : 'noE') +
-  (errors.any? ? "<E*#{errors.full_messages*', '}*>" : '') +
-  #"{#{references_expired==1 ? 'Exp' : "noEx"}:" +
-  "{#{trash&&'trash:'||''}#{new_card? &&'new:'||''}#{frozen? ? 'Fz' : readonly? ? 'RdO' : ''}" +
-  "#{@virtual &&'virtual:'||''}#{@set_mods_loaded&&'I'||'!loaded' }:#{references_expired.inspect}}" +
-  '>'
-end
-

data/mod/01_core/set_pattern/01_all.rb

@@ -1,7 +0,0 @@
-def label name
-  'All cards'
-end
-
-def prototype_args anchor
-  {}
-end

data/mod/01_core/set_pattern/02_all_plus.rb

@@ -1,9 +0,0 @@
-@@options = { :junction_only => true }
-
-def label name
-  'All "+" cards'
-end
-
-def prototype_args anchor
-  { :name=>'+' }
-end

data/mod/01_core/set_pattern/03_type.rb

@@ -1,19 +0,0 @@
-def label name
-  %{All "#{name}" cards}
-end
-
-def prototype_args anchor
-  { :type=>anchor }
-end
-
-def pattern_applies? card
-  !!card.type_id
-end
-
-def anchor_name card
-  card.type_name
-end
-
-def anchor_id card
-  card.type_id
-end

data/mod/01_core/set_pattern/04_star.rb

@@ -1,11 +0,0 @@
-def label name
-  'All "*" cards'
-end
-
-def prototype_args anchor
-  { :name=>'*dummy' }
-end
-
-def pattern_applies? card
-  card.cardname.star?
-end

data/mod/01_core/set_pattern/05_rstar.rb

@@ -1,13 +0,0 @@
-@@options = { :junction_only => true }
-
-def label name
-  'All "+*" cards'
-end
-
-def prototype_args anchor
-  { :name=>'*dummy+*dummy' }
-end
-
-def pattern_applies? card
-  card.cardname.rstar?
-end

data/mod/01_core/set_pattern/06_right.rb

@@ -1,16 +0,0 @@
-@@options = { 
-  :junction_only => true,
-  :assigns_type=>true
-}
-
-def label name
-  %{All "+#{name}" cards}
-end
-
-def prototype_args anchor
-  { :name=>"*dummy+#{anchor}" }
-end
-
-def anchor_name card
-  card.cardname.tag
-end

data/mod/01_core/set_pattern/07_type_plus_right.rb

@@ -1,19 +0,0 @@
-@@options = {
-  :junction_only=>true,
-  :assigns_type=>true,
-  :anchor_parts_count=>2
-}
-
-def label name
-  %{All "+#{name.to_name.tag}" cards on "#{name.to_name.left_name}" cards}
-end
-
-def prototype_args anchor
-  { :name=>"+#{anchor.tag}", :supercard=>Card.new( :name=>'*dummy', :type=>anchor.trunk_name ) }
-end
-
-def anchor_name card
-  left = card.left
-  type_name = (left && left.type_name) || Card[ Card.default_type_id ].name
-  "#{type_name}+#{card.cardname.tag}"
-end

data/mod/01_core/set_pattern/08_self.rb

@@ -1,15 +0,0 @@
-def label name
-  %{The card "#{name}"}
-end
-
-def prototype_args anchor
-  { :name=>anchor }
-end
-
-def anchor_name card
-  card.name
-end
-
-def anchor_id card
-  card.id
-end

data/mod/01_core/spec/chunk/literal_spec.rb

@@ -1,14 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Chunk::EscapedLiteral, "literal chunk tests" do
-
-  it "should handle escaped link" do
-    expect(render_content('write this: \[[text]]')).to eq('write this: <span>[</span>[text]]')
-  end
-
-  it "should handle escaped inclusion" do
-    expect(render_content('write this: \{{cardname}}')).to eq('write this: <span>{</span>{cardname}}')
-  end
-
-end
-

data/mod/01_core/spec/chunk/uri_spec.rb

@@ -1,292 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Chunk::URI, "URI chunk tests" do
-  it "should test_non_matches" do
-    no_match(Card::Chunk::URI, 'There is no URI here')
-    no_match(Card::Chunk::URI,
-        'One gemstone is the garnet:reddish in colour, like ruby')
-  end
-
-  it "should test_simple_uri" do
-    # Simplest case
-    match_chunk(Card::Chunk::URI, 'http://www.example.com',
-      :scheme =>'http', :host =>'www.example.com', :path => '',
-      :link_text => 'http://www.example.com'
-    )
-  end
-  it "should work with trailing slash" do
-    match_chunk(Card::Chunk::URI, 'http://www.example.com/',
-      :scheme =>'http', :host =>'www.example.com', :path => '/',
-      :link_text => 'http://www.example.com/'
-    )
-  end
-  it "should work with trailing slash inside html tags" do
-    match_chunk(Card::Chunk::URI, '<p>http://www.example.com/</p>',
-      :scheme =>'http', :host =>'www.example.com', :path => '/',
-      :link_text => 'http://www.example.com/'
-    )
-  end
-  it "should work with trailing period (no longer suppressed .. spec?)" do
-    match_chunk(Card::Chunk::URI, 'http://www.example.com/. ',
-      :scheme =>'http', :host =>'www.example.com', :path => '/',
-      :link_text => 'http://www.example.com/'
-    )
-  end
-  it "should work with trailing period inside html tags (dot change?)" do
-    match_chunk(Card::Chunk::URI, '<p>http://www.example.com/.</p>',
-      :scheme =>'http', :host =>'www.example.com', :path => '/',
-      :link_text => 'http://www.example.com/'
-    )
-  end
-  it "should work with trailing &nbsp;" do
-    match_chunk(Card::Chunk::URI, 'http://www.example.com/&nbsp;',
-      :scheme =>'http', :host =>'www.example.com', :path => '/',
-      :link_text => 'http://www.example.com/'
-    )
-  end
-  it "should work without http://" do
-    match_chunk(Card::Chunk::URI, 'www.example.com',
-      :scheme =>'http', :host =>'www.example.com', :text => 'www.example.com', :link_text => 'http://www.example.com'
-    )
-    match_chunk(Card::Chunk::URI, 'example.com',
-      :scheme =>'http',:host =>'example.com', :text => 'example.com', :link_text => 'http://example.com'
-    )
-  end
-  it "should match \"unusual\" base domain (was a bug in an early version)" do
-    match_chunk(Card::Chunk::URI, 'http://example.com.au/',
-      :scheme =>'http', :host =>'example.com.au', :link_text => 'http://example.com.au/'
-    )
-  end
-  it 'should work with "unusual" base domain without http://' do
-    match_chunk(Card::Chunk::URI, 'example.com.au',
-      :scheme =>'http', :host =>'example.com.au', :text => 'example.com.au', :link_text => 'http://example.com.au'
-    )
-  end
-  it 'should work with another "unusual" base domain' do
-    match_chunk(Card::Chunk::URI, 'http://www.example.co.uk/',
-      :scheme =>'http', :host =>'www.example.co.uk',
-      :link_text => 'http://www.example.co.uk/'
-    )
-    match_chunk(Card::Chunk::URI, 'example.co.uk',
-      :scheme =>'http', :host =>'example.co.uk', :link_text => 'http://example.co.uk', :text => 'example.co.uk'
-    )
-  end
-  it "should work with some path at the end" do
-    match_chunk(Card::Chunk::URI, 'http://moinmoin.wikiwikiweb.de/HelpOnNavigation',
-      :scheme => 'http', :host => 'moinmoin.wikiwikiweb.de', :path => '/HelpOnNavigation',
-      :link_text => 'http://moinmoin.wikiwikiweb.de/HelpOnNavigation'
-    )
-  end
-  it "should work with some path at the end, and withot http:// prefix (@link_text has prefix added)" do
-    match_chunk(Card::Chunk::URI, 'moinmoin.wikiwikiweb.de/HelpOnNavigation',
-      :scheme => 'http', :host => 'moinmoin.wikiwikiweb.de', :path => '/HelpOnNavigation',
-      :text => 'moinmoin.wikiwikiweb.de/HelpOnNavigation',
-      :link_text => 'http://moinmoin.wikiwikiweb.de/HelpOnNavigation'
-    )
-  end
-  it "should work with a port number" do
-    match_chunk(Card::Chunk::URI, 'http://www.example.com:80',
-       :scheme =>'http', :host =>'www.example.com', :port => 80, :path => '',
-       :link_text => 'http://www.example.com:80')
-  end
-  it "should work with a port number and a path" do
-    match_chunk(Card::Chunk::URI, 'http://www.example.com.tw:80/HelpOnNavigation',
-        :scheme =>'http', :host =>'www.example.com.tw', :port => 80, :path => '/HelpOnNavigation',
-        :link_text => 'http://www.example.com.tw:80/HelpOnNavigation')
-  end
-  it "should work with a query" do
-    match_chunk(Card::Chunk::URI, 'http://www.example.com.tw:80/HelpOnNavigation?arg=val',
-        :scheme =>'http', :host =>'www.example.com.tw', :port => 80, :path => '/HelpOnNavigation',
-        :query => 'arg=val',
-        :link_text => 'http://www.example.com.tw:80/HelpOnNavigation?arg=val')
-  end
-  it "should work on Query with two arguments" do
-    match_chunk(Card::Chunk::URI, 'http://www.example.com.tw:80/HelpOnNavigation?arg=val&arg2=val2',
-        :scheme =>'http', :host =>'www.example.com.tw', :port => 80, :path => '/HelpOnNavigation',
-        :query => 'arg=val&arg2=val2',
-        :link_text => 'http://www.example.com.tw:80/HelpOnNavigation?arg=val&arg2=val2')
-  end
-  it "should work with IRC" do
-    match_chunk(Card::Chunk::URI, 'irc://irc.freenode.net#recentchangescamp',
-        :scheme =>'irc', :host =>'irc.freenode.net',
-        :fragment => 'recentchangescamp',
-        :link_text => 'irc://irc.freenode.net#recentchangescamp')
-  end
-
-  it "should see HTTPS" do
-    match_chunk(Card::Chunk::URI, 'https://www.example.com',
-        :scheme =>'https', :host =>'www.example.com', :port => 443, :path => '', :query => nil,
-        :link_text => 'https://www.example.com')
-  end
-  it "should see FTP" do
-    match_chunk(Card::Chunk::URI, 'ftp://www.example.com',
-        :scheme =>'ftp', :host =>'www.example.com', :port => 21, :path => '', :query => nil,
-        :link_text => 'ftp://www.example.com')
-  end
-  it "should handle mailto:" do
-    match_chunk(Card::Chunk::URI, 'mailto:jdoe123@example.com',
-        :scheme =>'mailto', :host =>nil, :port => nil, :path => nil, :query => nil,
-        :to => 'jdoe123@example.com', :link_text => 'mailto:jdoe123@example.com')
-  end
-    # something nonexistant (pending spec?  this is no longer recognized, the sheme has to be listed)
-    #match_chunk(Card::Chunk::URI, 'foobar://www.example.com',
-    #    :scheme =>'foobar', :host =>'www.example.com', :port => '', :path => '', :query => nil,
-    #    :link_text => 'foobar://www.example.com')
-
-  it "should run more basic cases" do
-
-    # from *css (with () around the URI)
-    # so, now this doesn't even match because I fixed the suspiciou* stuff
-    no_match(Card::Chunk::URI, "background: url('http://dl.dropbox.com/u/4657397/wikirate/wikirate_files/wr-bg-menu-line.gif') repeat-x;")
-
-    # Soap opera (the most complex case imaginable... well, not really, there should be more evil)
-    match_chunk(Card::Chunk::URI, 'http://www.example.com.tw:80/~jdoe123/Help%20Me%20?arg=val&arg2=val2',
-        :scheme =>'http', :host =>'www.example.com.tw', :port => 80,
-        :path => '/~jdoe123/Help%20Me%20', :query => 'arg=val&arg2=val2',
-        :link_text => 'http://www.example.com.tw:80/~jdoe123/Help%20Me%20?arg=val&arg2=val2')
-
-    # from 0.9 bug reports
-    match_chunk(Card::Chunk::URI, 'http://www2.pos.to/~tosh/ruby/rdtool/en/doc/rd-draft.html',
-        :scheme =>'http', :host => 'www2.pos.to',
-        :path => '/~tosh/ruby/rdtool/en/doc/rd-draft.html')
-
-    match_chunk(Card::Chunk::URI, 'http://support.microsoft.com/default.aspx?scid=kb;en-us;234562',
-        :scheme =>'http', :host => 'support.microsoft.com', :path => '/default.aspx',
-        :query => 'scid=kb;en-us;234562')
-
-  end
-
-  it "should test_email_uri" do
-    match_chunk(Card::Chunk::URI, 'mail@example.com',
-      :to => 'mail@example.com', :host => nil, :text => 'mail@example.com', :link_text => 'mailto:mail@example.com'
-    )
-  end
-
-  it "should test_non_email" do
-    # The @ is part of the normal text, but 'example.com' is marked up.
-     match_chunk(Card::Chunk::URI, 'Not an email: @example.com', :uri => 'http://example.com')
-  end
-
-  it "should test_textile_image" do
-    no_match(Card::Chunk::URI,
-             'This !http://hobix.com/sample.jpg! is a Textile image link.')
-  end
-
-  it "should test_textile_link" do
-    no_match(Card::Chunk::URI,
-             'This "hobix (hobix)":http://hobix.com/sample.jpg is a Textile link.')
-    # just to be sure ...
-    match_chunk(Card::Chunk::URI, 'This http://hobix.com/sample.jpg should match',
-          :link_text => 'http://hobix.com/sample.jpg')
-  end
-
-  it "should test_inline_html" do
-    no_match(Card::Chunk::URI, "<img src='http://hobix.com/sample.jpg'/>")
-    no_match(Card::Chunk::URI, '<IMG SRC="http://hobix.com/sample.jpg">')
-  end
-
-  it "should test_non_uri" do
-    # "so" is a valid country code; "libproxy.so" is a valid url
-    match_chunk(Card::Chunk::URI, 'libproxy.so', :host => 'libproxy.so', :text => 'libproxy.so', :link_text => 'http://libproxy.so')
-
-    no_match Card::Chunk::URI, 'httpd.conf'
-    # THIS ONE'S BUSTED.. Ethan fix??
-    #no_match Card::Chunk::URI, 'ld.so.conf'
-    no_match Card::Chunk::URI, 'index.jpeg'
-    no_match Card::Chunk::URI, 'index.jpg'
-    no_match Card::Chunk::URI, 'file.txt'
-    no_match Card::Chunk::URI, 'file.doc'
-    no_match Card::Chunk::URI, 'file.pdf'
-    no_match Card::Chunk::URI, 'file.png'
-    no_match Card::Chunk::URI, 'file.ps'
-  end
-
-  it "should test_uri_in_text" do
-    match_chunk(Card::Chunk::URI, 'Go to: http://www.example.com/', :host => 'www.example.com', :path =>'/')
-    match_chunk(Card::Chunk::URI, 'http://www.example.com/ is a link.', :host => 'www.example.com')
-    match_chunk(Card::Chunk::URI,
-        'Email david@loudthinking.com',
-        :scheme =>'mailto', :to =>'david@loudthinking.com', :host => nil)
-    # check that trailing punctuation is not included in the hostname
-    match_chunk(Card::Chunk::URI, 'Hey dude, http://fake.link.com.', :scheme => 'http', :host => 'fake.link.com')
-    # this is a textile link, no match please.
-    no_match(Card::Chunk::URI, '"link":http://fake.link.com.')
-   end
-
-  it "should test_uri_in_parentheses" do
-    match_chunk(Card::Chunk::URI, 'URI (http://brackets.com.de) in brackets', :host => 'brackets.com.de')
-    match_chunk(Card::Chunk::URI, 'because (as shown at research.net) the results', :host => 'research.net')
-    match_chunk(Card::Chunk::URI,
-      'A wiki (http://wiki.org/wiki.cgi?WhatIsWiki) card',
-      :scheme => 'http', :host => 'wiki.org', :path => '/wiki.cgi', :query => 'WhatIsWiki'
-    )
-  end
-
-  it "should test_uri_list_item" do
-    match_chunk(
-      Card::Chunk::URI,
-      '* http://www.btinternet.com/~mail2minh/SonyEricssonP80xPlatform.sis',
-      :path => '/~mail2minh/SonyEricssonP80xPlatform.sis'
-    )
-  end
-
-  it "should test_interesting_uri_with__comma" do
-    # Counter-intuitively, this URL matches, but the query part includes the trailing comma.
-    # It has no way to know that the query does not include the comma.
-    # The trailing , addition breaks this test, but is this test actually valid?
-    # It seems better to exclude the comma from the uri, YMMV
-    match_chunk(
-        Card::Chunk::URI,
-        "This text contains a URL http://someplace.org:8080/~person/stuff.cgi?arg=val, doesn't it?",
-        :scheme => 'http', :host => 'someplace.org', :port => 8080, :path => '/~person/stuff.cgi',
-        :query => 'arg=val')
-  end
-
- describe Card::Chunk::URI, "URI chunk tests" do
-  it "should test_local_urls" do
-    # normal
-    match_chunk(Card::Chunk::URI, 'http://perforce:8001/toto.html',
-          :scheme => 'http', :host => 'perforce',
-          :port => 8001, :link_text => 'http://perforce:8001/toto.html')
-
-    # in parentheses
-    match_chunk(Card::Chunk::URI, 'URI (http://localhost:2500) in brackets',
-          :host => 'localhost', :port => 2500)
-    match_chunk(Card::Chunk::URI, 'because (as shown at http://perforce:8001) the results',
-          :host => 'perforce', :port => 8001)
-    match_chunk(Card::Chunk::URI,
-      'A wiki (http://localhost:2500/wiki.cgi?WhatIsWiki) card',
-          :scheme => 'http', :host => 'localhost', :path => '/wiki.cgi',
-          :port => 2500, :query => 'WhatIsWiki')
-  end
- end
-
-  private
-  DUMMY_CARD = Card.new(:name=>'dummy')
-
-  # Asserts a number of tests for the given type and text.
-  def no_match(type, test_text)
-    test_cont = Card::Content.new(test_text, DUMMY_CARD)
-    expect( ((test_cont.respond_to? :each) ? test_cont : [test_cont]).find{|ck| type===ck } ).to be_nil
-  end
-
-  def aa_match(type, test_text)
-    test_cont = Card::Content.new(test_text, DUMMY_CARD)
-    expect( ((test_cont.respond_to? :each) ? test_cont : [test_cont]).find{|ck| type===ck } ).not_to be_nil
-  end
-
-  def match_chunk(type, test_text, expected)
-    test_cont = Card::Content.new(test_text, DUMMY_CARD)
-    chunk = ((test_cont.respond_to? :each) ? test_cont : [test_cont]).find{ |ck| type===ck }
-    #warn "chunk? #{chunk.inspect}"
-    expect(chunk).not_to be_nil
-
-    expected.each_pair do |method_sym, value|
-      #assert_respond_to(chunk, method_sym)
-      cvalue = chunk.method(method_sym).call
-      cvalue = cvalue.to_s if method_sym == :uri
-      assert_equal(value, cvalue, "Checking value of '#{method_sym}'")
-    end
-  end
-
-end