card 1.18.0 → 1.18.1

data/mod/01_core/format/html_format.rb

@@ -5,8 +5,6 @@ require_dependency 'card/diff'
 class Card
   Format.register :html
   class HtmlFormat < Format
-    include Diff
-
     attr_accessor :options_need_save, :start_time, :skip_autosave
 
     # builtin layouts allow for rescue / testing

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

@@ -17,7 +17,6 @@ def abort status, msg='action canceled'
   end
   raise Card::Abort.new(status, msg)
 end
-
 module ClassMethods
   def create! opts
     card = Card.new opts
@@ -48,6 +47,18 @@ def delete!
   end
 end
 
+def save!(*)
+  act do
+    super
+  end
+end
+
+def save(*)
+  act do
+    super
+  end
+end
+
 def update_attributes opts
   act do
     super opts

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

@@ -177,14 +177,14 @@ format do
 
   def each_reference_with_args args={}
     content_object = Card::Content.new _render_raw(args), card
-    content_object.find_chunks(Card::Chunk::Reference).each do |chunk|
+    content_object.find_chunks(Card::Content::Chunk::Reference).each do |chunk|
       yield chunk.referee_name.to_s, nest_args(args, chunk)
     end
   end
 
   def each_nested_chunk args={}
     content_object = Card::Content.new(_render_raw(args), card)
-    content_object.find_chunks(Card::Chunk::Include).each do |chunk|
+    content_object.find_chunks(Card::Content::Chunk::Include).each do |chunk|
       yield(chunk) if chunk.referee_name # filter commented nests
     end
   end
@@ -237,9 +237,9 @@ format do
     r_args.merge! @nest_opts.clone if @nest_opts
 
     case chunk
-    when Card::Chunk::Include
+    when Card::Content::Chunk::Include
       r_args.merge!(chunk.options)
-    when Card::Chunk::Link
+    when Card::Content::Chunk::Link
       r_args.reverse_merge!(view: :link)
       r_args.reverse_merge!(title: chunk.link_text) if chunk.link_text
     end

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

@@ -108,33 +108,6 @@ module ClassMethods
     Card.cache.delete "~#{card.id}" if card.id
   end
 
-  # set_names reverse map (cached)
-  # FIXME: move to set handling
-  def cached_set_members key
-    set_cache_list = Card.cache.read "$#{key}"
-    set_cache_list.nil? ? [] : set_cache_list.keys
-  end
-
-  # updates the members hash for all sets self is a member of
-  # QUESTION: why map and not each?
-  # I don't see where that array is useful. It contains
-  # nil for all sets for which self was already cached as a member
-  def set_members set_names, key
-    set_names.compact.map do |set_name|
-      # dollar sign avoids conflict with card keys
-      skey = "$#{set_name.to_name.key}"
-      h = Card.cache.read skey
-      if h.nil?
-        h = {}
-      elsif h[key]
-        next
-      end
-      h = h.dup if h.frozen?
-      h[key] = true
-      Card.cache.write skey, h
-    end
-  end
-
   def validate_fetch_opts! opts
     return unless opts[:new] && opts[:skip_virtual]
     raise Card::Error, 'fetch called with new args and skip_virtual'

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

@@ -30,21 +30,42 @@ def name= newname
   end
 
   newkey = cardname.key
-  if key != newkey
-    self.key = newkey
-    # reset the old name - should be handled in tracked_attributes!!
-    reset_patterns_if_rule
-    reset_patterns
-  end
-  if @director
-    subcards.each do |subcard|
-      subcard.name = subcard.cardname.replace_part name, newname
-    end
-  end
-
+  self.key = newkey if key != newkey
+  update_subcard_names cardname
   write_attribute :name, cardname.s
 end
 
