#!/usr/bin/perl -w
# file KLEIDER/web/src/addstory/mksitemap.pl
# Erstellt eine sitemap-Datei
# 2017-06-17 Herbert Schiemann <h.schiemann@herbaer.de>
# GPL Version 2 oder neuer

# 2012-07-11 überarbeitet
# 2012-08-22 Voreinstellungen --ignoredir, --ignorefile
# 2012-09-26 Voreinstellung --ignorefile (.gz)
# 2012-10-30 --chgweekly
# 2013-02-08 Voreinstellung --ignoredir
# 2013-02-26 Dateien error_*.xhtml, save.* ignorieren
# 2013-03-27 Voreinstellung --chgweekly
# 2013-07-19 Voreinstellung --ignoredir
# 2014-12-04 --ignoresfx, --rmsfx
# 2015-07-18 Deutschsprachige Version suchen
# 2015-07-26 Voreinstellung --ignoredir: l.* (l, local)
# 2015-12-23 Abgleich IGNOREDIR und IGNOREFILE mit den Pfaden
# 2017-04-18 Dateien #.* ignorieren
# 2017-06-17 Anpassung /f/ statt /favourites/

package main;

use utf8;
use Cwd qw(realpath);
use Herbaer::Readargs;             # read_args ()
use Encode;
use File::Spec::Functions qw(catfile catdir file_name_is_absolute);
use POSIX qw(strftime);

binmode (STDOUT, ":raw:encoding(utf-8)") ;
binmode (STDERR, ":raw:encoding(utf-8)") ;

sub version {
   print <<'VERSION' ;
KLEIDER/web/src/addstory/mksitemap.pl
2017-06-17 Herbert Schiemann <h.schiemann@herbaer.de>
VERSION
}

my $webbase = realpath ($0);
$webbase =~ s/\/src\/addstory\/mksitemap\.pl//;

# Hash der Kommandozeilen-Argumente
my $args = {
   "[cnt]verbose" => 1,
   "webdir"       => "$webbase/docroot",             # Webverzeichnis
   "rooturl"      => "http://kleider.herbaer.de/",   # URL der Wurzel

   # Name oder Pfad der sitemap-Datei
   "sitemapfile"  => "sitemap.xml",

   # Verweis in der XSLT-Anweisung in der Ausgabe
   "xslt"         => "style/sitemap_ht.xslt",

   # Priorität für Dateien ausser *index.xhtml und *story.xml
   "priority"     => 0.4,

   # Regex der zu ignorierenden Verzeichnispfade
   "ignoredir"    =>
   '(?:/error|/images|/smallimg|/thumbs|/helpmontage|/montage|/style.*'
   . '|/pool|/puppen|/src|/peruecken|/supplement|/l.*|[._-](?:old|save|x)'
   . '|/kal/b|/kal/s'
   . ')$',
   
   # Regex der zu ignorierenden Dateipfade
   "ignorefile"   =>
   '(?:/\..*|/#.*|/sitemap.*|/baustelle.*|/error.*|/robots.*'
   . '|/(?:old|save|whisky)[._-].+|(?:old|save|whisky)'
   . '|/kal/index\..*|/kal/.*/index\..*|~'
   . '|/f/.*\.xslt\..*|/f/.*\.xml\..*)$',

   # Regex der Suffixe der zu ignorierenden Dateien
   "ignoresfx"    => '\.(?:old|save|whisky|zh|ru|jpg|gz)\b',

   # Regex der zu entfernenden Suffixe
   "rmsfx"        => '(?:\.$|\.de\b)',

   # Regex der Pfade der Dateien, die wöchentlich geändert werden
   "chgweekly"    => '/index.xhtml$',
};

$args -> {"[sr]version"} = sub { version (); exit 0; };

$args -> {"[sr]help"} = sub {
   version ();
   print_message_with_values (<<"HELP", $args);
$0 --help     zeigt diese Hilfe an
$0 --version  zeigt die Programm-Version an

$0 [option]...
--[no_]verbose             Umfang der STDERR-Ausgabe \${[cnt]verbose}
--webdir      WEBDIR       Lokales Verzeichnis des Webserver-Inhalts
                           \${webdir}
--rooturl     ROOTURL      URL der Wurzel
                           \${rooturl}
--sitemapfile SITEMAPFILE  Dateiname oder Pfad der Sitemap-Datei
                           \${sitemapfile}
--xslt        XSLT         Verweisziel der Stylesheet-Anweisung oder 'none'
                           \${xslt}
--priority    PRIO         Priorität für Dateien ausser *index.xslt und *story.xml
                           \${priority}
--ignoredir   IGNOREDIR    Regex der zu ignorierenden Verzeichnisnamen
                           \${ignoredir}
--ignorefile  IGNOREFILE   Regex der zu ignorierenden Dateinamen
                           \${ignorefile}
--ignoresfx   IGNORESFX    Regex der Kennungen der zu ignorierenden Sprachen
                           \${ignoresfx}
--rmsfx       RMSFX        Regex der zu entfernenden Suffixe
                           \${rmsfx}
--chgweekly   CHGWEEKLY    Regex der Pfade der Dateien, die wöchentlich geändert werden
                           \${chgweekly}
HELP
   exit 0;
}; # version

read_args ($args);
my $verbose = $args -> {"[cnt]verbose"};

my $sfxes = {
   "css"  => "css",
   "js"   => "javascript",
   "xslt" => "xslt",
   "pl"   => "perl",
};
my $urllist = [];

buildRegex   ($args);   # Erstellt die regulären Ausdrücke
buildUrllist ($urllist, $args, "");
my $smf = $args -> {"sitemapfile"};
$smf = catfile ($args -> {"webdir"}, $smf) unless file_name_is_absolute ($smf);
writeSitemap ($urllist, $args, $smf);

