',
"can override ->make_external_link" );
like( $html,
qr'foo ',
"...works for external links with titles too" );
package Wiki::Toolkit::Formatter::Kake;
use base "Wiki::Toolkit::Formatter::UseMod";
sub make_edit_link {
my ($self, %args) = @_;
my $title = $args{title};
my $url = $args{url};
return qq|[$title]?|;
}
sub make_internal_link {
my ($self, %args) = @_;
my $title = $args{title};
my $url = $args{url};
return qq|$title|;
}
sub make_external_link {
my ($self, %args) = @_;
my $title = $args{title};
my $url = $args{url};
return qq|$title |;
}
Wiki-Toolkit-Formatter-UseMod-0.24/t/tables.t 0000644 0001750 0001750 00000001517 10421647336 017154 0 ustar dom dom use strict;
use Wiki::Toolkit::Formatter::UseMod;
use Test::More tests => 8;
my $wikitext = <- \s*
- bar 1<\/li>/s, "...second level of nested list" );
# Test ordered lists.
$wikitext = <
- /, "ordered list created" );
like( $html, qr/
- item 1/, "items are ordered" );
Wiki-Toolkit-Formatter-UseMod-0.24/t/macros.t 0000644 0001750 0001750 00000002430 10421647336 017161 0 ustar dom dom use strict;
use Test::More tests => 7;
use Wiki::Toolkit::Formatter::UseMod;
my $wikitext = <
A table cell
|, "no bogus
s" ); Wiki-Toolkit-Formatter-UseMod-0.24/t/external_links.t 0000644 0001750 0001750 00000001251 12011754666 020721 0 ustar dom dom use strict; use Wiki::Toolkit::Formatter::UseMod; use Test::More tests => 2; my $wikitext = <\s*This is paragraph 1./, "first paragraph detected" ); like( $html, qr/
\s*This is paragraph 2./, "second paragraph, separated from first by blank line, detected" ); Wiki-Toolkit-Formatter-UseMod-0.24/t/twf-bug.t 0000644 0001750 0001750 00000000426 10421647336 017253 0 ustar dom dom use strict; use Test::More tests => 1; use Wiki::Toolkit::Formatter::UseMod; my $formatter = Wiki::Toolkit::Formatter::UseMod->new; my $foo = "x"; $foo .= "" if $foo =~ /x/; my $html = $formatter->format("test"); is( $html, "
test
\n", "Text::WikiFormat bug avoided" ); Wiki-Toolkit-Formatter-UseMod-0.24/t/usemod.t 0000644 0001750 0001750 00000011633 11000123633 017155 0 ustar dom dom use strict; local $^W = 1; use Test::More tests => 25; use_ok( "Wiki::Toolkit::Formatter::UseMod" ); print "#\n#### Testing default configuration\n#\n"; my $wikitext = <Welcome
|, "headings work" ); like( $html, qr|LinkInAHeader
|, "...links work in headers" ); like( $html, qr|Header with an = in
|, "...headers may contain =" ); like( $html, qr|- \s*
- This should be a \s*
- definition list with data \s*
- but no terms \s*
- " );
like( $html, qr|
- ", " \n" ], pre => [ "
\npig\npig\n
|, "leading space makes" ); my @links = $formatter->find_internal_links($wikitext); is_deeply( [ sort @links ], [ "LinkInAHeader", "WikiText", "WikiWord" ], "find_internal_links seems to work" ); print "# Found internal links: " . join(", ", sort @links) . "\n"; print "#\n#### Testing HTML escaping\n#\n"; $wikitext = <WIKITEXT $formatter = Wiki::Toolkit::Formatter::UseMod->new; $html = $formatter->format($wikitext); like( $html, qr|£|, "Entities preserved by default." ); unlike( $html, qr||, "HTML tags escaped by default" ); $formatter = Wiki::Toolkit::Formatter::UseMod->new( allowed_tags => [ "strike" ] ); $html = $formatter->format($wikitext); like( $html, qr||, "...but not when we allow them" ); unlike( $html, qr||, "...and ones we don't explicitly allow are escaped" ); like( $html, qr|£|, "Entities still preserved." ); print "#\n#### Testing extended links\n#\n"; $wikitext = <my $formatter = Wiki::Toolkit::Formatter::UseMod->new( extended_links => 0, # $FreeLinks implicit_links => 1, # $WikiLinks force_ucfirst_nodes => 1, # $FreeUpper use_headings => 1, # $UseHeadings allowed_tags => [qw(b i)], # defaults to none macros => {}, pass_wiki_to_macros => 0, node_prefix => 'wiki.pl?', node_suffix => '', edit_prefix => 'wiki.pl?action=edit;id=', edit_suffix => '', munge_urls => 0, external_link_class => 'external', ); Parameters will default to the values shown above (apart from C , which defaults to allowing no tags, and C , which defaults to false). =over 4 =item B C , C , C and C allow you to control the URLs generated for links to other wiki pages. So for example with the defaults given above, a link to the Home node will have the URL C If you wish to have greater control over the links, you may use the C parameter. The value of this should be a subroutine reference. This sub will be called on each internal link after all other formatting and munging I URL escaping has been applied. It will be passed the node name as its first parameter and should return a node name. Note that this will affect the URLs of internal links, but not the link text. Example: # The formatter munges links so node names are ucfirst. # Ensure 'state51' always appears in lower case in node names. munge_node_name => sub { my $node_name = shift; $node_name =~ s/State51/state51/g; return $node_name; } B usage and you should only do it if you I know what you're doing. Consider in particular whether and how your munged nodes are going to be treated by C . =item B By default, we emulate the UseModWiki behaviour of formatting external links with hardcoded square brackets around them. If you would instead prefer to control this with CSS, supply the C parameter to C<< ->new >> - the value of this parameter will be used as the class applied to the link (so it should be a valid CSS class name). Controlling the appearance with CSS is our recommended method, but the default is as described for reasons of backward compatibility. =item B If you set C to true, then your URLs will be more user-friendly, for example http://example.com/wiki.cgi?Mailing_List_Managers rather than http://example.com/wiki.cgi?Mailing%20List%20Managers The former behaviour is the actual UseMod behaviour, but requires a little fiddling about in your code (see C ), so the default is to B munge URLs. =item B Be aware that macros are processed I filtering out disallowed HTML tags and I transforming from wiki markup into HTML. They are also not called in any particular order. The keys of macros should be either regexes or strings. The values can be strings, or, if the corresponding key is a regex, can be coderefs. The coderef will be called with the first nine substrings captured by the regex as arguments. I would like to call it with all captured substrings but apparently this is complicated. You may wish to have access to the overall wiki object in the subs defined in your macro. To do this: =over =item * Pass the wiki object to the C<< ->formatter >> call as described below. =item * Pass a true value in the C parameter when calling C<< ->new >>. =back If you do this, then I coderefs will be called with the wiki object as the first parameter, followed by the first nine captured substrings as described above. Note therefore that setting C may cause backwards compatibility issues. =back Macro examples: # Simple example - substitute a little search box for '@SEARCHBOX' macros => { '@SEARCHBOX' => qq(), } # More complex example - substitute a list of all nodes in a # category for '@INDEX_LINK [[Category Foo]]' pass_wiki_to_macros => 1, macros => { qr/\@INDEX_LINK\s+\[\[Category\s+([^\]]+)]]/ => sub { my ($wiki, $category) = @_; my @nodes = $wiki->list_nodes_by_metadata( metadata_type => "category", metadata_value => $category, ignore_case => 1, ); my $return = "\n"; foreach my $node ( @nodes ) { $return .= "* " . $wiki->formatter->format_link( wiki => $wiki, link => $node, ) . "\n"; } return $return; }, } =cut sub new { my ($class, @args) = @_; my $self = {}; bless $self, $class; $self->_init(@args) or return undef; return $self; } sub _init { my ($self, %args) = @_; # Store the parameters or their defaults. my %defs = ( extended_links => 0, implicit_links => 1, force_ucfirst_nodes => 1, use_headings => 1, allowed_tags => [], macros => {}, pass_wiki_to_macros => 0, node_prefix => 'wiki.pl?', node_suffix => '', edit_prefix => 'wiki.pl?action=edit;id=', edit_suffix => '', munge_urls => 0, munge_node_name => undef, external_link_class => undef, ); my %collated = (%defs, %args); foreach my $k (keys %defs) { $self->{"_".$k} = $collated{$k}; } return $self; } =item B my $html = $formatter->format($submitted_content, $wiki); Escapes any tags which weren't specified as allowed on creation, then interpolates any macros, then translates the raw Wiki language supplied into HTML. A L
paragraph => [ "", "
\n", "", "\n", 1 ], # no bogus
extended_link_delimiters => [ '[[', ']]' ], blocks => { ordered => qr/^\s*([\d]+)\.\s*/, unordered => qr/^\s*\*\s*/, definition => qr/^:\s*/, pre => qr/^\s+/, table => qr/^\|\|/, }, definition => [ "- \n", "
\n", "
\n", "", "\n" ], table => [ qq|\n|, "
\n", sub { my $line = shift; $line =~ s/\|\|$/<\/td>/; $line =~ s/\|\|/<\/td>/g; return (" "," "); }, ], # we don't label unordered lists as "not indented" so we can nest them. indented => { definition => 0, ordered => 0, pre => 0, table => 0, }, blockorder => [ qw( header line ordered unordered code definition pre table paragraph )], nests => { map { $_ => 1} qw( ordered unordered ) }, link => sub { my $link = shift; return $self->format_link( link => $link, wiki => $wiki, ); }, ); return wikiformat($safe, \%format_tags, \%format_opts ); } sub _format_opts { my $self = shift; return ( extended => $self->{_extended_links}, prefix => $self->{_node_prefix}, implicit_links => $self->{_implicit_links} ); } =item B$line"," my $string = $formatter->format_link( link => "Home Node", wiki => $wiki, ); An internal method exposed to make it easy to go from eg * Foo * Bar to * Foo * Bar See Macro Examples above for why you might find this useful. C should be something that would go inside your extended link delimiters. C is optional but should be a L then the method will be able to check whether the node exists yet or not and so will call C<< ->make_edit_link >> instead of C<< ->make_internal_link >> where appropriate. If you don't supply C then C<< ->make_internal_link >> will be called always. This method used to be private so may do unexpected things if you use it in a way that I haven't tested yet. =cut sub format_link { my ($self, %args) = @_; my $link = $args{link}; my %opts = $self->_format_opts; my $wiki = $args{wiki}; my $title; ($link, $title) = split(/\|/, $link, 2) if $opts{extended}; $title =~ s/^\s*// if $title; # strip leading whitespace $title ||= $link; if ( $self->{_force_ucfirst_nodes} ) { $link = $self->_do_freeupper($link); } $link = $self->_munge_spaces($link); $link = $self->{_munge_node_name}($link) if $self->{_munge_node_name}; if (!$link) { return "[Undefined link '$title']"; } my $editlink_not_link = 0; # See whether the linked-to node exists, if we can. if ( $wiki && !$wiki->node_exists( $link ) ) { $editlink_not_link = 1; } $link =~ s/ /_/g if $self->{_munge_urls}; $link = uri_escape( $link ); if ( $editlink_not_link ) { my $prefix = $self->{_edit_prefix}; my $suffix = $self->{_edit_suffix}; return $self->make_edit_link( title => $title, url => $prefix.$link.$suffix, ); } else { my $prefix = $self->{_node_prefix}; my $suffix = $self->{_node_suffix}; return $self->make_internal_link( title => $title, url => $prefix.$link.$suffix, ); } } # CGI.pm is sometimes awkward about actually performing CGI::escapeHTML # if there's a previous instantiation - in the calling script, for example. # So just do it here. sub _escape_HTML { my ($self, $text) = @_; $text =~ s{&}{&}gso; $text =~ s{<}{<}gso; $text =~ s{>}{>}gso; $text =~ s{"}{"}gso; return $text; } =item B my @links_to = $formatter->find_internal_links( $content ); Returns a list of all nodes that the supplied content links to. =cut sub find_internal_links { my ($self, $raw) = @_; @_links_found = (); my %format_opts = $self->_format_opts; my %format_tags = ( extended_link_delimiters => [ '[[', ']]' ], link => sub { my $link = shift; my %opts = $self->_format_opts; my $title; ($link, $title) = split(/\|/, $link, 2) if $opts{extended}; if ( $self->{_force_ucfirst_nodes} ) { $link = $self->_do_freeupper($link); } $link = $self->{_munge_node_name}($link) if $self->{_munge_node_name}; $link = $self->_munge_spaces($link); push @Wiki::Toolkit::Formatter::UseMod::_links_found, $link; return ""; # don't care about output } ); my $foo = wikiformat($raw, \%format_tags, \%format_opts); my @links = @_links_found; @_links_found = (); return @links; } =item B use URI::Escape; $param = $formatter->node_name_to_node_param( "Recent Changes" ); my $url = "wiki.pl?" . uri_escape($param); In usemod, the node name is encoded prior to being used as part of the URL. This method does this encoding (essentially, whitespace is munged into underscores). In addition, if C is in action then the node names will be forced ucfirst if they weren't already. Note that unless C was set to true when C was called, this method will do nothing. =cut sub node_name_to_node_param { my ($self, $node_name) = @_; return $node_name unless $self->{_munge_urls}; my $param = $node_name; $param = $self->_munge_spaces($param); $param = $self->_do_freeupper($param) if $self->{_force_ucfirst_nodes}; $param =~ s/ /_/g; return $param; } =item B my $node = $q->param('node') || ""; $node = $formatter->node_param_to_node_name( $node ); In usemod, the node name is encoded prior to being used as part of the URL, so we must decode it before we can get back the original node name. Note that unless C was set to true when C was called, this method will do nothing. =cut sub node_param_to_node_name { my ($self, $param) = @_; return $param unless $self->{_munge_urls}; # Note that this might not give us back exactly what we started with, # since in the encoding we collapse and trim whitespace; but this is # how usemod does it (as of 0.92) and usemod is what we're emulating. $param =~ s/_/ /g; return $param; } sub _do_freeupper { my ($self, $node) = @_; # This is the FreeUpper usemod behaviour, slightly modified from # their regexp, as we need to do it before we check whether the # node exists ie before we substitute the spaces with underscores. $node = ucfirst($node); $node =~ s|([- _.,\(\)/])([a-z])|$1.uc($2)|ge; return $node; } sub _munge_spaces { my ($self, $node) = @_; # Yes, we really do only munge spaces, not all whitespace. This is # how usemod does it (as of 0.92). $node =~ s/ +/ /g; $node =~ s/^ //; $node =~ s/ $//; return $node } =back =head1 SUBCLASSING The following methods can be overridden to provide custom behaviour. =over =item B my $link = $self->make_edit_link( title => "Home Page", url => "http://example.com/?id=Home", ); This method will be passed a title and a url and should return an HTML snippet. For example, you can add a C attribute to the link like so: sub make_edit_link { my ($self, %args) = @_; my $title = $args{title}; my $url = $args{url}; return qq|[$title]<a href="$url" title="create">?</a>|; } =cut sub make_edit_link { my ($self, %args) = @_; return qq|[$args{title}]<a href="$args{url}">?</a>|; } =item B<make_internal_link> my $link = $self->make_internal_link( title => "Home Page", url => "http://example.com/?id=Home", ); This method will be passed a title and a url and should return an HTML snippet. For example, you can add a C<class> attribute to the link like so: sub make_internal_link { my ($self, %args) = @_; my $title = $args{title}; my $url = $args{url}; return qq|<a href="$url" class="internal">$title</a>|; } =cut sub make_internal_link { my ($self, %args) = @_; return qq|<a href="$args{url}">$args{title}</a>|; } =item B<make_external_link> my $link = $self->make_external_link( title => "London Perlmongers", url => "http://london.pm.org", ); This method will be passed a title and a url and should return an HTML snippet. For example, you can add a little icon after each external link like so: sub make_external_link { my ($self, %args) = @_; my $title = $args{title}; my $url = $args{url}; return qq|<a href="$url">$title</a> <img src="external.gif">|; } =cut sub make_external_link { my ($self, %args) = @_; my ($open, $close) = ( "[", "]" ); my $link_class = $self->{_external_link_class} || ""; if ( $args{title} eq $args{url} || $link_class ) { ($open, $close) = ( "", "" ); } my $ret = qq|$open<a href="$args{url}"| . ( $link_class ? qq| class="$link_class"| : "" ) . qq|>$args{title}</a>$close|; return $ret; } =back =head1 AUTHOR Kake Pugh (kake@earth.li) and the Wiki::Toolkit team. =head1 COPYRIGHT Copyright (C) 2003-2004 Kake Pugh. All Rights Reserved. Copyright (C) 2006-2012 the Wiki::Toolkit team. All Rights Reserved. This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =head1 CREDITS The OpenGuides London team (L<http://openguides.org/london/>) sent some very helpful bug reports. A lot of the work of this module is done within chromatic's module, L<Text::WikiFormat>. =head1 CAVEATS This doesn't yet support all of UseMod's formatting features and options, by any means. This really truly I<is> a 0.* release. Please send bug reports, omissions, patches, and stuff, to me at C<kake@earth.li>. =head1 NOTE ON USEMOD COMPATIBILITY UseModWiki "encodes" node names before making them part of a URL, so for example a node about Wombat Defenestration will have a URL like http://example.com/wiki.cgi?Wombat_Defenestration So if we want to emulate a UseModWiki exactly, we need to munge back and forth between node names as titles, and node names as CGI params. my $formatter = Wiki::Toolkit::Formatter::UseMod->new( munge_urls => 1 ); my $node_param = $q->param('id') || $q->param('keywords') || ""; my $node_name = $formatter->node_param_to_node_name( $node_param ); use URI::Escape; my $url = "http://example.com/wiki.cgi?" . uri_escape( $formatter->node_name_to_node_param( "Wombat Defenestration" ) ); =head1 SEE ALSO =over 4 =item * L<Wiki::Toolkit> =item * L<Text::WikiFormat> =item * UseModWiki (L<http://www.usemod.com/cgi-bin/wiki.pl>) =back =cut 1;
- item 1/, "items are ordered" );
Wiki-Toolkit-Formatter-UseMod-0.24/t/macros.t 0000644 0001750 0001750 00000002430 10421647336 017161 0 ustar dom dom use strict;
use Test::More tests => 7;
use Wiki::Toolkit::Formatter::UseMod;
my $wikitext = <