wikitext 1.8 → 1.9

data/ext/parser.c

@@ -1042,12 +1042,15 @@ VALUE Wikitext_parser_parse(int argc, VALUE *argv, VALUE self)
     // process options hash
     int base_indent = 0;
     int base_heading_level = NUM2INT(rb_iv_get(self, "@base_heading_level"));
+    VALUE link_proc = Qnil;
     if (!NIL_P(options) && TYPE(options) == T_HASH)
     {
         // :indent => 0 (or more)
-        if (rb_funcall(options, rb_intern("has_key?"), 1, ID2SYM(rb_intern("indent"))) == Qtrue)
+        ID has_key = rb_intern("has_key?");
+        ID id = ID2SYM(rb_intern("indent"));
+        if (rb_funcall(options, has_key, 1, id) == Qtrue)
         {
-            VALUE indent = rb_hash_aref(options, ID2SYM(rb_intern("indent")));
+            VALUE indent = rb_hash_aref(options, id);
             if (indent == Qfalse)
                 base_indent = -1; // indentation disabled
             else
@@ -1059,8 +1062,14 @@ VALUE Wikitext_parser_parse(int argc, VALUE *argv, VALUE self)
         }
 
         // :base_heading_level => 0/1/2/3/4/5/6
-        if (rb_funcall(options, rb_intern("has_key?"), 1, ID2SYM(rb_intern("base_heading_level"))) == Qtrue)
-            base_heading_level = NUM2INT(rb_hash_aref(options, ID2SYM(rb_intern("base_heading_level"))));
+        id = ID2SYM(rb_intern("base_heading_level"));
+        if (rb_funcall(options, has_key, 1, id) == Qtrue)
+            base_heading_level = NUM2INT(rb_hash_aref(options, id));
+
+        // :link_proc => lambda { |link_target| ... }
+        id = ID2SYM(rb_intern("link_proc"));
+        if (rb_funcall(options, has_key, 1, id) == Qtrue)
+            link_proc = rb_hash_aref(options, id);
     }
 
     // normalize, regardless of whether this came from instance variable or override
@@ -2144,10 +2153,23 @@ VALUE Wikitext_parser_parse(int argc, VALUE *argv, VALUE self)
                     }
                     else
                         wiki_trim_link_text(parser);
+
+                    // perform "redlink" check before manipulating link_target
+                    if (NIL_P(link_proc))
+                        j = Qnil;
+                    else
+                    {
+                        j = rb_funcall(link_proc, rb_intern("call"), 1, string_from_str(parser->link_target));
+                        if (!NIL_P(j))
+                        {
+                            VALUE l = j; // can't cast inside StringValue macro
+                            j = StringValue(l);
+                        }
+                    }
                     wiki_encode_link_target(parser);
                     wiki_pop_from_stack_up_to(parser, output, LINK_START, true);
                     parser->capture = NULL;
-                    wiki_append_hyperlink(parser, prefix, parser->link_target, parser->link_text, Qnil, false);
+                    wiki_append_hyperlink(parser, prefix, parser->link_target, parser->link_text, j, false);
                     str_clear(parser->link_target);
                     str_clear(parser->link_text);
                 }

data/lib/wikitext/nil_class.rb

@@ -25,7 +25,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'ext',
   'wikitext'))
 
 class NilClass
-  def to_wikitext
+  def to_wikitext options = {}
     ''
   end
   alias :w :to_wikitext

data/lib/wikitext/version.rb

@@ -22,5 +22,5 @@
 # POSSIBILITY OF SUCH DAMAGE.
 
 module Wikitext
-  VERSION = '1.8'
+  VERSION = '1.9'
 end # module Wikitext

data/spec/internal_link_spec.rb

@@ -114,6 +114,119 @@ describe Wikitext::Parser, 'internal links (space to underscore off)' do
     @parser.parse('foo [[bar]] baz').should == expected # was a bug
   end
 