# Erstellt die regulären Ausdrücke
sub buildRegex {
   my $args = shift;
   my $wrd;
   my $re;
   for $wrd ("dir", "file", "sfx") {
      $re = $args -> {"ignore$wrd"};
      $args -> {"re_$wrd"} = qr/$re/ ;
   }
   for $wrd ("chgweekly", "rmsfx") {
      $re = $args -> {$wrd};
      $args -> {"re_$wrd"} = qr/$re/ ;
   }
} # buildRegex

# erstellt eine Liste der zu indizierenden Dokumente
sub buildUrllist {
   my ($urllist, $args, $subdir) = @_ ;
   print STDERR $subdir ? "Verzeichnis \"$subdir\"\n" : "Liste der URL\n" if $verbose;
   my $re_file = $args -> {"re_file"};   # Regex der Namen auszuschließender Dateien
   my $re_dir  = $args -> {"re_dir"};    # Regex der Namen auszuschl. Unterverzeichnisse
   my $re_sfx  = $args -> {"re_sfx"};    # Regex der auszuschließenden Suffixe
   my $dir = catdir ($args -> {"webdir"}, $subdir);  # Verzeichnis-Pfad
   my $dh;                                           # Verzeichnis-Handle
   my $de;                                           # Verzeichnis-Eintrag
   my $dep;                                          # Pfad zum Verzeichnis-Eintrag
   my $dt;                                           # Vergleichseintrag mit Suffix .de
   opendir ($dh, $dir) or die "Kann Verzeichnis \"$dir\" nicht öffnen: $!\n";
   while ($de = readdir ($dh)) {
      next if $de eq "." or $de eq "..";
      $dep = catfile ($dir, $de);
      print STDERR "Path $dep\n" if $verbose > 2;
      if (-f $dep) {
         next if $dep =~ $re_sfx;
         next if $dep =~ $re_file;
         $dt = $de;
         $dt =~ s/\.[^.\\]+(\.*)$/.de${1}/;
         # weiter, wenn es eine deutschsprachige Version gibt
         next if $de ne $dt && -f catfile ($dir, $dt);
         addFile ($urllist, $args, catfile ($subdir, $de));
      }
      elsif (-d $dep) {
         next if $dep =~ $re_dir;
         buildUrllist ($urllist, $args, catdir ($subdir, $de));
      }
   }
   closedir ($dh);
} # buildUrllist

# Fügt eine Datei zur Liste hinze
sub addFile {
   my ($urllist, $args, $subpath) = @_;
   print STDERR "Datei \"$subpath\"\n" if $verbose;
   my $re_weekly = $args -> {"re_chgweekly"};
   my $re_rmsfx  = $args -> {"re_rmsfx"};
   my ($k, $v);      # Schlüssel/Wert - Paar
   my $entry = {};
   push @$urllist, $entry;
   $entry -> {"changefreq"} = ($subpath =~ $re_weekly ? "weekly" : "yearly");
   $subpath =~ s/^\///;
   my $fp = catfile ($args -> {"webdir"}, $subpath);
   $entry -> {"lastmod"} = strftime ("%Y-%m-%d", localtime ((stat $fp) [9]));
   my $hash;
   if ( $subpath =~ /\.([a-z]+)\b/ ) {
      $k = $1;
      $v = "";
      if ($v = $sfxes -> {$k} or -x $fp) {
         $hash = {};
         $entry -> {"c:codesearch"} = $hash ;
         $hash  -> {"c:filetype"}   = ($v || "shell") ;
      }
   }
   $subpath =~ s/$re_rmsfx//g ;
   $entry -> {"loc"} = $args -> {"rooturl"} . $subpath;
} # addFile

# gibt die Sitemap aus
sub writeSitemap {
   my ($urllist, $args, $outfile) = @_ ;
   my $hout;                          # Handle der Ausgabedate (Sitemap)
   my $le;                            # Listeneintrag
   my ($k, $v);                       # Schlüssel/Wert-Paar
   my ($k1, $v1);                     # Schlüssel/Wert-Paar
   my $prio = $args -> {"priority"};  # Default-Priorität

   print STDERR "Ausgabedatei \"$outfile\"\n" if $verbose;
   open ($hout, ">:encoding(utf-8)", $outfile)
      or die "Kann Ausgabedatei \"$outfile\" nicht öffnen: $!\n";
   print $hout "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
   $le = $args -> {"xslt"};
   print $hout "<?xml-stylesheet href = \"$le\" type = \"application/xml\"?>\n"
      if $le && $le ne "none";
   print $hout <<'HEAD' ;
<urlset
  xmlns   = "http://www.sitemaps.org/schemas/sitemap/0.9"
  xmlns:c = "http://www.google.com/codesearch/schemas/sitemap/1.0"
>
HEAD
   for $le (@$urllist) {
      print $hout "<url>\n";
      while ( ($k, $v) = each %$le ) {
         if (ref ($v) eq "HASH") {
            print $hout "<$k>\n";
            while ( ($k1, $v1) = each %$v ) { print $hout "  <$k1>$v1</$k1>\n"; }
            print $hout "</$k>\n";
         }
         else {
            print $hout "<$k>$v</$k>\n";
         }
      }
      if (
         $le -> {"loc"} !~ /(?:index\.xhtml|story\.xml)\b/
         && ! exists $le -> {"priority"}
      ) {
         print $hout "<priority>$prio</priority>\n";
      }
      print $hout "</url>\n";
   };
   print $hout "</urlset>\n";
   close ($hout);
} # writeSitemap
# end of file KLEIDER/web/src/addstory/mksitemap.pl