File Coverage

blib/lib/Dancer/Plugin/SiteMap.pm

Criterion	Covered	Total	%
statement	4	6	66.6
branch			n/a
condition			n/a
subroutine	2	2	100.0
pod			n/a
total	6	8	75.0

package Dancer::Plugin::SiteMap;

use strict;
use Dancer qw(:syntax);
use Dancer::Plugin;

use Scalar::Util;
use XML::Simple;

our $VERSION     = '0.14';
my  $OMIT_ROUTES = [];
my  @sitemap_urls;

# Add syntactic sugar for omitting routes.
register 'sitemap_ignore' => sub {

    # Dancer 2 keywords receive a reference to the DSL object as a first param,
    # So if we're running under D2, we need to make sure we don't pass that on
    # to the route gathering code.
    shift if Scalar::Util::blessed($_[0]) && $_[0]->isa('Dancer::Core::DSL');
    push @$Dancer::Plugin::SiteMap::OMIT_ROUTES, @_;
};

# Add this plugin to Dancer, both Dancer 1 and Dancer 2 :-)
register_plugin( for_versions => [ qw( 1 2 ) ] );

my $conf   = plugin_setting();
my %routes = (
    html => {
        urlpath => '/sitemap',
        coderef => \&_html_sitemap,
    },
    xml  => {
        urlpath => '/sitemap.xml',
        coderef => \&_xml_sitemap,
    },
);

# If a route exists but it's not defined within the app settings, this means the
# developer wishes the app omit that particular sitemap type. If the route
# doesn't exist in the plugin settings at all, we go with the default urlpath
# for that route.
for my $route_type (keys %routes) {
    my $route      = $routes{$route_type};
    my $config_key = $route_type . "_route";

    if (exists $conf->{$config_key}) {
        $route->{urlpath} = $conf->{$config_key} || undef;
    }

    get $route->{urlpath} => $route->{coderef} if $route->{urlpath};
}

# Add omissions defined in the robots.txt file, if that option is specified in
# the config.
if ( defined $conf->{'robots_disallow'} ) {

    # Read the Disallow lines from robots.txt and add to $OMIT_ROUTES
    my $robots_txt = $conf->{'robots_disallow'};
    my @disallowed_list = ();
    open my $robots_fh, '<', $robots_txt or die "Error reading $robots_txt $!";

    while (my $line = <$robots_fh>) {
        if ($line =~ m/^\s*Disallow: \s*(\/[^\s#]*)/) {
            push @disallowed_list, $1;
        }
    }

    close $robots_fh;
    sitemap_ignore(@disallowed_list);
}

# The action handler for the automagic /sitemap route. Uses the list of
# URLs from _retreive_get_urls and outputs a basic HTML template to the
# browser using the standard layout if one is defined.
sub _html_sitemap {
    my @urls = _retreive_get_urls();

    my $content = qq[Site Map\n\n];
    for my $url (@urls) {
        $content .= qq[  $url\n];
    }
    $content .= qq[\n];

    # If the config specifies a HTML Wrapper for the HTML SiteMap - then use
    # that (which handily also stuffs it in the layout). Failing that, we need
    # to just take the sitemap and whack it in the site layout
    return ($conf->{html_template})
        ? template $conf->{html_template}, { sitemap => $content }
        : engine('template')->apply_layout($content);
};


# The action handler for the automagic /sitemap.xml route. Uses the list of
# URLs from _retreive_get_urls and outputs an XML document to the browser.
sub _xml_sitemap {
    my @urls = _retreive_get_urls();
    my @sitemap_urls;

    # add the "loc" key to each url so XML::Simple creates  tags.
    for my $url (@urls) {
        my $uri = uri_for($url);
        push @sitemap_urls, { loc => [ "$uri" ] }; # $uri has to be stringified
    }

    # create a hash for XML::Simple to turn into XML.
    my %urlset = (
        xmlns => 'http://www.sitemaps.org/schemas/sitemap/0.9',
        url   => \@sitemap_urls
    );

    my $xs  = new XML::Simple( KeepRoot   => 1,
                               ForceArray => 0,
                               KeyAttr    => {urlset => 'xmlns'},
                               XMLDecl    => '' );
    my $xml = $xs->XMLout( { urlset => \%urlset } );

    content_type "text/xml";
    return $xml;
};


# Obtains the list of URLs from Dancers Route Registry.
sub _retreive_get_urls {
    return @sitemap_urls if @sitemap_urls;

    my $version = (exists &dancer_version) ? int( dancer_version() ) : 1;
    my @apps    = ($version == 2) ? @{ runner->server->apps }
                                  : Dancer::App->applications;

    my ($route, @urls);
    for my $app ( @apps ) {
        my $routes = ($version == 2) ? $app->routes
                                     : $app->{registry}->{routes};

        # push the static get routes into an array.
        get_route:
        for my $get_route ( @{ $routes->{get} } ) {
            my $pattern = ($version == 2) ? $get_route->spec_route
                                          : $get_route->{pattern};

            if (ref($pattern) !~ m/HASH/i) {

                # If the pattern is a true comprehensive regexp or the route
                # has a :variable element to it, then omit it. Dancer 2 also
                # has /** entries - we'll dump them too.
                next get_route if ($pattern =~ m/[()[\]|]|:\w/);
                next get_route if ($pattern =~ m{/\*\*});

                # If there is a wildcard modifier, then drop it and have the
                # full route.
                $pattern =~ s/\?//g;

                # Only add any given route once.
                next get_route if grep { $_ eq $pattern } @urls;

                # Other than that, its cool to be added.
                push (@urls, $pattern)
                    if ! grep { $pattern =~ m/^$_/i }
                              @$Dancer::Plugin::SiteMap::OMIT_ROUTES;
            }
        }
    }

    return @sitemap_urls = sort(@urls);
}


1; # End of Dancer::Plugin::SiteMap
__END__