+  describe '"red link" support' do
+    it 'should accept a Proc object via the optional "link_proc" parameter' do
+      @parser.parse('foo', :link_proc => Proc.new { }).should == %Q{<p>foo</p>\n}
+    end
+
+    it 'should accept a lambda via the optional "link_proc" parameter' do
+      @parser.parse('foo', :link_proc => lambda { }).should == %Q{<p>foo</p>\n}
+    end
+
+    it 'should apply custom link CSS when supplied (Proc object version)' do
+      link_proc = Proc.new { |target| target == 'bar' ? 'redlink' : nil }
+      expected = %Q{<p><a href="/wiki/foo">foo</a> <a href="/wiki/bar" class="redlink">bar</a></p>\n}
+      @parser.parse('[[foo]] [[bar]]', :link_proc => link_proc).should == expected
+    end
+
+    it 'should apply custom link CSS when supplied (lambda version)' do
+      link_proc = lambda { |target| target == 'bar' ? 'redlink' : nil }
+      expected = %Q{<p><a href="/wiki/foo">foo</a> <a href="/wiki/bar" class="redlink">bar</a></p>\n}
+      @parser.parse('[[foo]] [[bar]]', :link_proc => link_proc).should == expected
+    end
+
+    it 'should apply no custom link CSS when supplied nil (Proc object version)' do
+      expected = %Q{<p><a href="/wiki/foo">foo</a></p>\n}
+      @parser.parse('[[foo]]', :link_proc => Proc.new { |target| nil }).should == expected
+    end
+
+    it 'should apply no custom link CSS when supplied nil (lambda version)' do
+      expected = %Q{<p><a href="/wiki/foo">foo</a></p>\n}
+      @parser.parse('[[foo]]', :link_proc => lambda { |target| nil }).should == expected
+    end
+
+    it 'should let exceptions bubble up from the link proc (Proc object version)' do
+      lambda { @parser.parse('[[foo]]', :link_proc => Proc.new { |target| raise 'bar' }) }.should raise_error(RuntimeError, /bar/)
+    end
+
+    it 'should let exceptions bubble up from the link proc (lambda version)' do
+      lambda { @parser.parse('[[foo]]', :link_proc => lambda { |target| raise 'bar' }) }.should raise_error(RuntimeError, /bar/)
+    end
+
+    it 'should complain if the link proc returns a non-stringy object (Proc object version)' do
+      lambda {
+        @parser.parse '[[foo]]', :link_proc => Proc.new { 1 }
+      }.should raise_error(TypeError, /can't convert/)
+    end
+
+    it 'should complain if the link proc returns a non-stringy object (lambda version)' do
+      lambda {
+        @parser.parse '[[foo]]', :link_proc => lambda { 1 }
+      }.should raise_error(TypeError, /can't convert/)
+    end
+
+    # a couple of Ruby's idiosynchrasies: different behaviour of lambdas and Procs
+    it 'should not complain if the Proc object accepts too many arguments' do
+      lambda {
+        @parser.parse '[[foo]]', :link_proc => Proc.new { |a,b| }
+      }.should_not raise_error(ArgumentError, /wrong number/)
+    end
+
+    it 'should complain if the lambda accepts too many arguments' do
+      lambda {
+        @parser.parse '[[foo]]', :link_proc => lambda { |a,b| }
+      }.should raise_error(ArgumentError, /wrong number/)
+    end
+
+    it 'should complain when "return" is used inside a "Proc.new" block' do
+      lambda {
+        @parser.parse '[[foo]]', :link_proc => Proc.new { return 'bar' }
+      }.should raise_error(LocalJumpError)
+    end
+
+    it 'should not complain when "return" is used inside a lambda' do
+      lambda {
+        @parser.parse '[[foo]]', :link_proc => lambda { return 'bar' }
+      }.should_not raise_error(LocalJumpError)
+    end
+
+    it 'should interact correctly with spaces in link targets (Proc object version)' do
+      link_proc = Proc.new { |target| target == 'bar b' ? 'redlink' : nil }
+      expected = %Q{<p><a href="/wiki/foo%20a">foo a</a> <a href="/wiki/bar%20b" class="redlink">bar b</a></p>\n}
+      @parser.parse('[[foo a]] [[bar b]]', :link_proc => link_proc).should == expected
+    end
+
+    it 'should interact correctly with spaces in link targets (lambda version)' do
+      link_proc = lambda { |target| target == 'bar b' ? 'redlink' : nil }
+      expected = %Q{<p><a href="/wiki/foo%20a">foo a</a> <a href="/wiki/bar%20b" class="redlink">bar b</a></p>\n}
+      @parser.parse('[[foo a]] [[bar b]]', :link_proc => link_proc).should == expected
+    end
+
+    it 'should interact correctly with explicit link text (Proc object version)' do
+      link_proc = Proc.new { |target| target == 'bar b' ? 'redlink' : nil }
+      expected = %Q{<p><a href="/wiki/foo%20a">hello</a> <a href="/wiki/bar%20b" class="redlink">world</a></p>\n}
+      @parser.parse('[[foo a|hello]] [[bar b|world]]', :link_proc => link_proc).should == expected
+    end
+
+    it 'should interact correctly with explicit link text (lambda version)' do
+      link_proc = lambda { |target| target == 'bar b' ? 'redlink' : nil }
+      expected = %Q{<p><a href="/wiki/foo%20a">hello</a> <a href="/wiki/bar%20b" class="redlink">world</a></p>\n}
+      @parser.parse('[[foo a|hello]] [[bar b|world]]', :link_proc => link_proc).should == expected
+    end
+
+    it 'should handle link targets with encoded parts (Proc object version)' do
+      link_proc = Proc.new { |target| target == 'información' ? 'redlink' : nil }
+      expected = %Q{<p><a href="/wiki/informaci%c3%b3n" class="redlink">informaci&#x00f3;n</a> <a href="/wiki/bar">bar</a></p>\n}
+      @parser.parse('[[información]] [[bar]]', :link_proc => link_proc).should == expected
+    end
+
+    it 'should handle link targets with encoded parts (lambda version)' do
+      link_proc = lambda { |target| target == 'información' ? 'redlink' : nil }
+      expected = %Q{<p><a href="/wiki/informaci%c3%b3n" class="redlink">informaci&#x00f3;n</a> <a href="/wiki/bar">bar</a></p>\n}
+      @parser.parse('[[información]] [[bar]]', :link_proc => link_proc).should == expected
+    end
+  end
+
   describe 'custom link text' do
     it 'should recognize link text placed after the separator' do
       @parser.parse('[[foo|bar]]').should == %Q{<p><a href="/wiki/foo">bar</a></p>\n}
@@ -541,6 +654,119 @@ describe Wikitext::Parser, 'internal links (space to underscore on)' do
     @parser.parse('foo [[bar]] baz').should == expected # was a bug
   end
 
+  describe '"red link" support' do
+    it 'should accept a Proc object via the optional "link_proc" parameter' do
+      @parser.parse('foo', :link_proc => Proc.new { }).should == %Q{<p>foo</p>\n}
+    end
+
+    it 'should accept a lambda via the optional "link_proc" parameter' do
+      @parser.parse('foo', :link_proc => lambda { }).should == %Q{<p>foo</p>\n}
+    end
+
+    it 'should apply custom link CSS when supplied (Proc object version)' do
+      link_proc = Proc.new { |target| target == 'bar' ? 'redlink' : nil }
+      expected = %Q{<p><a href="/wiki/foo">foo</a> <a href="/wiki/bar" class="redlink">bar</a></p>\n}
+      @parser.parse('[[foo]] [[bar]]', :link_proc => link_proc).should == expected
+    end
+
+    it 'should apply custom link CSS when supplied (lambda version)' do
+      link_proc = lambda { |target| target == 'bar' ? 'redlink' : nil }
+      expected = %Q{<p><a href="/wiki/foo">foo</a> <a href="/wiki/bar" class="redlink">bar</a></p>\n}
+      @parser.parse('[[foo]] [[bar]]', :link_proc => link_proc).should == expected
+    end
+
+    it 'should apply no custom link CSS when supplied nil (Proc object version)' do
+      expected = %Q{<p><a href="/wiki/foo">foo</a></p>\n}
+      @parser.parse('[[foo]]', :link_proc => Proc.new { |target| nil }).should == expected
+    end
+
+    it 'should apply no custom link CSS when supplied nil (lambda version)' do
+      expected = %Q{<p><a href="/wiki/foo">foo</a></p>\n}
+      @parser.parse('[[foo]]', :link_proc => lambda { |target| nil }).should == expected
+    end
+
+    it 'should let exceptions bubble up from the link proc (Proc object version)' do
+      lambda { @parser.parse('[[foo]]', :link_proc => Proc.new { |target| raise 'bar' }) }.should raise_error(RuntimeError, /bar/)
+    end
+
+    it 'should let exceptions bubble up from the link proc (lambda version)' do
+      lambda { @parser.parse('[[foo]]', :link_proc => lambda { |target| raise 'bar' }) }.should raise_error(RuntimeError, /bar/)
+    end
+
+    it 'should complain if the link proc returns a non-stringy object (Proc object version)' do
+      lambda {
+        @parser.parse '[[foo]]', :link_proc => Proc.new { 1 }
+      }.should raise_error(TypeError, /can't convert/)
+    end
+
+    it 'should complain if the link proc returns a non-stringy object (lambda version)' do
+      lambda {
+        @parser.parse '[[foo]]', :link_proc => lambda { 1 }
+      }.should raise_error(TypeError, /can't convert/)
+    end
+
+    # a couple of Ruby's idiosynchrasies: different behaviour of lambdas and Procs
+    it 'should not complain if the Proc object accepts too many arguments' do
+      lambda {
+        @parser.parse '[[foo]]', :link_proc => Proc.new { |a,b| }
+      }.should_not raise_error(ArgumentError, /wrong number/)
+    end
+
+    it 'should complain if the lambda accepts too many arguments' do
+      lambda {
+        @parser.parse '[[foo]]', :link_proc => lambda { |a,b| }
+      }.should raise_error(ArgumentError, /wrong number/)
+    end
+
+    it 'should complain when "return" is used inside a "Proc.new" block' do
+      lambda {
+        @parser.parse '[[foo]]', :link_proc => Proc.new { return 'bar' }
+      }.should raise_error(LocalJumpError)
+    end
+
+    it 'should not complain when "return" is used inside a lambda' do
+      lambda {
+        @parser.parse '[[foo]]', :link_proc => lambda { return 'bar' }
+      }.should_not raise_error(LocalJumpError)
+    end
+
+    it 'should interact correctly with spaces in link targets (Proc object version)' do
+      link_proc = Proc.new { |target| target == 'bar b' ? 'redlink' : nil }
+      expected = %Q{<p><a href="/wiki/foo_a">foo a</a> <a href="/wiki/bar_b" class="redlink">bar b</a></p>\n}
+      @parser.parse('[[foo a]] [[bar b]]', :link_proc => link_proc).should == expected
+    end
+
+    it 'should interact correctly with spaces in link targets (lambda version)' do
+      link_proc = lambda { |target| target == 'bar b' ? 'redlink' : nil }
+      expected = %Q{<p><a href="/wiki/foo_a">foo a</a> <a href="/wiki/bar_b" class="redlink">bar b</a></p>\n}
+      @parser.parse('[[foo a]] [[bar b]]', :link_proc => link_proc).should == expected
+    end
+
+    it 'should interact correctly with explicit link text (Proc object version)' do
+      link_proc = Proc.new { |target| target == 'bar b' ? 'redlink' : nil }
+      expected = %Q{<p><a href="/wiki/foo_a">hello</a> <a href="/wiki/bar_b" class="redlink">world</a></p>\n}
+      @parser.parse('[[foo a|hello]] [[bar b|world]]', :link_proc => link_proc).should == expected
+    end
+
+    it 'should interact correctly with explicit link text (lambda version)' do
+      link_proc = lambda { |target| target == 'bar b' ? 'redlink' : nil }
+      expected = %Q{<p><a href="/wiki/foo_a">hello</a> <a href="/wiki/bar_b" class="redlink">world</a></p>\n}
+      @parser.parse('[[foo a|hello]] [[bar b|world]]', :link_proc => link_proc).should == expected
+    end
+
+    it 'should handle link targets with encoded parts (Proc object version)' do
+      link_proc = Proc.new { |target| target == 'información' ? 'redlink' : nil }
+      expected = %Q{<p><a href="/wiki/informaci%c3%b3n" class="redlink">informaci&#x00f3;n</a> <a href="/wiki/bar">bar</a></p>\n}
+      @parser.parse('[[información]] [[bar]]', :link_proc => link_proc).should == expected
+    end
+
+    it 'should handle link targets with encoded parts (lambda version)' do
+      link_proc = lambda { |target| target == 'información' ? 'redlink' : nil }
+      expected = %Q{<p><a href="/wiki/informaci%c3%b3n" class="redlink">informaci&#x00f3;n</a> <a href="/wiki/bar">bar</a></p>\n}
+      @parser.parse('[[información]] [[bar]]', :link_proc => link_proc).should == expected
+    end
+  end
+
   describe 'custom link text' do
     it 'should recognize link text placed after the separator' do
       @parser.parse('[[foo|bar]]').should == %Q{<p><a href="/wiki/foo">bar</a></p>\n}

data/spec/nil_class_spec.rb

@@ -33,4 +33,8 @@ describe NilClass, 'wikitext extensions' do
   it 'should provide a w method on the nil singleton' do
     nil.w.should == ''
   end
+
+  it 'should accept and ignore an optional options hash' do
+    lambda { nil.w :base_heading_level => 3 }.should_not raise_error
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: wikitext
 version: !ruby/object:Gem::Version 
-  version: "1.8"
+  version: "1.9"
 platform: ruby
 authors: 
 - Wincent Colaiuta
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-27 00:00:00 +02:00
+date: 2009-08-06 00:00:00 +02:00
 default_executable: 
 dependencies: []