wikitext 1.3.2 → 1.4.0

data/ext/parser.c

@@ -1,4 +1,4 @@
-// Copyright 2007-2008 Wincent Colaiuta
+// Copyright 2007-2009 Wincent Colaiuta
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
@@ -37,9 +37,7 @@ typedef struct
     ary_t   *line_buffer;           // stack for tracking raw tokens (not scope) on current line
     VALUE   pending_crlf;           // boolean (Qtrue or Qfalse)
     VALUE   autolink;               // boolean (Qtrue or Qfalse)
-    VALUE   treat_slash_as_special; // boolean (Qtrue or Qfalse)
     VALUE   space_to_underscore;    // boolean (Qtrue or Qfalse)
-    VALUE   special_link;           // boolean (Qtrue or Qfalse): is the current link_target a "special" link?
     str_t   *line_ending;
     int     base_indent;            // controlled by the :indent option to Wikitext::Parser#parse
     int     current_indent;         // fluctuates according to currently nested structures
@@ -398,6 +396,10 @@ void _Wikitext_pop_from_stack(parser_t *parser, VALUE target)
             // not an HTML tag; so nothing to emit
             break;
 
+        case PATH:
+            // not an HTML tag; so nothing to emit
+            break;
+
         case SPACE:
             // not an HTML tag (only used to separate an external link target from the link text); so nothing to emit
             break;
@@ -619,7 +621,7 @@ VALUE _Wikitext_parser_trim_link_target(VALUE string)
 // - non-printable (non-ASCII) characters converted to numeric entities
 // - QUOT and AMP characters converted to named entities
 // - if rollback is Qtrue, there is no special treatment of spaces