+def key= newkey
+  was_in_cache = Card.cache.soft.delete key
+  write_attribute :key, newkey
+  # keep the soft cache up-to-date
+  Card.write_to_soft_cache self if was_in_cache
+  # reset the old name - should be handled in tracked_attributes!!
+  reset_patterns_if_rule
+  reset_patterns
+  newkey
+end
+
+def update_subcard_names cardname
+  return unless @subcards
+  subcards.each do |subcard|
+    # if subcard has a relative name like +C
+    # and self is a subcard as well that changed from +B to A+B then
+    # +C should change to A+B+C. #replace_part doesn't work in this case
+    # because the old name +B is not a part of +C
+    # name_to_replace =
+    name_to_replace =
+      if subcard.cardname.junction? &&
+         subcard.cardname.parts.first.empty? &&
+         cardname.parts.first.present?
+        ''.to_name
+      else
+        name
+      end
+    subcard.name = subcard.cardname.replace_part name_to_replace, cardname.s
+  end
+end
+
 def cardname
   name.to_name
 end

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

@@ -24,7 +24,7 @@ def reset_patterns_if_rule saving=false
 
     # FIXME: should be in right/read.rb
     if saving && right.id == Card::ReadID
-      add_to_read_rule_update_queue(set.item_cards limit: 0)
+      add_to_read_rule_update_queue set.item_cards(limit: 0)
     end
   end
 end
@@ -47,14 +47,10 @@ def set_format_modules klass
 end
 
 def set_names
-  if @set_names.nil?
-    @set_names = patterns.map(&:to_s)
-    Card.set_members @set_names, key
-  end
+  @set_names = patterns.map(&:to_s) if @set_names.nil?
   @set_names
 end
 
 def rule_set_keys
-  set_names # this triggers set_members cache.  need better solution!
   @rule_set_keys ||= patterns.map(&:rule_set_key).compact
 end

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

@@ -1,5 +1,4 @@
 def prepare_for_phases
-  identify_action
   reset_patterns
   include_set_modules
 end

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

@@ -44,7 +44,7 @@ end
 # replace references in card content
 def replace_reference_syntax old_name, new_name
   obj_content = Card::Content.new raw_content, self
-  obj_content.find_chunks(Card::Chunk::Reference).select do |chunk|
+  obj_content.find_chunks(Card::Content::Chunk::Reference).select do |chunk|
     next unless (old_ref_name = chunk.referee_name)
     next unless (new_ref_name = old_ref_name.replace_part old_name, new_name)
     chunk.referee_name = chunk.replace_reference old_name, new_name
@@ -66,7 +66,7 @@ end
 def create_references_out
   ref_hash = {}
   content_obj = Card::Content.new raw_content, self
-  content_obj.find_chunks(Card::Chunk::Reference).each do |chunk|
+  content_obj.find_chunks(Card::Content::Chunk::Reference).each do |chunk|
     interpret_reference ref_hash, chunk.referee_name, chunk.reference_code
   end
   return if ref_hash.empty?

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

@@ -209,14 +209,21 @@ module ClassMethods
     end
   end
 
-  def preference_cards user_name, setting_code
+  def preference_names user_name, setting_code
     Card.search(
       { right: { codename: setting_code },
-        left: { left: { type_id: SetID }, right: user_name }
-      }, "rule cards for user: #{user_name}"
+        left: {
+          left: { type_id: SetID }, right: user_name
+        },
+        return: :name
+      }, "preference cards for user: #{user_name}"
     )
   end
 
+  def preference_cards user_name, setting_code
+    preference_names(user_name, setting_code).map { |name| Card.fetch name }
+  end
+
   def rule_cache
     Card.cache.read('RULES') || begin
       @rule_hash = {}

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

@@ -74,7 +74,6 @@ event :update_ruled_cards, :finalize do
     # warn "updating ruled cards for #{name}"
     self.class.clear_rule_cache
     set = rule_set
-    set.reset_set_patterns
 
     if right_id == Card::ReadID && (name_changed? || trash_changed?)
       update_read_ruled_cards set

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

@@ -51,17 +51,3 @@ event :validate_type, :validate, changed: :type_id do
                       "to #{rt.type_name}"
   end
 end
-
-event :reset_type_specific_fields, :finalize do
-  # Example: if you save a card of type Phrase
-  # then reset set patterns for update all
-  # "Phrase+Something+*type plus right" cards
-  wql = { left: { left_id: type_id },
-          right: { codename: 'type_plus_right' }
-        }
-  wql_comment = "sets with a type_plus_right rule for #{name}"
-
-  Auth.as_bot do
-    Card.search(wql, wql_comment).each &:reset_set_patterns
-  end
-end

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

