pax_global_header00006660000000000000000000000064116343045510014514gustar00rootroot0000000000000052 comment=465f9fb60af0d8bef348767894d61863e8ff1d31 perl-Text-Xslate-Bridge-TT2Like-0.00010/000075500000000000000000000000001163430455100174025ustar00rootroot00000000000000perl-Text-Xslate-Bridge-TT2Like-0.00010/.gitignore000064400000000000000000000000161163430455100213670ustar00rootroot00000000000000inc/ Makefile perl-Text-Xslate-Bridge-TT2Like-0.00010/Changes000064400000000000000000000032101163430455100206710ustar00rootroot00000000000000Changes ======= 0.00010 - 15 Sep 2011 * Release solely to fix this Change log * Require Text::Xsate 1.3000 (suggested by nihen) * Changes that went in 0.0009, but had completely escaped my memory: * These filters now *ESCAPE* html before doing their magic html_para html_break html_para_break html_line_break 0.00009 - 15 Sep 2011 * XXX INITIALLY THIS RELEASE WAS DESCRIVED AS "NO CHANGES", BUT THERE WERE CHANGES. SEE 0.00010 ABOVE * Add t/005_xss.t to validate we're safe from potential xss attacks [https://github.com/lestrrat/Text-Xslate-Bridge-TT2Like/pull/1] (gfx) 0.00008 - 11 May 2011 * Now html_* and xml filters return strings that are prorperly marked as raw via Text::Xslate::html_builder() (http://cpanbook.koneta.org/post/5361569358) 0.00007 - 4 Sep 2010 * Grrrr, fight against PAUSE indexer. * No code changes 0.00006 - 3 Sep 2010 * Rename the functions so that they are private * Split up the .pm file and the .pod file so I can auto-generate the list of functions that are available. (request for the list of functions by gfx) * Add pod tests 0.00005 - 9 Aug 2010 * Add truncate() filter. 0.00004 - 1 Aug 2010 * Update Text::Xslate dependency * Remove uri() which is a builtin filter since Xslate 0.1052 (gfx) * Use uri_escape from Xslate 0.1052 as the background for url filter (gfx) 0.00003 - 19 Jul 2010 * Add dynamic filter support (tokuhirom) 0.00002 - 19 Jul 2010 * Add filter support (tokuhirom) * Update Text::Xslate dependency 0.00001 - 09 Jun 2010 * Initial release perl-Text-Xslate-Bridge-TT2Like-0.00010/Makefile.PL000064400000000000000000000024021163430455100213520ustar00rootroot00000000000000use inc::Module::Install; name 'Text-Xslate-Bridge-TT2Like'; all_from 'lib/Text/Xslate/Bridge/TT2Like.pm'; requires 'Text::Xslate' => '1.3000'; requires 'Scalar::Util'; author_tests 'xt'; no_index 'directory' => 'src'; WriteAll; if ($Module::Install::AUTHOR) { warn "Author mode, auto generating pod"; open my $fh, '<', File::Spec->catfile('lib', 'Text', 'Xslate', 'Bridge', 'TT2Like.pm' ) or die "Could not open file : $!"; my $currkey; my %sections; while ( <$fh> ) { next unless /^__PACKAGE__->bridge\(/; while ( <$fh> ) { last if /^\)$/; if (/^\s+(\w+)\s+=>\s+{/) { $currkey = $1; $sections{ $currkey } = []; } elsif ( /^\s+(\w+)\s+=>/ ) { push @{ $sections{ $currkey } }, $1; } } } require Text::Xslate; my $xslate = Text::Xslate->new( syntax => 'TTerse', path => 'src' ); my $string = $xslate->render( 'TT2Like.tx', { sections => \%sections, names => [ sort keys %sections ], } ); open my $pod, '>', File::Spec->catfile('lib', 'Text', 'Xslate', 'Bridge', 'TT2Like.pod' ) or die "Could not open file: $!"; print $pod $string; close $pod; } perl-Text-Xslate-Bridge-TT2Like-0.00010/lib/000075500000000000000000000000001163430455100201505ustar00rootroot00000000000000perl-Text-Xslate-Bridge-TT2Like-0.00010/lib/Text/000075500000000000000000000000001163430455100210745ustar00rootroot00000000000000perl-Text-Xslate-Bridge-TT2Like-0.00010/lib/Text/Xslate/000075500000000000000000000000001163430455100223345ustar00rootroot00000000000000perl-Text-Xslate-Bridge-TT2Like-0.00010/lib/Text/Xslate/Bridge/000075500000000000000000000000001163430455100235305ustar00rootroot00000000000000perl-Text-Xslate-Bridge-TT2Like-0.00010/lib/Text/Xslate/Bridge/TT2Like.pm000064400000000000000000000357131163430455100253150ustar00rootroot00000000000000package Text::Xslate::Bridge::TT2Like; use 5.008001; use strict; use warnings; use base qw(Text::Xslate::Bridge); our $VERSION = '0.00010'; use Scalar::Util 'blessed'; use Text::Xslate; our $TRUNCATE_LENGTH = 32; our $TRUNCATE_ADDON = '...'; __PACKAGE__->bridge( scalar => { item => \&_text_item, list => \&_text_list, hash => \&_text_hash, length => \&_text_length, size => \&_text_size, defined => \&_text_defined, match => \&_text_match, search => \&_text_search, repeat => \&_text_repeat, replace => \&_text_replace, remove => \&_text_remove, split => \&_text_split, chunk => \&_text_chunk, substr => \&_text_substr, }, hash => { item => \&_hash_item, hash => \&_hash_hash, size => \&_hash_size, each => \&_hash_each, keys => \&_hash_keys, values => \&_hash_values, items => \&_hash_items, pairs => \&_hash_pairs, list => \&_hash_list, exists => \&_hash_exists, defined => \&_hash_defined, delete => \&_hash_delete, import => \&_hash_import, sort => \&_hash_sort, nsort => \&_hash_nsort, }, array => { item => \&_list_item, list => \&_list_list, hash => \&_list_hash, push => \&_list_push, pop => \&_list_pop, unshift => \&_list_unshift, shift => \&_list_shift, max => \&_list_max, size => \&_list_size, defined => \&_list_defined, first => \&_list_first, last => \&_list_last, reverse => \&_list_reverse, grep => \&_list_grep, join => \&_list_join, sort => \&_list_sort, nsort => \&_list_nsort, unique => \&_list_unique, import => \&_list_import, merge => \&_list_merge, slice => \&_list_slice, splice => \&_list_splice, }, function => { # 'html' => \&_html_filter, # Xslate has builtin filter for html escape, and it is not overridable. html_para => Text::Xslate::html_builder(\&_html_paragraph), html_break => Text::Xslate::html_builder(\&_html_para_break), html_para_break => Text::Xslate::html_builder(\&_html_para_break), html_line_break => Text::Xslate::html_builder(\&_html_line_break), xml => Text::Xslate::html_builder(\&_xml_filter), # 'uri' => \&uri_escape, # builtin from version 0.1052 url => \&Text::Xslate::uri_escape, upper => sub { uc $_[0] }, lower => sub { lc $_[0] }, ucfirst => sub { ucfirst $_[0] }, lcfirst => sub { lcfirst $_[0] }, # 'stderr' => sub { print STDERR @_; return '' }, # anyone want this?? trim => sub { for ($_[0]) { s/^\s+//; s/\s+$// }; $_[0] }, null => sub { return '' }, collapse => sub { for ($_[0]) { s/^\s+//; s/\s+$//; s/\s+/ /g }; $_[0] }, indent => \&_indent_filter_factory, format => \&_format_filter_factory, truncate => \&_truncate_filter_factory, repeat => \&_repeat_filter_factory, replace => \&_replace_filter_factory, remove => \&_remove_filter_factory, }, ); sub _text_item { $_[0]; } sub _text_list { [ $_[0] ]; } sub _text_hash { { value => $_[0] }; } sub _text_length { length $_[0]; } sub _text_size { return 1; } sub _text_defined { return 1; } sub _text_match { my ($str, $search, $global) = @_; return $str unless defined $str and defined $search; my @matches = $global ? ($str =~ /$search/g) : ($str =~ /$search/); return @matches ? \@matches : ''; } sub _text_search { my ($str, $pattern) = @_; return $str unless defined $str and defined $pattern; return $str =~ /$pattern/; } sub _text_repeat { my ($str, $count) = @_; $str = '' unless defined $str; return '' unless $count; $count ||= 1; return $str x $count; } sub _text_replace { my ($text, $pattern, $replace, $global) = @_; $text = '' unless defined $text; $pattern = '' unless defined $pattern; $replace = '' unless defined $replace; $global = 1 unless defined $global; if ($replace =~ /\$\d+/) { # replacement string may contain backrefs my $expand = sub { my ($chunk, $start, $end) = @_; $chunk =~ s{ \\(\\|\$) | \$ (\d+) }{ $1 ? $1 : ($2 > $#$start || $2 == 0) ? '' : substr($text, $start->[$2], $end->[$2] - $start->[$2]); }exg; $chunk; }; if ($global) { $text =~ s{$pattern}{ &$expand($replace, [@-], [@+]) }eg; } else { $text =~ s{$pattern}{ &$expand($replace, [@-], [@+]) }e; } } else { if ($global) { $text =~ s/$pattern/$replace/g; } else { $text =~ s/$pattern/$replace/; } } return $text; } sub _text_remove { my ($str, $search) = @_; return $str unless defined $str and defined $search; $str =~ s/$search//g; return $str; } sub _text_split { my ($str, $split, $limit) = @_; $str = '' unless defined $str; # we have to be very careful about spelling out each possible # combination of arguments because split() is very sensitive # to them, for example C behaves differently # to C<$space=' '; split($space, ...)> if (defined $limit) { return [ defined $split ? split($split, $str, $limit) : split(' ', $str, $limit) ]; } else { return [ defined $split ? split($split, $str) : split(' ', $str) ]; } } sub _text_chunk { my ($string, $size) = @_; my @list; $size ||= 1; if ($size < 0) { # sexeger! It's faster to reverse the string, search # it from the front and then reverse the output than to # search it from the end, believe it nor not! $string = reverse $string; $size = -$size; unshift(@list, scalar reverse $1) while ($string =~ /((.{$size})|(.+))/g); } else { push(@list, $1) while ($string =~ /((.{$size})|(.+))/g); } return \@list; } sub _text_substr { my ($text, $offset, $length, $replacement) = @_; $offset ||= 0; if(defined $length) { if (defined $replacement) { substr( $text, $offset, $length, $replacement ); return $text; } else { return substr( $text, $offset, $length ); } } else { return substr( $text, $offset ); } } sub _hash_item { my ($hash, $item) = @_; $item = '' unless defined $item; $hash->{ $item }; } sub _hash_hash { $_[0]; } sub _hash_size { scalar keys %{$_[0]}; } sub _hash_each { # this will be changed in TT3 to do what hash_pairs() does [ %{ $_[0] } ]; } sub _hash_keys { [ keys %{ $_[0] } ]; } sub _hash_values { [ values %{ $_[0] } ]; } sub _hash_items { [ %{ $_[0] } ]; } sub _hash_pairs { [ map { { key => $_ , value => $_[0]->{ $_ } } } sort keys %{ $_[0] } ]; } sub _hash_list { my ($hash, $what) = @_; $what ||= ''; return ($what eq 'keys') ? [ keys %$hash ] : ($what eq 'values') ? [ values %$hash ] : ($what eq 'each') ? [ %$hash ] : # for now we do what pairs does but this will be changed # in TT3 to return [ $hash ] by default [ map { { key => $_ , value => $hash->{ $_ } } } sort keys %$hash ]; } sub _hash_exists { exists $_[0]->{ $_[1] }; } sub _hash_defined { # return the item requested, or 1 if no argument # to indicate that the hash itself is defined my $hash = shift; return @_ ? defined $hash->{ $_[0] } : 1; } sub _hash_delete { my $hash = shift; delete $hash->{ $_ } for @_; } sub _hash_import { my ($hash, $imp) = @_; $imp = {} unless ref $imp eq 'HASH'; @$hash{ keys %$imp } = values %$imp; return ''; } sub _hash_sort { my ($hash) = @_; [ sort { lc $hash->{$a} cmp lc $hash->{$b} } (keys %$hash) ]; } sub _hash_nsort { my ($hash) = @_; [ sort { $hash->{$a} <=> $hash->{$b} } (keys %$hash) ]; } sub _list_item { $_[0]->[ $_[1] || 0 ]; } sub _list_list { $_[0]; } sub _list_hash { my $list = shift; if (@_) { my $n = shift || 0; return { map { ($n++, $_) } @$list }; } no warnings; return { @$list }; } sub _list_push { my $list = shift; push(@$list, @_); return ''; } sub _list_pop { my $list = shift; pop(@$list); } sub _list_unshift { my $list = shift; unshift(@$list, @_); return ''; } sub _list_shift { my $list = shift; shift(@$list); } sub _list_max { no warnings; my $list = shift; $#$list; } sub _list_size { no warnings; my $list = shift; $#$list + 1; } sub _list_defined { # return the item requested, or 1 if no argument to # indicate that the hash itself is defined my $list = shift; return @_ ? defined $list->[$_[0]] : 1; } sub _list_first { my $list = shift; return $list->[0] unless @_; return [ @$list[0..$_[0]-1] ]; } sub _list_last { my $list = shift; return $list->[-1] unless @_; return [ @$list[-$_[0]..-1] ]; } sub _list_reverse { my $list = shift; [ reverse @$list ]; } sub _list_grep { my ($list, $pattern) = @_; $pattern ||= ''; return [ grep /$pattern/, @$list ]; } sub _list_join { my ($list, $joint) = @_; join(defined $joint ? $joint : ' ', map { defined $_ ? $_ : '' } @$list); } sub _list_sort_make_key { my ($item, $fields) = @_; my @keys; if (ref($item) eq 'HASH') { @keys = map { $item->{ $_ } } @$fields; } elsif (blessed $item) { @keys = map { $item->can($_) ? $item->$_() : $item } @$fields; } else { @keys = $item; } # ugly hack to generate a single string using a delimiter that is # unlikely (but not impossible) to be found in the wild. return lc join('/*^UNLIKELY^*/', map { defined $_ ? $_ : '' } @keys); } sub _list_sort { my ($list, @fields) = @_; return $list unless @$list > 1; # no need to sort 1 item lists return [ @fields # Schwartzian Transform ? map { $_->[0] } # for case insensitivity sort { $a->[1] cmp $b->[1] } map { [ $_, _list_sort_make_key($_, \@fields) ] } @$list : map { $_->[0] } sort { $a->[1] cmp $b->[1] } map { [ $_, lc $_ ] } @$list, ]; } sub _list_nsort { my ($list, @fields) = @_; return $list unless @$list > 1; # no need to sort 1 item lists return [ @fields # Schwartzian Transform ? map { $_->[0] } # for case insensitivity sort { $a->[1] <=> $b->[1] } map { [ $_, _list_sort_make_key($_, \@fields) ] } @$list : map { $_->[0] } sort { $a->[1] <=> $b->[1] } map { [ $_, lc $_ ] } @$list, ]; } sub _list_unique { my %u; [ grep { ++$u{$_} == 1 } @{$_[0]} ]; } sub _list_import { my $list = shift; push(@$list, grep defined, map ref eq 'ARRAY' ? @$_ : undef, @_); return $list; } sub _list_merge { my $list = shift; return [ @$list, grep defined, map ref eq 'ARRAY' ? @$_ : undef, @_ ]; } sub _list_slice { my ($list, $from, $to) = @_; $from ||= 0; $to = $#$list unless defined $to; $from += @$list if $from < 0; $to += @$list if $to < 0; return [ @$list[$from..$to] ]; } sub _list_splice { my ($list, $offset, $length, @replace) = @_; if (@replace) { # @replace can contain a list of multiple replace items, or # be a single reference to a list @replace = @{ $replace[0] } if @replace == 1 && ref $replace[0] eq 'ARRAY'; return [ splice @$list, $offset, $length, @replace ]; } elsif (defined $length) { return [ splice @$list, $offset, $length ]; } elsif (defined $offset) { return [ splice @$list, $offset ]; } else { return [ splice(@$list) ]; } } sub _xml_filter { my $text = shift; for ($text) { s/&/&/g; s//>/g; s/"/"/g; s/'/'/g; } return $text; } sub _html_paragraph { my $text = shift; return "