-// - if rollback is Qfalse, leading and trailing whitespace trimmed if trimmed
+// - if rollback is Qfalse, leading and trailing whitespace trimmed
 VALUE _Wikitext_parser_sanitize_link_target(parser_t *parser, VALUE rollback)
 {
     VALUE string        = StringValue(parser->link_target); // raises if string is nil or doesn't quack like a string
@@ -725,8 +727,6 @@ VALUE Wikitext_parser_sanitize_link_target(VALUE self, VALUE string)
 //         ...the [[foo]] is...
 // to be equivalent to:
 //         thing. [[Foo]] was...
-// this is also where we check treat_slash_as_special is true and act accordingly
-// basically any link target matching /\A[a-z]+\/\d+\z/ is flagged as special
 static void _Wikitext_parser_encode_link_target(parser_t *parser)
 {
     VALUE in                = StringValue(parser->link_target);
@@ -738,28 +738,6 @@ static void _Wikitext_parser_encode_link_target(parser_t *parser)
     char        *end        = input + len;
     static char hex[]       = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
 
-    // this potential shortcut requires an (admittedly cheap) prescan, so only do it when treat_slash_as_special is true
-    parser->special_link = Qfalse;
-    if (parser->treat_slash_as_special == Qtrue)
-    {
-        char *c = input;                                    // \A
-        while (c < end && *c >= 'a' && *c <= 'z')           // [a-z]
-            c++;                                            // +
-        if (c > start && c < end && *c++ == '/')            // \/
-        {
-            while (c < end && *c >= '0' && *c <= '9')       // \d
-            {
-                c++;                                        // +
-                if (c == end)                               // \z
-                {
-                    // matches /\A[a-z]+\/\d+\z/ so no transformation required
-                    parser->special_link = Qtrue;
-                    return;
-                }
-            }
-        }
-    }
-
     // to avoid most reallocations start with a destination buffer twice the size of the source
     // this handles the most common case (where most chars are in the ASCII range and don't require more storage, but there are
     // often quite a few spaces, which are encoded as "%20" and occupy 3 bytes)
@@ -827,7 +805,6 @@ VALUE Wikitext_parser_encode_link_target(VALUE self, VALUE in)
 {
     parser_t parser;
     parser.link_target              = in;
-    parser.treat_slash_as_special   = Qfalse;
     parser.space_to_underscore      = Qfalse;
     _Wikitext_parser_encode_link_target(&parser);
     return parser.link_target;
@@ -838,7 +815,6 @@ VALUE Wikitext_parser_encode_special_link_target(VALUE self, VALUE in)
 {
     parser_t parser;
     parser.link_target              = in;
-    parser.treat_slash_as_special   = Qtrue;
     parser.space_to_underscore      = Qfalse;
     _Wikitext_parser_encode_link_target(&parser);
     return parser.link_target;
@@ -906,7 +882,6 @@ VALUE Wikitext_parser_initialize(int argc, VALUE *argv, VALUE self)
     VALUE internal_link_prefix          = rb_str_new2("/wiki/");
     VALUE img_prefix                    = rb_str_new2("/images/");
     VALUE space_to_underscore           = Qtrue;
-    VALUE treat_slash_as_special        = Qtrue;
     VALUE minimum_fulltext_token_length = INT2NUM(3);
 
     // process options hash (override defaults)
@@ -921,7 +896,6 @@ VALUE Wikitext_parser_initialize(int argc, VALUE *argv, VALUE self)
         internal_link_prefix            = OVERRIDE_IF_SET(internal_link_prefix);
         img_prefix                      = OVERRIDE_IF_SET(img_prefix);
         space_to_underscore             = OVERRIDE_IF_SET(space_to_underscore);
-        treat_slash_as_special          = OVERRIDE_IF_SET(treat_slash_as_special);
         minimum_fulltext_token_length   = OVERRIDE_IF_SET(minimum_fulltext_token_length);
     }
 
@@ -933,7 +907,6 @@ VALUE Wikitext_parser_initialize(int argc, VALUE *argv, VALUE self)
     rb_iv_set(self, "@internal_link_prefix",            internal_link_prefix);
     rb_iv_set(self, "@img_prefix",                      img_prefix);
     rb_iv_set(self, "@space_to_underscore",             space_to_underscore);
-    rb_iv_set(self, "@treat_slash_as_special",          treat_slash_as_special);
     rb_iv_set(self, "@minimum_fulltext_token_length",   minimum_fulltext_token_length);
     return self;
 }
@@ -1001,9 +974,7 @@ VALUE Wikitext_parser_parse(int argc, VALUE *argv, VALUE self)
     GC_WRAP_ARY(parser->line_buffer, line_buffer_gc);
     parser->pending_crlf            = Qfalse;
     parser->autolink                = rb_iv_get(self, "@autolink");
-    parser->treat_slash_as_special  = rb_iv_get(self, "@treat_slash_as_special");
     parser->space_to_underscore     = rb_iv_get(self, "@space_to_underscore");
-    parser->special_link            = Qfalse;
     parser->line_ending             = str_new_from_string(line_ending);
     GC_WRAP_STR(parser->line_ending, line_ending_gc);
     parser->base_indent             = base_indent;
@@ -1011,6 +982,12 @@ VALUE Wikitext_parser_parse(int argc, VALUE *argv, VALUE self)
     parser->tabulation              = str_new();
     GC_WRAP_STR(parser->tabulation, tabulation_gc);
 
+    // this simple looping design leads to a single enormous function,
+    // but it's faster than doing actual recursive descent and also secure in the face of
+    // malicious input that seeks to overflow the stack
+    // (with "<blockquote><blockquote><blockquote>..." times by 10,000, for example)
+    // given that we expect to deal with a lot of malformed input, a recursive descent design is less appropriate
+    // than a straightforward looping translator like this one anyway
     token_t _token;
     _token.type = NO_TOKEN;
     token_t *token = NULL;
@@ -1945,13 +1922,58 @@ VALUE Wikitext_parser_parse(int argc, VALUE *argv, VALUE self)
                 }
                 break;
 
+            case PATH:
+                if (IN(NO_WIKI_START) || IN(PRE) || IN(PRE_START))
+                    rb_str_cat(parser->output, token->start, TOKEN_LEN(token));
+                else if (IN(EXT_LINK_START))
+                {
+                    if (NIL_P(parser->link_target))
+                    {
+                        // this must be our link target: look ahead to make sure we see the space we're expecting to see
+                        i = TOKEN_TEXT(token);
+                        NEXT_TOKEN();
+                        if (token->type == SPACE)
+                        {
+                            ary_push(parser->scope, PATH);
+                            ary_push(parser->scope, SPACE);
+                            parser->link_target = i;
+                            parser->link_text   = rb_str_new2("");
+                            parser->capture     = parser->link_text;
+                            token               = NULL; // silently consume space
+                        }
+                        else
+                        {
+                            // didn't see the space! this must be an error
+                            _Wikitext_pop_from_stack(parser, Qnil);
+                            _Wikitext_pop_excess_elements(parser);
+                            _Wikitext_start_para_if_necessary(parser);
+                            rb_str_cat(parser->output, ext_link_start, sizeof(ext_link_start) - 1);
+                            rb_str_append(parser->output, i);
+                        }
+                    }
+                    else
+                    {
+                        if (NIL_P(parser->link_text))
+                            // this must be the first part of our link text
+                            parser->link_text = TOKEN_TEXT(token);
+                        else
+                            // add to existing link text
+                            rb_str_cat(parser->link_text, token->start, TOKEN_LEN(token));
+                    }
+                }
+                else
+                {
+                    i = NIL_P(parser->capture) ? parser->output : parser->capture;
+                    _Wikitext_pop_excess_elements(parser);
+                    _Wikitext_start_para_if_necessary(parser);
+                    rb_str_cat(i, token->start, TOKEN_LEN(token));
+                }
+                break;
+
             // internal links (links to other wiki articles) look like this:
             //      [[another article]] (would point at, for example, "/wiki/another_article")
             //      [[the other article|the link text we'll use for it]]
             //      [[the other article | the link text we'll use for it]]
-            // note that the forward slash is a reserved character which changes the meaning of an internal link;
-            // this is a link that is external to the wiki but internal to the site as a whole:
-            //      [[bug/12]] (a relative link to "/bug/12")
             // MediaWiki has strict requirements about what it will accept as a link target:
             //      all wikitext markup is disallowed:
             //          example [[foo ''bar'' baz]]
@@ -1968,7 +1990,7 @@ VALUE Wikitext_parser_parse(int argc, VALUE *argv, VALUE self)
             //          example [[foo €]]
             //          renders <a href="/wiki/Foo_%E2%82%AC">foo €</a>
             // we'll impose similar restrictions here for the link target; allowed tokens will be:
-            //      SPACE, SPECIAL_URI_CHARS, PRINTABLE, ALNUM, DEFAULT, QUOT and AMP
+            //      SPACE, SPECIAL_URI_CHARS, PRINTABLE, PATH, ALNUM, DEFAULT, QUOT and AMP
             // everything else will be rejected
             case LINK_START:
                 i = NIL_P(parser->capture) ? parser->output : parser->capture;
@@ -2002,6 +2024,7 @@ VALUE Wikitext_parser_parse(int argc, VALUE *argv, VALUE self)
                     {
                         if (type == SPACE               ||
                             type == SPECIAL_URI_CHARS   ||
+                            type == PATH                ||
                             type == PRINTABLE           ||
                             type == ALNUM               ||
                             type == DEFAULT             ||
@@ -2072,10 +2095,7 @@ VALUE Wikitext_parser_parse(int argc, VALUE *argv, VALUE self)
                     _Wikitext_parser_encode_link_target(parser);
                     _Wikitext_pop_from_stack_up_to(parser, i, LINK_START, Qtrue);
                     parser->capture     = Qnil;
-                    if (parser->special_link)
-                        i = _Wikitext_hyperlink(rb_str_new2("/"), parser->link_target, parser->link_text, Qnil);
-                    else
-                        i = _Wikitext_hyperlink(prefix, parser->link_target, parser->link_text, Qnil);
+                    i = _Wikitext_hyperlink(prefix, parser->link_target, parser->link_text, Qnil);
                     rb_str_append(parser->output, i);
                     parser->link_target = Qnil;
                     parser->link_text   = Qnil;
@@ -2090,6 +2110,7 @@ VALUE Wikitext_parser_parse(int argc, VALUE *argv, VALUE self)
 
             // external links look like this:
             //      [http://google.com/ the link text]
+            //      [/other/page/on/site see this page]
             // strings in square brackets which don't match this syntax get passed through literally; eg:
             //      he was very angery [sic] about the turn of events
             case EXT_LINK_START:
@@ -2129,9 +2150,9 @@ VALUE Wikitext_parser_parse(int argc, VALUE *argv, VALUE self)
                     _Wikitext_pop_excess_elements(parser);
                     _Wikitext_start_para_if_necessary(parser);
 
-                    // look ahead: expect a URI
+                    // look ahead: expect an absolute URI (with protocol) or "relative" (path) URI
                     NEXT_TOKEN();
-                    if (token->type == URI)
+                    if (token->type == URI || token->type == PATH)
                         ary_push(parser->scope, EXT_LINK_START);    // so far so good, jump back to the top of the loop
                     else
                         // only get here if there was a syntax error (missing URI)
@@ -2155,9 +2176,10 @@ VALUE Wikitext_parser_parse(int argc, VALUE *argv, VALUE self)
                     else
                     {
                         // success!
+                        j = IN(PATH) ? Qnil : parser->external_link_class;
                         _Wikitext_pop_from_stack_up_to(parser, i, EXT_LINK_START, Qtrue);
                         parser->capture = Qnil;
-                        i = _Wikitext_hyperlink(Qnil, parser->link_target, parser->link_text, parser->external_link_class);
+                        i = _Wikitext_hyperlink(Qnil, parser->link_target, parser->link_text, j);
                         rb_str_append(parser->output, i);
                     }
                     parser->link_target = Qnil;
@@ -2275,13 +2297,13 @@ VALUE Wikitext_parser_parse(int argc, VALUE *argv, VALUE self)
                     _Wikitext_pop_excess_elements(parser);
                     _Wikitext_start_para_if_necessary(parser);
 
-                    // scan ahead consuming PRINTABLE, ALNUM and SPECIAL_URI_CHARS tokens
+                    // scan ahead consuming PATH, PRINTABLE, ALNUM and SPECIAL_URI_CHARS tokens
                     // will cheat here and abuse the link_target capture buffer to accumulate text
                     if (NIL_P(parser->link_target))
                         parser->link_target = rb_str_new2("");
                     while (NEXT_TOKEN(), (type = token->type))
                     {
-                        if (type == PRINTABLE || type == ALNUM || type == SPECIAL_URI_CHARS)
+                        if (type == PATH || type == PRINTABLE || type == ALNUM || type == SPECIAL_URI_CHARS)
                             rb_str_cat(parser->link_target, token->start, TOKEN_LEN(token));
                         else if (type == IMG_END)
                         {

data/ext/token.c

@@ -1,4 +1,4 @@
-// Copyright 2008 Wincent Colaiuta
+// Copyright 2008-2009 Wincent Colaiuta
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
@@ -63,6 +63,7 @@ VALUE Wikitext_parser_token_types(VALUE self)
     SET_TOKEN_TYPE(H1_END);
     SET_TOKEN_TYPE(URI);
     SET_TOKEN_TYPE(MAIL);
+    SET_TOKEN_TYPE(PATH);
     SET_TOKEN_TYPE(LINK_START);
     SET_TOKEN_TYPE(LINK_END);
     SET_TOKEN_TYPE(EXT_LINK_START);

data/ext/token.h

@@ -1,4 +1,4 @@
-// Copyright 2008 Wincent Colaiuta
+// Copyright 2008-2009 Wincent Colaiuta
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
@@ -69,6 +69,7 @@ enum token_types {
     H1_END,
     URI,
     MAIL,
+    PATH,
     LINK_START,
     LINK_END,
     EXT_LINK_START,

data/ext/wikitext.c

@@ -1,4 +1,4 @@
-// Copyright 2008 Wincent Colaiuta
+// Copyright 2008-2009 Wincent Colaiuta
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
@@ -42,7 +42,6 @@ void Init_wikitext()
     rb_define_attr(cWikitextParser, "external_link_class", Qtrue, Qtrue);
     rb_define_attr(cWikitextParser, "mailto_class", Qtrue, Qtrue);
     rb_define_attr(cWikitextParser, "autolink", Qtrue, Qtrue);
-    rb_define_attr(cWikitextParser, "treat_slash_as_special", Qtrue, Qtrue);
     rb_define_attr(cWikitextParser, "space_to_underscore", Qtrue, Qtrue);
     rb_define_attr(cWikitextParser, "minimum_fulltext_token_length", Qtrue, Qtrue);
 

data/lib/wikitext/string.rb

@@ -26,6 +26,6 @@ private
   # if speed later becomes a concern can whip up a Ragel C extension to do it
   # TODO: make this customizable (accept a lambda that performs preprocessing)
   def wikitext_preprocess
-    gsub /\b(bug|issue|request|ticket) #(\d+)/i, '[[issues/\2|\1 #\2]]'
+    gsub /\b(bug|issue|request|ticket) #(\d+)/i, '[/issues/\2 \1 #\2]'
   end
 end

data/lib/wikitext/version.rb

@@ -13,5 +13,5 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 module Wikitext
-  VERSION = '1.3.2'
+  VERSION = '1.4.0'
 end # module Wikitext

data/spec/external_link_spec.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-# Copyright 2007-2008 Wincent Colaiuta
+# Copyright 2007-2009 Wincent Colaiuta
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
@@ -48,6 +48,33 @@ describe Wikitext::Parser, 'external links' do
     @parser.parse('[mailto:user@example.com john]').should == expected
   end
 
+  it 'should format absolute path links' do
+    expected = %Q{<p><a href="/foo/bar">fb</a></p>\n} # note no "external" class
+    @parser.parse('[/foo/bar fb]').should == expected
+  end
+
+  it 'should format deeply nested absolute path links' do
+    expected = %Q{<p><a href="/foo/bar/baz/bing">fb</a></p>\n} # note no "external" class
+    @parser.parse('[/foo/bar/baz/bing fb]').should == expected
+  end
+
+  it 'should format minimal absolute path links' do
+    expected = %Q{<p><a href="/">fb</a></p>\n} # note no "external" class
+    @parser.parse('[/ fb]').should == expected
+  end
+
+  it 'should format absolute path links with trailing slashes' do
+    expected = %Q{<p><a href="/foo/bar/">fb</a></p>\n} # note no "external" class
+    @parser.parse('[/foo/bar/ fb]').should == expected
+  end
+
+  it 'should not format relative path links' do
+    # relative paths don't make sense in wikitext because
+    # they could be displayed anywhere (eg. /wiki/article, /dashboard/ etc)
+    expected = %Q{<p>[foo/bar fb]</p>\n}
+    @parser.parse('[foo/bar fb]').should == expected
+  end
+
   it 'should treat runs of spaces after the link target as a single space' do
     expected = %Q{<p><a href="http://google.com/" class="external">Google</a></p>\n}
     @parser.parse('[http://google.com/                  Google]').should == expected

data/spec/internal_link_spec.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-# Copyright 2007-2008 Wincent Colaiuta
+# Copyright 2007-2009 Wincent Colaiuta
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
@@ -94,6 +94,11 @@ describe Wikitext::Parser, 'internal links (space to underscore off)' do
     @parser.parse('[[foo, "bar" & baz €]]').should == expected
   end
 
+  it 'should handle embedded paths' do
+    expected = %Q{<p><a href="/wiki/foo%2fbar">foo/bar</a></p>\n}
+    @parser.parse('[[foo/bar]]').should == expected
+  end
+
   it 'should handle links in paragraph flows' do
     expected = %Q{<p>foo <a href="/wiki/bar">bar</a> baz</p>\n}
     @parser.parse('foo [[bar]] baz').should == expected # was a bug
@@ -252,6 +257,11 @@ describe Wikitext::Parser, 'internal links (space to underscore off)' do
       expected = %Q{<p><a href="/wiki/foo">bar ]</a></p>\n}
       @parser.parse("[[foo|bar <nowiki>]</nowiki>]]").should == expected
     end
+
+    it 'should handle paths in custom link text' do
+      expected = %Q{<p><a href="/wiki/hello%2fworld">foo/bar</a></p>\n}
+      @parser.parse('[[hello/world|foo/bar]]').should == expected
+    end
   end
 
   describe 'overriding the link prefix' do
@@ -266,36 +276,30 @@ describe Wikitext::Parser, 'internal links (space to underscore off)' do
     end
   end
 
+  # "special links" existed in internal links up to and including wikitext version 1.3.2
+  # from version 1.4.0 onwards this feature was changed to instead work with external links
+  # as such, all of these specs have been updated to make sure that the old behaviour was removed
   describe 'special links' do
-    it 'should recognize links of the form "bug/10" as special links' do
-      @parser.parse('[[bug/10]]').should == %Q{<p><a href="/bug/10">bug/10</a></p>\n}
-      @parser.parse('[[issue/25]]').should == %Q{<p><a href="/issue/25">issue/25</a></p>\n}
-      @parser.parse('[[post/7]]').should == %Q{<p><a href="/post/7">post/7</a></p>\n}
+    it 'should no longer recognize links of the form "bug/10" as special links' do
+      @parser.parse('[[bug/10]]').should    == %Q{<p><a href="/wiki/bug%2f10">bug/10</a></p>\n}
+      @parser.parse('[[issue/25]]').should  == %Q{<p><a href="/wiki/issue%2f25">issue/25</a></p>\n}
+      @parser.parse('[[post/7]]').should    == %Q{<p><a href="/wiki/post%2f7">post/7</a></p>\n}
     end
 
-    it 'should not recognize special links when "treat_slash_as_special" is set to false' do
-      @parser.treat_slash_as_special = false
-      @parser.parse('[[bug/10]]').should == %Q{<p><a href="/wiki/bug%2f10">bug/10</a></p>\n}
-      @parser.parse('[[issue/25]]').should == %Q{<p><a href="/wiki/issue%2f25">issue/25</a></p>\n}
-      @parser.parse('[[post/7]]').should == %Q{<p><a href="/wiki/post%2f7">post/7</a></p>\n}
+    it 'should no longer accept custom link text in conjunction with special links' do
+      @parser.parse('[[bug/10|bug #10]]').should == %Q{<p><a href="/wiki/bug%2f10">bug #10</a></p>\n}
     end
 
-    it 'should accept custom link text in conjunction with special links' do
-      @parser.parse('[[bug/10|bug #10]]').should == %Q{<p><a href="/bug/10">bug #10</a></p>\n}
-    end
-
-    it 'should ignore link prefix overrides when emitting special links' do
+    it 'should not emit special links regardless of custom internal link prefix overrides' do
       @parser.internal_link_prefix = '/custom/'
-      @parser.parse('[[bug/10]]').should == %Q{<p><a href="/bug/10">bug/10</a></p>\n}
+      @parser.parse('[[bug/10]]').should == %Q{<p><a href="/custom/bug%2f10">bug/10</a></p>\n}
     end
 
-    it 'should not classify links as special merely because of the presence of a slash' do
-      # we want the syntax to be tight to minimize false positives
+    it 'should (still) not classify links as special merely because of the presence of a slash' do
       @parser.parse('[[foo/bar]]').should == %Q{<p><a href="/wiki/foo%2fbar">foo/bar</a></p>\n}
     end
 
-    it 'should not accept special links which have a leading forward slash' do
-      # this is a syntax error
+    it 'should (still) not accept special links which have a leading forward slash' do
       @parser.parse('[[/bug/10]]').should == %Q{<p><a href="/wiki/%2fbug%2f10">/bug/10</a></p>\n}
     end
   end
@@ -694,36 +698,28 @@ describe Wikitext::Parser, 'internal links (space to underscore on)' do
     end
   end
 
+  # see note above about "special links" being removed from internal links from 1.4.0 onwards
   describe 'special links' do
-    it 'should recognize links of the form "bug/10" as special links' do
-      @parser.parse('[[bug/10]]').should == %Q{<p><a href="/bug/10">bug/10</a></p>\n}
-      @parser.parse('[[issue/25]]').should == %Q{<p><a href="/issue/25">issue/25</a></p>\n}
-      @parser.parse('[[post/7]]').should == %Q{<p><a href="/post/7">post/7</a></p>\n}
-    end
-
-    it 'should not recognize special links when "treat_slash_as_special" is set to false' do
-      @parser.treat_slash_as_special = false
-      @parser.parse('[[bug/10]]').should == %Q{<p><a href="/wiki/bug%2f10">bug/10</a></p>\n}
-      @parser.parse('[[issue/25]]').should == %Q{<p><a href="/wiki/issue%2f25">issue/25</a></p>\n}
-      @parser.parse('[[post/7]]').should == %Q{<p><a href="/wiki/post%2f7">post/7</a></p>\n}
+    it 'should no longer recognize links of the form "bug/10" as special links' do
+      @parser.parse('[[bug/10]]').should    == %Q{<p><a href="/wiki/bug%2f10">bug/10</a></p>\n}
+      @parser.parse('[[issue/25]]').should  == %Q{<p><a href="/wiki/issue%2f25">issue/25</a></p>\n}
+      @parser.parse('[[post/7]]').should    == %Q{<p><a href="/wiki/post%2f7">post/7</a></p>\n}
     end
 
-    it 'should accept custom link text in conjunction with special links' do
-      @parser.parse('[[bug/10|bug #10]]').should == %Q{<p><a href="/bug/10">bug #10</a></p>\n}
+    it 'should no longer accept custom link text in conjunction with special links' do
+      @parser.parse('[[bug/10|bug #10]]').should == %Q{<p><a href="/wiki/bug%2f10">bug #10</a></p>\n}
     end
 
-    it 'should ignore link prefix overrides when emitting special links' do
+    it 'should not emit special links regardless of custom internal link prefix overrides' do
       @parser.internal_link_prefix = '/custom/'
-      @parser.parse('[[bug/10]]').should == %Q{<p><a href="/bug/10">bug/10</a></p>\n}
+      @parser.parse('[[bug/10]]').should == %Q{<p><a href="/custom/bug%2f10">bug/10</a></p>\n}
     end
 
-    it 'should not classify links as special merely because of the presence of a slash' do
-      # we want the syntax to be tight to minimize false positives
+    it 'should (still) not classify links as special merely because of the presence of a slash' do
       @parser.parse('[[foo/bar]]').should == %Q{<p><a href="/wiki/foo%2fbar">foo/bar</a></p>\n}
     end
 
-    it 'should not accept special links which have a leading forward slash' do
-      # this is a syntax error
+    it 'should (still) not accept special links which have a leading forward slash' do
       @parser.parse('[[/bug/10]]').should == %Q{<p><a href="/wiki/%2fbug%2f10">/bug/10</a></p>\n}
     end
   end

data/spec/link_encoding_spec.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-# Copyright 2007-2008 Wincent Colaiuta
+# Copyright 2007-2009 Wincent Colaiuta
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
@@ -87,10 +87,12 @@ describe Wikitext, 'encoding a link target' do
 
   # "special" links don't get transformed in any way
   describe 'special links' do
-    it 'should recognize links which match /\A[a-z]+\/\d+\z/ as being special' do
+
+    # as of version 1.4.0 the encode_link_target function no longer handles special links
+    it 'should (no longer) recognize links which match /\A[a-z]+\/\d+\z/ as being special' do
       string = 'foo/10'
-      Wikitext::Parser.encode_special_link_target(string).should == string
-      Wikitext::Parser.encode_link_target(string).should_not == string
+      Wikitext::Parser.encode_special_link_target(string).should == 'foo%2f10'
+      Wikitext::Parser.encode_link_target(string).should == 'foo%2f10'
     end
 
     it "should not recognize links which don't match at /\A/ as being special" do

data/spec/vim_formatter.rb

@@ -0,0 +1,41 @@
+require 'spec/runner/formatter/base_text_formatter'
+require 'pathname'
+
+# Format spec results for display in the Vim quickfix window
+# Use this custom formatter like this:
+#   spec -r spec/vim_formatter.rb -f Spec::Runner::Formatter::VimFormatter spec
+module Spec
+  module Runner
+    module Formatter
+      class VimFormatter < BaseTextFormatter
+
+        # TODO: handle pending issues
+        # TODO: vim-side function for printing progress
+        def dump_failure counter, failure
+          path = failure.exception.backtrace.find do |frame|
+            frame =~ %r{\bspec/.*_spec\.rb:\d+\z}
+          end
+          message = failure.exception.message.gsub("\n", ' ')
+          @output.puts "#{relativize_path(path)}: #{message}" if path
+        end
+
+        def dump_pending; end
+
+        def dump_summary duration, example_count, failure_count, pending_count
+        end
+
+      private
+
+        def relativize_path path
+          @wd ||= Pathname.new Dir.getwd
+          begin
+            return Pathname.new(path).relative_path_from(@wd)
+          rescue ArgumentError
+            # raised unless both paths relative, or both absolute
+            return path
+          end
+        end
+      end # class VimFormatter
+    end # module Formatter
+  end # module Runner
+end # module Spec

data/spec/wikitext_spec.rb

@@ -49,10 +49,6 @@ describe Wikitext::Parser do
     @parser.space_to_underscore.should == true
   end
 
-  it 'should treat slash as special by default' do
-    @parser.treat_slash_as_special.should == true
-  end
-
   describe 'overriding defaults at initialization time' do
     it 'should allow overriding of autolink' do
       Wikitext::Parser.new(:autolink => false).autolink.should == false
@@ -83,10 +79,6 @@ describe Wikitext::Parser do
     it 'should allow overriding of space-to-underscore' do
       Wikitext::Parser.new(:space_to_underscore => false).space_to_underscore.should == false
     end
-
-    it 'should allow overriding of treat slash as special' do
-      Wikitext::Parser.new(:treat_slash_as_special => false).treat_slash_as_special.should == false
-    end
   end
 
   describe 'overriding defaults at parse time' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: wikitext
 version: !ruby/object:Gem::Version 
-  version: 1.3.2
+  version: 1.4.0
 platform: ruby
 authors: 
 - Wincent Colaiuta
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-06 00:00:00 +01:00
+date: 2009-02-02 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -22,7 +22,6 @@ extensions:
 extra_rdoc_files: []
 
 files: 
-- spec/#spec_helper.rb#
 - spec/autolinking_spec.rb
 - spec/blockquote_spec.rb
 - spec/em_spec.rb
@@ -59,6 +58,7 @@ files:
 - spec/tt_spec.rb
 - spec/ul_spec.rb
 - spec/version_spec.rb
+- spec/vim_formatter.rb
 - spec/wikitext_spec.rb
 - ext/extconf.rb
 - ext/ary.c
@@ -66,7 +66,6 @@ files:
 - ext/str.c
 - ext/token.c
 - ext/wikitext.c
-- ext/wikitext_ragel.c
 - ext/ary.h
 - ext/parser.h
 - ext/ruby_compat.h