@@ -1,6 +1,6 @@
 # -*- encoding : utf-8 -*-
 
-describe Card::Chunk::EscapedLiteral, 'literal chunk tests' do
+describe Card::Content::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]]')

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

@@ -1,263 +1,256 @@
 # -*- encoding : utf-8 -*-
 
-describe Card::Chunk::URI, 'URI chunk tests' do
+describe Card::Content::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')
+    no_match_uri 'There is no URI here'
+    no_match_uri 'One gemstone is the garnet:reddish in colour, like ruby'
   end
 
-  it 'should test_simple_uri' do
+  it 'works with 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'
-               )
+    match_http_uri 'http://www.example.com',
+                   host: 'www.example.com', path: ''
+  end
+  it 'works with trailing slash' do
+    match_http_uri 'http://www.example.com/',
+                   host: 'www.example.com', path: '/'
+  end
+  it 'works with trailing slash inside html tags' do
+    match_http_uri '<p>http://www.example.com/</p>',
+                   host: 'www.example.com', path: '/',
+                   link_text: 'http://www.example.com/'
+  end
+  it 'works with trailing period (no longer suppressed .. spec?)' do
+    match_http_uri 'http://www.example.com/. ',
+                   host: 'www.example.com', path: '/',
+                   link_text: 'http://www.example.com/'
+  end
+  it 'works with trailing period inside html tags (dot change?)' do
+    match_http_uri '<p>http://www.example.com/.</p>',
+                   host: 'www.example.com', path: '/',
+                   link_text: 'http://www.example.com/'
+  end
+  it 'works with trailing &nbsp;' do
+    match_http_uri 'http://www.example.com/&nbsp;',
+                   host: 'www.example.com', path: '/',
+                   link_text: 'http://www.example.com/'
+  end
+  it 'works without http://' do
+    match_http_uri 'www.example.com',
+                   host: 'www.example.com',
+                   text: 'www.example.com',
+                   link_text: 'http://www.example.com'
+    match_http_uri 'example.com',
+                   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')
+    match_http_uri 'http://example.com.au/',
+                   host: 'example.com.au'
+  end
+  it 'works with "unusual" base domain without http://' do
+    match_http_uri 'example.com.au',
+                   host: 'example.com.au',
+                   text: 'example.com.au',
+                   link_text: 'http://example.com.au'
+  end
+  it 'works with another "unusual" base domain' do
+    match_http_uri 'http://www.example.co.uk/',
+                   host: 'www.example.co.uk'
+    match_http_uri 'example.co.uk',
+                   host: 'example.co.uk',
+                   text: 'example.co.uk',
+                   link_text: 'http://example.co.uk'
+  end
+  it 'works with some path at the end' do
+    match_http_uri 'http://moinmoin.wikiwikiweb.de/HelpOnNavigation',
+                   host: 'moinmoin.wikiwikiweb.de',
+                   path: '/HelpOnNavigation'
+  end
+  it 'works with some path at the end, and without http:// prefix (@link_text has prefix added)' do
+    match_http_uri 'moinmoin.wikiwikiweb.de/HelpOnNavigation',
+                   host: 'moinmoin.wikiwikiweb.de',
+                   path: '/HelpOnNavigation',
+                   text: 'moinmoin.wikiwikiweb.de/HelpOnNavigation',
+                   link_text: 'http://moinmoin.wikiwikiweb.de/HelpOnNavigation'
+  end
+  it 'works with a port number' do
+    match_http_uri 'http://www.example.com:80',
+                   host: 'www.example.com', port: 80,
+                   path: ''
+  end
+  it 'works with a port number and a path' do
+    match_http_uri 'http://www.example.com.tw:80/HelpOnNavigation',
+                   host: 'www.example.com.tw', port: 80,
+                   path: '/HelpOnNavigation'
+  end
+  it 'works with a query' do
+    match_http_uri 'http://www.example.com.tw:80/HelpOnNavigation?arg=val',
+                   host: 'www.example.com.tw', port: 80,
+                   path: '/HelpOnNavigation', query: 'arg=val'
+  end
+  it 'works on Query with two arguments' do
+    match_http_uri 'http://www.example.com.tw:80/HelpOnNavigation?arg=val&arg2=val2',
+                   host: 'www.example.com.tw', port: 80,
+                   path: '/HelpOnNavigation', query: 'arg=val&arg2=val2'
+  end
+  it 'works with IRC' do
+    match_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')
+    match_uri 'https://www.example.com',
+              scheme: 'https', host: 'www.example.com', port: 443,
+              path: '', query: nil
   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')
