card 1.17.4 → 1.18.0

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

@@ -1,4 +1,3 @@
-
 module ClassMethods
   def empty_trash
     Card.delete_trashed_files
@@ -17,7 +16,7 @@ module ClassMethods
     file_ids.each do |file_id|
       next unless trashed_card_ids.member?(file_id)
       if Card.exists?(file_id) # double check!
-        fail Card::Error, 'Narrowly averted deleting current file'
+        raise Card::Error, 'Narrowly averted deleting current file'
       end
       FileUtils.rm_rf "#{dir}/#{file_id}", secure: true
     end
@@ -29,7 +28,7 @@ module ClassMethods
   end
 
   def all_trashed_card_ids
-    trashed_card_sql = %{ select id from cards where trash is true }
+    trashed_card_sql = %( select id from cards where trash is true )
     sql_results = Card.connection.select_all(trashed_card_sql)
     sql_results.map(&:values).flatten.map(&:to_i)
   end
@@ -40,6 +39,7 @@ module ClassMethods
       WHERE cards.type_id IN (#{Card::FileID}, #{Card::ImageID})
       AND card_actions.draft = true"
     actions.each do |action|
+      # we don't want to delete uploads in progress
       if older_than_five_days?(action.created_at) && (card = action.card)
         # we don't want to delete uploads in progress
         card.delete_files_for_action action
@@ -88,7 +88,7 @@ module ClassMethods
   end
 
   def older_than_five_days? time
-    Time.now - time > 432000
+    Time.now - time > 432_000
   end
 end
 
@@ -120,13 +120,11 @@ format :html do
       self.class.ancestors.each_with_object({}) do |format_class, hash|
         views =
           format_class.instance_methods.map do |method|
-            if method.to_s.match(/^_view_(.+)$/)
-              "<li>#{$1}</li>"
-            end
+            "<li>#{Regexp.last_match(1)}</li>" if method.to_s =~ /^_view_(.+)$/
           end.compact.join "\n"
         if views.present?
-          format_class.name.match(/^Card(::Set)?::(.+?)$/) #::(\w+Format)
-          hash[$2] = views
+          format_class.name =~ /^Card(::Set)?::(.+?)$/ #::(\w+Format)
+          hash[Regexp.last_match(2)] = views
         end
       end
     accordion_group format_views
@@ -134,9 +132,7 @@ format :html do
 
   view :views_by_name do
     views = methods.map do |method|
-      if method.to_s.match(/^_view_(.+)$/)
-        $1
-      end
+      Regexp.last_match(1) if method.to_s =~ /^_view_(.+)$/
     end.compact.sort
     "<ul>#{wrap_each_with :li, views}</ul>"
   end
@@ -161,7 +157,7 @@ format :html do
       when Array then content.join "\n"
       else            content
       end
-    %{
+    %(
       <div class="panel panel-default">
         <div class="panel-heading" role="tab" id="heading-#{collapse_id}">
           <h4 class="panel-title">
@@ -179,6 +175,6 @@ format :html do
           </div>
         </div>
       </div>
-      }.html_safe
+      ).html_safe
   end
 end

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

@@ -1,4 +1,4 @@
-event :clear_view_cache, after: :store do
+event :clear_view_cache, :finalize do
   Card::ViewCache.reset
 end
 
@@ -6,4 +6,4 @@ format do
   def view_caching?
     false
   end
-end
+end

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

@@ -1,11 +1,11 @@
-def label name
+def label _name
   'All cards'
 end
 
-def prototype_args anchor
+def prototype_args _anchor
   {}
 end
 
-def follow_label name
+def follow_label _name
   'everything'
 end

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

@@ -1,13 +1,13 @@
 @@options = { junction_only: true }
 
-def label name
+def label _name
   'All "+" cards'
 end
 
-def prototype_args anchor
+def prototype_args _anchor
   { name: '+' }
 end
 
-def follow_label name
+def follow_label _name
   'all "+" cards'
 end

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

@@ -1,5 +1,5 @@
 def label name
-  %{All "#{name}" cards}
+  %(All "#{name}" cards)
 end
 
 def prototype_args anchor
@@ -19,5 +19,5 @@ def anchor_id card
 end
 
 def follow_label name
-  %{all "#{name}s"}
+  %(all "#{name}s")
 end

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

@@ -1,8 +1,8 @@
-def label name
+def label _name
   'All "*" cards'
 end
 
-def prototype_args anchor
+def prototype_args _anchor
   { name: '*dummy' }
 end
 
@@ -10,6 +10,6 @@ def pattern_applies? card
   card.cardname.star?
 end
 
-def follow_label name
+def follow_label _name
   'all "*" cards'
 end

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

@@ -1,10 +1,10 @@
 @@options = { junction_only: true }
 
-def label name
+def label _name
   'All "+*" cards'
 end
 
-def prototype_args anchor
+def prototype_args _anchor
   { name: '*dummy+*dummy' }
 end
 
@@ -12,6 +12,6 @@ def pattern_applies? card
   card.cardname.rstar?
 end
 
-def follow_label name
+def follow_label _name
   'all "+*" cards'
 end

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

@@ -4,7 +4,7 @@
 }
 
 def label name