\n" . join("\n

\n\n

\n", split(/(?:\r?\n){2,}/, Text::Xslate::Util::html_escape($text))) . "

\n"; } sub _html_para_break { my $text = shift; $text = Text::Xslate::Util::html_escape($text); $text =~ s|(\r?\n){2,}|$1
$1
$1|g; return $text; } sub _html_line_break { my $text = shift; $text = Text::Xslate::Util::html_escape($text); $text =~ s|(\r?\n)|
$1|g; return $text; } sub _indent_filter_factory { my ($pad) = @_; $pad = 4 unless defined $pad; $pad = ' ' x $pad if $pad =~ /^\d+$/; return sub { my $text = shift; $text = '' unless defined $text; $text =~ s/^/$pad/mg; return $text; } } sub _format_filter_factory { my ($format) = @_; $format = '%s' unless defined $format; return sub { my $text = shift; $text = '' unless defined $text; return join("\n", map{ sprintf($format, $_) } split(/\n/, $text)); } } sub _truncate_filter_factory { my ($len, $char) = @_; $len = $TRUNCATE_LENGTH unless defined $len; $char = $TRUNCATE_ADDON unless defined $char; # Length of char is the minimum length my $lchar = length $char; if ($len < $lchar) { $char = substr($char, 0, $len); $lchar = $len; } return sub { my $text = shift; return $text if length $text <= $len; return substr($text, 0, $len - $lchar) . $char; } } sub _repeat_filter_factory { my ($iter) = @_; $iter = 1 unless defined $iter and length $iter; return sub { my $text = shift; $text = '' unless defined $text; return join('\n', $text) x $iter; } } sub _replace_filter_factory { my ($search, $replace) = @_; $search = '' unless defined $search; $replace = '' unless defined $replace; return sub { my $text = shift; $text = '' unless defined $text; $text =~ s/$search/$replace/g; return $text; } } sub _remove_filter_factory { my ($search) = @_; return sub { my $text = shift; $text = '' unless defined $text; $text =~ s/$search//g; return $text; } } 1; perl-Text-Xslate-Bridge-TT2Like-0.00010/src/000075500000000000000000000000001163430455100201715ustar00rootroot00000000000000perl-Text-Xslate-Bridge-TT2Like-0.00010/src/TT2Like.tx000064400000000000000000000033411163430455100217650ustar00rootroot00000000000000=head1 NAME Text::Xslate::Bridge::TT2Like - TT2 Variable Method Clone For Text::Xslate =head1 SYNOPSIS use Text::Xslate; my $xslate = Text::Xslate->new( module => [ 'Text::Xslate::Bridge::TT2Like' ], ); # Note that all methods require a set of parenthesis to be # recognized as a method. $xslate->render_string( '<: $foo.length() :>', { foo => "foo" } ); $xslate->render_string( '<: $foo.replace("foo", "bar") :>', { foo => "foo" } ); =head1 DESCRIPTION Text::Xslate::Bridge::TT2Like exports Template-Toolkit variable methods into Text::Xslate namespace, such that you can use them on your variables. The only difference between this module and Text::Xslate::Bridge::TT2 is that Bridge::TT2 uses Template::Toolkit underneath, while this module is independent of Template::Toolkit and therefore does not require TT to be installed =head1 AVAILABLE FUNCTIONS Upon loading Text::Xslate::Bridge::TT2Like, you will be able to use the following functions in your template. Please note that some functions like C are available from Text::Xslate to start with, so we don't reimplment them. Check the manual for Text::Xslate for more info. [% FOREACH name IN names %] =head2 C<[% name %]> =over 4 [% FOREACH section IN sections.$name %] =item C<[% section %]> [% END %] =back [% END %] =head1 ACKNOWLEDGEMENT Original code was taken from Template::VMethods, Template::Filters by Andy Wardley. =head1 AUTHOR Copyright (c) 2010 Daisuke Maki C<< >> =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See http://www.perl.com/perl/misc/Artistic.html =cutperl-Text-Xslate-Bridge-TT2Like-0.00010/t/000075500000000000000000000000001163430455100176455ustar00rootroot00000000000000perl-Text-Xslate-Bridge-TT2Like-0.00010/t/001_scalar.t000064400000000000000000000023741163430455100216650ustar00rootroot00000000000000use strict; use Test::More; use t::TT2LikeTest qw(render_ok); use_ok "Text::Xslate"; use_ok "Text::Xslate::Bridge::TT2Like"; # note Text::Xslate::Bridge::TT2Like->dump; render_ok '[% foo.length() %]', undef, 3, "foo.length"; render_ok '[% foo.size() %]', undef, 1, "foo.size"; render_ok '[% foo.match( "o", 1 ).join("") %]', undef, 'oo', "foo.match"; render_ok '[% IF (foo.search( "fo" )) %]match[% ELSE %]no match[% END %]', undef, "match", "foo.search (MATCH)"; render_ok '[% IF (foo.search( "bar" )) %]match[% ELSE %]no match[% END %]', undef, "no match", "foo.search (NO MATCH)"; render_ok '[% foo.remove( "oo" ) %]', undef, "f", "foo.remove"; render_ok '[% foobar.split().size() %]', undef, 2, "foobar.split (size)"; render_ok '[% foobar.split().0 %]', undef, "foo", "foobar.split (foo)"; render_ok '[% foobar.split().1 %]', undef, "bar", "foobar.split (bar)"; render_ok '[% foobar.chunk(2).0 %]', undef, "fo", "foobar.chunk 0"; render_ok '[% foobar.chunk(2).1 %]', undef, "o ", "foobar.chunk 1"; render_ok '[% foobar.replace("bar", "baz") %]', undef, "foo baz", "foobar.replace"; render_ok '[% foobar.substr( 0, 2 ) %]', undef, "fo", "foobar.substr (get)"; render_ok '[% foobar.substr( 0, 2, "ba" ) %]', undef, "bao bar", "foobar.substr (replace)"; done_testing(); perl-Text-Xslate-Bridge-TT2Like-0.00010/t/002_array.t000064400000000000000000000037171163430455100215410ustar00rootroot00000000000000use strict; use Test::More; use t::TT2LikeTest qw(render_ok); use_ok "Text::Xslate"; use_ok "Text::Xslate::Bridge::TT2Like"; render_ok '[% strings.size() %]', undef, 4, "strings.size"; render_ok '[% strings.join("-") %]', undef, "abc-def-ghi-jkl", "strings.join"; render_ok '[% CALL strings.push("end"); strings.4 %]', undef, "end", "strings.push"; render_ok '[% strings.pop() %]', undef, "jkl", "strings.pop"; render_ok '[% CALL strings.unshift("begin"); strings.0 %]', undef, "begin", "strings.unshift"; render_ok '[% strings.shift() %]', undef, "abc", "strings.shift"; render_ok '[% strings.max() %]', undef, 3, "strings.max"; render_ok '[% strings.size() %]', undef, 4, "strings.size"; render_ok '[% strings.defined() %]', undef, 1, "strings.defined"; render_ok '[% strings.first() %]', undef, "abc", "strings.first"; render_ok '[% strings.last() %]', undef, "jkl", "strings.last"; render_ok '[% strings.reverse().shift() %]', undef, "jkl", "strings.reverse"; render_ok '[% strings.grep( "[ce]" ).join("-") %]', undef, "abc-def", "strings.grep"; render_ok '[% CALL strings.unshift("zzz"); strings.sort().join("-") %]', undef, 'abc-def-ghi-jkl-zzz', "strings.sort"; render_ok '[% CALL numbers.unshift(99); numbers.nsort().join("-") %]', undef, "1-2-3-4-5-99", "numbers.nsort"; render_ok '[% CALL numbers.unshift(1); numbers.unique().join("-") %]', undef, "1-2-3-4-5", "numbers.unique"; render_ok '[% SET newlist = [ 6, 7, 8, 9 ]; CALL numbers.import( newlist ); numbers.join("-") %]', undef, "1-2-3-4-5-6-7-8-9", "numbers.import"; render_ok '[% SET newlist = numbers.merge( [ 6, 7, 8, 9 ] ); newlist.join("-") %]', undef, "1-2-3-4-5-6-7-8-9", "numbers.merge 1"; render_ok '[% SET newlist = numbers.merge( [ 6, 7, 8, 9 ] ); numbers.join("-") %]', undef, "1-2-3-4-5", "numbers.merge 2"; render_ok '[% numbers.slice( 1, 3 ).join("-") %]', undef, "2-3-4", "numbers.slice"; render_ok '[% CALL numbers.splice( 1, 3, [ 99 ] ); numbers.join("-") %]', undef, "1-99-5", "numbers.splice"; done_testing();perl-Text-Xslate-Bridge-TT2Like-0.00010/t/003_hash.t000064400000000000000000000024401163430455100213370ustar00rootroot00000000000000use strict; use Test::More; use t::TT2LikeTest qw(render_xslate render_ok); use_ok "Text::Xslate"; use_ok "Text::Xslate::Bridge::TT2Like"; render_ok '[% hashmap.item("abc") %]', undef, "def", "hashmap.item"; render_ok '[% hashmap.size() %]', undef, 3, "hashmap.size"; render_ok '[% IF (hashmap.exists("abc")) %]exists[% ELSE %]not there[% END %]', undef, "exists", "hashmap.exists (MATCH)"; render_ok '[% IF (hashmap.exists("foo")) %]exists[% ELSE %]not there[% END %]', undef, "not there", "hashmap.exists (NO MATCH)"; render_ok '[% hashmap.defined() %]', undef, 1, "hashmap.defined"; render_ok '[% CALL hashmap.delete("abc"); FOREACH pair IN hashmap.pairs() %][% pair.key %]:[% pair.value %],[% END %]', undef, qr/ghi:jkl,list:ARRAY/, 'hashmap.delete'; render_ok '[% FOREACH key IN hashmap.sort() %][% key %],[% END %]', undef, "list,abc,ghi,", "hashmap.sort"; render_ok '[% FOREACH key IN hashmap.keys().sort() %][% key %],[% END %]', undef, 'abc,ghi,list,', 'hashmap.keys'; render_ok '[% hashmap.list.item(0).item("list_foo1") %]', undef, "list_bar1", "nested structures"; { my $output = render_xslate '[% FOREACH pair IN hashmap.pairs() %][% pair.key %]:[% pair.value %],[% END %]'; like $output, qr/abc:def,/, "hashmap.pairs"; like $output, qr/ghi:jkl,/, "hashmap.pairs"; } done_testing();perl-Text-Xslate-Bridge-TT2Like-0.00010/t/004_filters.t000064400000000000000000000027631163430455100220750ustar00rootroot00000000000000use strict; use Test::More; use t::TT2LikeTest qw(render_ok); use_ok "Text::Xslate"; use_ok "Text::Xslate::Bridge::TT2Like"; # note(Text::Xslate::Bridge::TT2Like->dump); render_ok q{[% "foo\n\nbar" | html_para %]}, undef, "

\nfoo\n

\n\n

\nbar

\n"; render_ok q{[% "foo\n\nbar" | html_para %]}, undef, "

\nfoo\n

\n\n

\nbar

\n"; render_ok q{[% "foo\n\nbar" | html_break %]}, undef, "foo\n
\n
\nbar"; render_ok q{[% "foo\n\nbar" | html_para_break %]}, undef, "foo\n
\n
\nbar"; render_ok q{[% "foo\n\nbar" | html_line_break %]}, undef, "foo
\n
\nbar"; render_ok q{[% "&'" | xml %]}, undef, "&'"; render_ok q{[% "my file.html" | uri %]}, undef, "my%20file.html"; render_ok q{[% "my file.html" | url %]}, undef, "my%20file.html"; render_ok '[% "foo" | upper %]', undef, "FOO", "foo.uc"; render_ok '[% "fOo" | lower %]', undef, "foo", "foo.lc"; render_ok '[% "foo" | ucfirst %]', undef, "Foo"; render_ok '[% "FOO" | lcfirst %]', undef, "fOO"; render_ok '[% " FOO " | trim %]', undef, "FOO"; render_ok '[% " I am a pen. " | collapse %]', undef, "I am a pen."; render_ok '[% "foo\nbar" | indent("me> ") %]', undef, "me> foo\nme> bar"; render_ok '[% "7" | format("%03d") %]', undef, "007"; render_ok '[% "7" | repeat(3) %]', undef, "777"; render_ok '[% "I am a pen." | replace("pen", "John") %]', undef, "I am a John."; render_ok '[% "pen." | remove("n") %]', undef, "pe."; render_ok '[% "aiueoaiueo" | truncate(5) %]', undef, "ai..."; done_testing(); perl-Text-Xslate-Bridge-TT2Like-0.00010/t/005_xss.t000064400000000000000000000013361163430455100212360ustar00rootroot00000000000000use strict; use Test::More; use t::TT2LikeTest qw(render_ok); use_ok "Text::Xslate"; use_ok "Text::Xslate::Util", "html_escape"; use_ok "Text::Xslate::Bridge::TT2Like"; # note(Text::Xslate::Bridge::TT2Like->dump); my $xss = ""; my $e = html_escape($xss)->as_string; my $vars = { xss => $xss }; render_ok q{[% xss _ "foo\n\nbar" | html_para %]}, $vars, "

\n${e}foo\n

\n\n

\nbar

\n"; render_ok q{[% xss _ "foo\n\nbar" | html_break %]}, $vars, "${e}foo\n
\n
\nbar"; render_ok q{[% xss _ "foo\n\nbar" | html_para_break %]}, $vars, "${e}foo\n
\n
\nbar"; render_ok q{[% xss _ "foo\n\nbar" | html_line_break %]}, $vars, "${e}foo
\n
\nbar"; done_testing(); perl-Text-Xslate-Bridge-TT2Like-0.00010/t/TT2LikeTest.pm000064400000000000000000000023061163430455100222620ustar00rootroot00000000000000package t::TT2LikeTest; use Exporter 'import'; use Test::More (); use Text::Xslate; use Text::Xslate::Bridge::TT2Like; our @EXPORT_OK = qw(render_xslate render_ok); our $XSLATE = Text::Xslate->new( syntax => 'TTerse', module => [ 'Text::Xslate::Bridge::TT2Like' ], ); sub render_xslate { my ($template, $args) = @_; $args ||= { foo => "foo", foobar => "foo bar", strings => [ "abc", "def", "ghi", "jkl" ], numbers => [ 1, 2, 3, 4, 5 ], hashmap => { abc => "def", ghi => "jkl", list => [ { list_foo1 => "list_bar1" }, { list_foo2 => "list_bar2" } ] } }; $XSLATE->render_string( $template, $args ), } sub render_ok { my ($template, $args, $expect, $name) = @_; local $Test::Builder::Level = $Test::Builder::Level + 1; my $ref = ref $expect; if (! $ref ) { $func = \&Test::More::is; } elsif ( $ref =~ /^Reg[Ee]xp$/ ) { $func = \&Test::More::like; } else { die "Don't know how to handle expect type $ref"; } $func->( render_xslate( $template, $args ), $expect, $name ); } 1;perl-Text-Xslate-Bridge-TT2Like-0.00010/xt/000075500000000000000000000000001163430455100200355ustar00rootroot00000000000000perl-Text-Xslate-Bridge-TT2Like-0.00010/xt/999_pod-coverage.t000064400000000000000000000002411163430455100232040ustar00rootroot00000000000000use strict; use Test::More; use Test::Requires; test_requires 'Test::Pod::Coverage'; Test::Pod::Coverage::all_pod_coverage_ok({ trustme => [ 'BUILD' ] }); perl-Text-Xslate-Bridge-TT2Like-0.00010/xt/999_pod.t000064400000000000000000000001361163430455100214160ustar00rootroot00000000000000use Test::More; use Test::Requires; test_requires 'Test::Pod'; Test::Pod::all_pod_files_ok();