+    match_uri 'ftp://www.example.com',
+              scheme: 'ftp', host: 'www.example.com', port: 21,
+              path: '', query: nil
   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')
+    match_uri 'mailto:jdoe123@example.com',
+              scheme: 'mailto', host: nil, port: nil,
+              path: nil, query: nil,
+              to: 'jdoe123@example.com'
+  end
 
   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;")
+    no_match_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')
+    # Soap opera (the most complex case imaginable... well, not really, there
+    # should be more evil)
+    match_http_uri(
+      'http://www.example.com.tw:80/~jdoe123/Help%20Me%20?arg=val&arg2=val2',
+      host: 'www.example.com.tw', port: 80,
+      path: '/~jdoe123/Help%20Me%20', query: '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_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')
+    match_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'
-               )
+    match_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')
+    match_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.')
+    no_match_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.')
+    no_match_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')
+    match_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">')
+    no_match_uri "<img src='http://hobix.com/sample.jpg'/>"
+    no_match_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')
+    match_uri 'libproxy.so', host: 'libproxy.so',
+                             text: 'libproxy.so',
+                             link_text: 'http://libproxy.so'
 
-    no_match Card::Chunk::URI, 'httpd.conf'
+    no_match_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'
+    # no_match_uri 'ld.so.conf'
+    no_match_uri 'index.jpeg'
+    no_match_uri 'index.jpg'
+    no_match_uri 'file.txt'
+    no_match_uri 'file.doc'
+    no_match_uri 'file.pdf'
+    no_match_uri 'file.png'
+    no_match_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)
+    match_uri 'Go to: http://www.example.com/',
+              host: 'www.example.com', path: '/'
+    match_uri 'http://www.example.com/ is a link.', host: 'www.example.com'
+    match_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')
+    match_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.')
+    no_match_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'
-               )
+    match_uri 'URI (http://brackets.com.de) in brackets',
+              host: 'brackets.com.de'
+    match_uri 'because (as shown at research.net) the results',
+              host: 'research.net'
+    match_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,
+      Card::Content::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.
+    # 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')
+    match_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
+  describe Card::Content::Chunk::URI, 'URI chunk tests' do
+    it 'should test_local_urls' do
+      # normal
+      match_http_uri 'http://perforce:8001/toto.html',
+                     host: 'perforce', port: 8001
+      # in parentheses
+      match_uri 'URI (http://localhost:2500) in brackets',
+                host: 'localhost', port: 2500
+      match_uri 'because (as shown at http://perforce:8001) the results',
+                host: 'perforce', port: 8001
+      match_uri 'A wiki (http://localhost:2500/wiki.cgi?WhatIsWiki) card',
+                scheme: 'http', host: 'localhost', path: '/wiki.cgi',
+                port: 2500, query: 'WhatIsWiki'
+    end
+  end
 
   private
 
@@ -265,19 +258,11 @@ describe Card::Chunk::URI, 'URI chunk tests' do
 
   # 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
+    expect(get_chunk(type, test_text)).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}"
+    chunk = get_chunk(type, test_text)
     expect(chunk).not_to be_nil
 
     expected.each_pair do |method_sym, value|
@@ -287,4 +272,22 @@ describe Card::Chunk::URI, 'URI chunk tests' do
       assert_equal(value, cvalue, "Checking value of '#{method_sym}'")
     end
   end
+
+  def match_uri uri, opts
+    match_chunk Card::Content::Chunk::URI, uri, opts
+  end
+
+  def no_match_uri text
+    no_match Card::Content::Chunk::URI, text
+  end
+
+  def match_http_uri uri, opts
+    match_uri uri, opts.reverse_merge(link_text: uri, scheme: 'http')
+  end
+
+  def get_chunk type, test_text
+    cont = Card::Content.new(test_text, DUMMY_CARD)
+    cont = [cont] unless cont.respond_to?(:each)
+    cont.find { |ck| ck.is_a? type }
+  end
 end