-  %{All "+#{name}" cards}
+  %(All "+#{name}" cards)
 end
 
 def prototype_args anchor
@@ -16,5 +16,5 @@ def anchor_name card
 end
 
 def follow_label name
-   %{all "+#{name}s"}
+  %(all "+#{name}s")
 end

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

@@ -5,7 +5,7 @@
 }
 
 def label name
-  %{All "+#{name.to_name.tag}" cards on "#{name.to_name.left_name}" cards}
+  %(All "+#{name.to_name.tag}" cards on "#{name.to_name.left_name}" cards)
 end
 
 def prototype_args anchor
@@ -22,5 +22,5 @@ def anchor_name card
 end
 
 def follow_label name
-  %{all "+#{name.to_name.tag}" on "#{name.to_name.left_name}s"}
+  %(all "+#{name.to_name.tag}" on "#{name.to_name.left_name}s")
 end

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

@@ -1,5 +1,5 @@
 def label name
-  %{The card "#{name}"}
+  %(The card "#{name}")
 end
 
 def prototype_args anchor

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

@@ -1,14 +1,13 @@
 # -*- 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]]')
+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}}')
+  it 'should handle escaped nest' 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,197 +1,195 @@
 # -*- encoding : utf-8 -*-
 
-describe Card::Chunk::URI, "URI chunk tests" do
-  it "should test_non_matches" do
+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')
+             'One gemstone is the garnet:reddish in colour, like ruby')
   end
 
-  it "should test_simple_uri" do
+  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'
-    )
+                scheme: 'http', host: 'www.example.com', path: '',
+                link_text: 'http://www.example.com'
+               )
   end
-  it "should work with trailing slash" do
+  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/'
-    )
+                scheme: 'http', host: 'www.example.com', path: '/',
+                link_text: 'http://www.example.com/'
+               )
   end
-  it "should work with trailing slash inside html tags" do
+  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/'
-    )
+                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
+  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/'
-    )
+                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
+  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/'
-    )
+                scheme: 'http', host: 'www.example.com', path: '/',
+                link_text: 'http://www.example.com/'
+               )
   end
-  it "should work with trailing &nbsp;" do
+  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/'
-    )
+                scheme: 'http', host: 'www.example.com', path: '/',
+                link_text: 'http://www.example.com/'
+               )
   end
-  it "should work without http://" do
+  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'
-    )
+                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'
-    )
+                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
+  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/'
-    )
+                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'
-    )
+                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/'
-    )
+                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'
-    )
+                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
+  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'
-    )
+                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
+  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'
-    )
+                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
+  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')
+                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
+  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')
+                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
+  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')
+                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
+  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')
+                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
+  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')
+                scheme: 'irc', host: 'irc.freenode.net',
+                fragment: 'recentchangescamp',
+                link_text: 'irc://irc.freenode.net#recentchangescamp')
   end
 
-  it "should see HTTPS" do
+  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')
+                scheme: 'https', host: 'www.example.com', port: 443, path: '', query: nil,
+                link_text: 'https://www.example.com')
   end
-  it "should see FTP" do
+  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')
+                scheme: 'ftp', host: 'www.example.com', port: 21, path: '', query: nil,
+                link_text: 'ftp://www.example.com')
   end
-  it "should handle mailto:" do
+  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')
+                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
+  # 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')
+                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')
+                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')
-
+                scheme: 'http', host: 'support.microsoft.com', path: '/default.aspx',
+                query: 'scid=kb;en-us;234562')
   end
 
-  it "should test_email_uri" do
+  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'
-    )
+                to: 'mail@example.com', host: nil, text: 'mail@example.com', link_text: 'mailto:mail@example.com'
+               )
   end
 
-  it "should test_non_email" do
+  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_chunk(Card::Chunk::URI, 'Not an email: @example.com', uri: 'http://example.com')
   end
 
-  it "should test_textile_image" do
+  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
+  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')
+                link_text: 'http://hobix.com/sample.jpg')
   end
 
-  it "should test_inline_html" do
+  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
+  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, 'ld.so.conf'
     no_match Card::Chunk::URI, 'index.jpeg'
     no_match Card::Chunk::URI, 'index.jpg'
     no_match Card::Chunk::URI, 'file.txt'
@@ -201,28 +199,28 @@ describe Card::Chunk::URI, "URI chunk tests" do
     no_match Card::Chunk::URI, 'file.ps'
   end
 
-  it "should test_uri_in_text" do
+  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)
+                '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
+  end
 
-  it "should test_uri_in_parentheses" do
+  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'
-    )
+                '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
+  it 'should test_uri_list_item' do
     match_chunk(
       Card::Chunk::URI,
       '* http://www.btinternet.com/~mail2minh/SonyEricssonP80xPlatform.sis',
@@ -230,63 +228,63 @@ describe Card::Chunk::URI, "URI chunk tests" do
     )
   end
 
-  it "should test_interesting_uri_with__comma" do
+  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')
+      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')
+ 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
+     # 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)
+  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
+    expect(((test_cont.respond_to? :each) ? test_cont : [test_cont]).find { |ck| type === ck }).to be_nil
   end
 
-  def aa_match(type, test_text)
+  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(((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)
+  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 = ((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)
+      # 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