scripts/sphinx-pre-install

   1 #!/usr/bin/perl
   2 # SPDX-License-Identifier: GPL-2.0-or-later
   3 use strict;
   4
   5 # Copyright (c) 2017-2019 Mauro Carvalho Chehab <mchehab@kernel.org>
   6 #
   7
   8 my $prefix = "./";
   9 $prefix = "$ENV{'srctree'}/" if ($ENV{'srctree'});
  10
  11 my $conf = $prefix . "Documentation/conf.py";
  12 my $requirement_file = $prefix . "Documentation/sphinx/requirements.txt";
  13 my $virtenv_prefix = "sphinx_";
  14
  15 #
  16 # Static vars
  17 #
  18
  19 my %missing;
  20 my $system_release;
  21 my $need = 0;
  22 my $optional = 0;
  23 my $need_symlink = 0;
  24 my $need_sphinx = 0;
  25 my $rec_sphinx_upgrade = 0;
  26 my $install = "";
  27 my $virtenv_dir = "";
  28 my $min_version;
  29
  30 #
  31 # Command line arguments
  32 #
  33
  34 my $pdf = 1;
  35 my $virtualenv = 1;
  36 my $version_check = 0;
  37
  38 #
  39 # List of required texlive packages on Fedora and OpenSuse
  40 #
  41
  42 my %texlive = (
  43         'amsfonts.sty'       => 'texlive-amsfonts',
  44         'amsmath.sty'        => 'texlive-amsmath',
  45         'amssymb.sty'        => 'texlive-amsfonts',
  46         'amsthm.sty'         => 'texlive-amscls',
  47         'anyfontsize.sty'    => 'texlive-anyfontsize',
  48         'atbegshi.sty'       => 'texlive-oberdiek',
  49         'bm.sty'             => 'texlive-tools',
  50         'capt-of.sty'        => 'texlive-capt-of',
  51         'cmap.sty'           => 'texlive-cmap',
  52         'ecrm1000.tfm'       => 'texlive-ec',
  53         'eqparbox.sty'       => 'texlive-eqparbox',
  54         'eu1enc.def'         => 'texlive-euenc',
  55         'fancybox.sty'       => 'texlive-fancybox',
  56         'fancyvrb.sty'       => 'texlive-fancyvrb',
  57         'float.sty'          => 'texlive-float',
  58         'fncychap.sty'       => 'texlive-fncychap',
  59         'footnote.sty'       => 'texlive-mdwtools',
  60         'framed.sty'         => 'texlive-framed',
  61         'luatex85.sty'       => 'texlive-luatex85',
  62         'multirow.sty'       => 'texlive-multirow',
  63         'needspace.sty'      => 'texlive-needspace',
  64         'palatino.sty'       => 'texlive-psnfss',
  65         'parskip.sty'        => 'texlive-parskip',
  66         'polyglossia.sty'    => 'texlive-polyglossia',
  67         'tabulary.sty'       => 'texlive-tabulary',
  68         'threeparttable.sty' => 'texlive-threeparttable',
  69         'titlesec.sty'       => 'texlive-titlesec',
  70         'ucs.sty'            => 'texlive-ucs',
  71         'upquote.sty'        => 'texlive-upquote',
  72         'wrapfig.sty'        => 'texlive-wrapfig',
  73 );
  74
  75 #
  76 # Subroutines that checks if a feature exists
  77 #
  78
  79 sub check_missing(%)
  80 {
  81         my %map = %{$_[0]};
  82
  83         foreach my $prog (sort keys %missing) {
  84                 my $is_optional = $missing{$prog};
  85
  86                 # At least on some LTS distros like CentOS 7, texlive doesn't
  87                 # provide all packages we need. When such distros are
  88                 # detected, we have to disable PDF output.
  89                 #
  90                 # So, we need to ignore the packages that distros would
  91                 # need for LaTeX to work
  92                 if ($is_optional == 2 && !$pdf) {
  93                         $optional--;
  94                         next;
  95                 }
  96
  97                 if ($is_optional) {
  98                         print "Warning: better to also install \"$prog\".\n";
  99                 } else {
 100                         print "ERROR: please install \"$prog\", otherwise, build won't work.\n";
 101                 }
 102                 if (defined($map{$prog})) {
 103                         $install .= " " . $map{$prog};
 104                 } else {
 105                         $install .= " " . $prog;
 106                 }
 107         }
 108
 109         $install =~ s/^\s//;
 110 }
 111
 112 sub add_package($$)
 113 {
 114         my $package = shift;
 115         my $is_optional = shift;
 116
 117         $missing{$package} = $is_optional;
 118         if ($is_optional) {
 119                 $optional++;
 120         } else {
 121                 $need++;
 122         }
 123 }
 124
 125 sub check_missing_file($$$)
 126 {
 127         my $file = shift;
 128         my $package = shift;
 129         my $is_optional = shift;
 130
 131         return if(-e $file);
 132
 133         add_package($package, $is_optional);
 134 }
 135
 136 sub findprog($)
 137 {
 138         foreach(split(/:/, $ENV{PATH})) {
 139                 return "$_/$_[0]" if(-x "$_/$_[0]");
 140         }
 141 }
 142
 143 sub check_program($$)
 144 {
 145         my $prog = shift;
 146         my $is_optional = shift;
 147
 148         return if findprog($prog);
 149
 150         add_package($prog, $is_optional);
 151 }
 152
 153 sub check_perl_module($$)
 154 {
 155         my $prog = shift;
 156         my $is_optional = shift;
 157
 158         my $err = system("perl -M$prog -e 1 2>/dev/null /dev/null");
 159         return if ($err == 0);
 160
 161         add_package($prog, $is_optional);
 162 }
 163
 164 sub check_python_module($$)
 165 {
 166         my $prog = shift;
 167         my $is_optional = shift;
 168
 169         my $err = system("python3 -c 'import $prog' 2>/dev/null /dev/null");
 170         return if ($err == 0);
 171         my $err = system("python -c 'import $prog' 2>/dev/null /dev/null");
 172         return if ($err == 0);
 173
 174         add_package($prog, $is_optional);
 175 }
 176
 177 sub check_rpm_missing($$)
 178 {
 179         my @pkgs = @{$_[0]};
 180         my $is_optional = $_[1];
 181
 182         foreach my $prog(@pkgs) {
 183                 my $err = system("rpm -q '$prog' 2>/dev/null >/dev/null");
 184                 add_package($prog, $is_optional) if ($err);
 185         }
 186 }
 187
 188 sub check_pacman_missing($$)
 189 {
 190         my @pkgs = @{$_[0]};
 191         my $is_optional = $_[1];
 192
 193         foreach my $prog(@pkgs) {
 194                 my $err = system("pacman -Q '$prog' 2>/dev/null >/dev/null");
 195                 add_package($prog, $is_optional) if ($err);
 196         }
 197 }
 198
 199 sub check_missing_tex($)
 200 {
 201         my $is_optional = shift;
 202         my $kpsewhich = findprog("kpsewhich");
 203
 204         foreach my $prog(keys %texlive) {
 205                 my $package = $texlive{$prog};
 206                 if (!$kpsewhich) {
 207                         add_package($package, $is_optional);
 208                         next;
 209                 }
 210                 my $file = qx($kpsewhich $prog);
 211                 add_package($package, $is_optional) if ($file =~ /^\s*$/);
 212         }
 213 }
 214
 215 sub get_sphinx_fname()
 216 {
 217         my $fname = "sphinx-build";
 218         return $fname if findprog($fname);
 219
 220         $fname = "sphinx-build-3";
 221         if (findprog($fname)) {
 222                 $need_symlink = 1;
 223                 return $fname;
 224         }
 225
 226         if ($virtualenv) {
 227                 my $prog = findprog("virtualenv-3");
 228                 $prog = findprog("virtualenv-3.5") if (!$prog);
 229
 230                 check_program("virtualenv", 0) if (!$prog);
 231                 $need_sphinx = 1;
 232         } else {
 233                 add_package("python-sphinx", 0);
 234         }
 235
 236         return "";
 237 }
 238
 239 sub check_sphinx()
 240 {
 241         my $rec_version;
 242         my $cur_version;
 243
 244         open IN, $conf or die "Can't open $conf";
 245         while (<IN>) {
 246                 if (m/^\s*needs_sphinx\s*=\s*[\'\"]([\d\.]+)[\'\"]/) {
 247                         $min_version=$1;
 248                         last;
 249                 }
 250         }
 251         close IN;
 252
 253         die "Can't get needs_sphinx version from $conf" if (!$min_version);
 254
 255         open IN, $requirement_file or die "Can't open $requirement_file";
 256         while (<IN>) {
 257                 if (m/^\s*Sphinx\s*==\s*([\d\.]+)$/) {
 258                         $rec_version=$1;
 259                         last;
 260                 }
 261         }
 262         close IN;
 263
 264         die "Can't get recommended sphinx version from $requirement_file" if (!$min_version);
 265
 266         $virtenv_dir = $virtenv_prefix . $rec_version;
 267
 268         my $sphinx = get_sphinx_fname();
 269         return if ($sphinx eq "");
 270
 271         open IN, "$sphinx --version 2>&1 |" or die "$sphinx returned an error";
 272         while (<IN>) {
 273                 if (m/^\s*sphinx-build\s+([\d\.]+)$/) {
 274                         $cur_version=$1;
 275                         last;
 276                 }
 277                 # Sphinx 1.2.x uses a different format
 278                 if (m/^\s*Sphinx.*\s+([\d\.]+)$/) {
 279                         $cur_version=$1;
 280                         last;
 281                 }
 282         }
 283         close IN;
 284
 285         die "$sphinx didn't return its version" if (!$cur_version);
 286
 287         if ($cur_version lt $min_version) {
 288                 printf "ERROR: Sphinx version is %s. It should be >= %s (recommended >= %s)\n",
 289                        $cur_version, $min_version, $rec_version;;
 290                 $need_sphinx = 1;
 291                 return;
 292         }
 293
 294         if ($cur_version lt $rec_version) {
 295                 printf "Sphinx version %s\n", $cur_version;
 296                 print "Warning: It is recommended at least Sphinx version $rec_version.\n";
 297                 $rec_sphinx_upgrade = 1;
 298                 return;
 299         }
 300
 301         # On version check mode, just assume Sphinx has all mandatory deps
 302         exit (0) if ($version_check);
 303 }
 304
 305 #
 306 # Ancillary subroutines
 307 #
 308
 309 sub catcheck($)
 310 {
 311   my $res = "";
 312   $res = qx(cat $_[0]) if (-r $_[0]);
 313   return $res;
 314 }
 315
 316 sub which($)
 317 {
 318         my $file = shift;
 319         my @path = split ":", $ENV{PATH};
 320
 321         foreach my $dir(@path) {
 322                 my $name = $dir.'/'.$file;
 323                 return $name if (-x $name );
 324         }
 325         return undef;
 326 }
 327
 328 #
 329 # Subroutines that check distro-specific hints
 330 #
 331
 332 sub give_debian_hints()
 333 {
 334         my %map = (
 335                 "python-sphinx"         => "python3-sphinx",
 336                 "sphinx_rtd_theme"      => "python3-sphinx-rtd-theme",
 337                 "virtualenv"            => "virtualenv",
 338                 "dot"                   => "graphviz",
 339                 "convert"               => "imagemagick",
 340                 "Pod::Usage"            => "perl-modules",
 341                 "xelatex"               => "texlive-xetex",
 342                 "rsvg-convert"          => "librsvg2-bin",
 343         );
 344
 345         if ($pdf) {
 346                 check_missing_file("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
 347                                    "fonts-dejavu", 2);
 348
 349                 check_missing_file("/usr/share/fonts/noto-cjk/NotoSansCJK-Regular.ttc",
 350                                    "fonts-noto-cjk", 2);
 351         }
 352
 353         check_program("dvipng", 2) if ($pdf);
 354         check_missing(\%map);
 355
 356         return if (!$need && !$optional);
 357         printf("You should run:\n\n\tsudo apt-get install $install\n");
 358 }
 359
 360 sub give_redhat_hints()
 361 {
 362         my %map = (
 363                 "python-sphinx"         => "python3-sphinx",
 364                 "sphinx_rtd_theme"      => "python3-sphinx_rtd_theme",
 365                 "virtualenv"            => "python3-virtualenv",
 366                 "dot"                   => "graphviz",
 367                 "convert"               => "ImageMagick",
 368                 "Pod::Usage"            => "perl-Pod-Usage",
 369                 "xelatex"               => "texlive-xetex-bin",
 370                 "rsvg-convert"          => "librsvg2-tools",
 371         );
 372
 373         my @fedora26_opt_pkgs = (
 374                 "graphviz-gd",          # Fedora 26: needed for PDF support
 375         );
 376
 377         my @fedora_tex_pkgs = (
 378                 "texlive-collection-fontsrecommended",
 379                 "texlive-collection-latex",
 380                 "texlive-xecjk",
 381                 "dejavu-sans-fonts",
 382                 "dejavu-serif-fonts",
 383                 "dejavu-sans-mono-fonts",
 384         );
 385
 386         #
 387         # Checks valid for RHEL/CentOS version 7.x.
 388         #
 389         my $old = 0;
 390         my $rel;
 391         $rel = $1 if ($system_release =~ /release\s+(\d+)/);
 392
 393         if (!($system_release =~ /Fedora/)) {
 394                 $map{"virtualenv"} = "python-virtualenv";
 395
 396                 if ($rel && $rel < 8) {
 397                         $old = 1;
 398                         $pdf = 0;
 399
 400                         printf("Note: texlive packages on RHEL/CENTOS <= 7 are incomplete. Can't support PDF output\n");
 401                         printf("If you want to build PDF, please read:\n");
 402                         printf("\thttps://www.systutorials.com/241660/how-to-install-tex-live-on-centos-7-linux/\n");
 403                 }
 404         } else {
 405                 if ($rel && $rel < 26) {
 406                         $old = 1;
 407                 }
 408         }
 409         if (!$rel) {
 410                 printf("Couldn't identify release number\n");
 411                 $old = 1;
 412                 $pdf = 0;
 413         }
 414
 415         if ($pdf) {
 416                 check_missing_file("/usr/share/fonts/google-noto-cjk/NotoSansCJK-Regular.ttc",
 417                                    "google-noto-sans-cjk-ttc-fonts", 2);
 418         }
 419
 420         check_rpm_missing(\@fedora26_opt_pkgs, 2) if ($pdf && !$old);
 421         check_rpm_missing(\@fedora_tex_pkgs, 2) if ($pdf);
 422         check_missing_tex(2) if ($pdf);
 423         check_missing(\%map);
 424
 425         return if (!$need && !$optional);
 426
 427         if (!$old) {
 428                 # dnf, for Fedora 18+
 429                 printf("You should run:\n\n\tsudo dnf install -y $install\n");
 430         } else {
 431                 # yum, for RHEL (and clones) or Fedora version < 18
 432                 printf("You should run:\n\n\tsudo yum install -y $install\n");
 433         }
 434 }
 435
 436 sub give_opensuse_hints()
 437 {
 438         my %map = (
 439                 "python-sphinx"         => "python3-sphinx",
 440                 "sphinx_rtd_theme"      => "python3-sphinx_rtd_theme",
 441                 "virtualenv"            => "python3-virtualenv",
 442                 "dot"                   => "graphviz",
 443                 "convert"               => "ImageMagick",
 444                 "Pod::Usage"            => "perl-Pod-Usage",
 445                 "xelatex"               => "texlive-xetex-bin",
 446                 "rsvg-convert"          => "rsvg-view",
 447         );
 448
 449         my @suse_tex_pkgs = (
 450                 "texlive-babel-english",
 451                 "texlive-caption",
 452                 "texlive-colortbl",
 453                 "texlive-courier",
 454                 "texlive-dvips",
 455                 "texlive-helvetic",
 456                 "texlive-makeindex",
 457                 "texlive-metafont",
 458                 "texlive-metapost",
 459                 "texlive-palatino",
 460                 "texlive-preview",
 461                 "texlive-times",
 462                 "texlive-zapfchan",
 463                 "texlive-zapfding",
 464         );
 465
 466         $map{"latexmk"} = "texlive-latexmk-bin";
 467
 468         # FIXME: add support for installing CJK fonts
 469         #
 470         # I tried hard, but was unable to find a way to install
 471         # "Noto Sans CJK SC" on openSUSE
 472
 473         check_rpm_missing(\@suse_tex_pkgs, 2) if ($pdf);
 474         check_missing_tex(2) if ($pdf);
 475         check_missing(\%map);
 476
 477         return if (!$need && !$optional);
 478         printf("You should run:\n\n\tsudo zypper install --no-recommends $install\n");
 479 }
 480
 481 sub give_mageia_hints()
 482 {
 483         my %map = (
 484                 "python-sphinx"         => "python3-sphinx",
 485                 "sphinx_rtd_theme"      => "python3-sphinx_rtd_theme",
 486                 "virtualenv"            => "python3-virtualenv",
 487                 "dot"                   => "graphviz",
 488                 "convert"               => "ImageMagick",
 489                 "Pod::Usage"            => "perl-Pod-Usage",
 490                 "xelatex"               => "texlive",
 491                 "rsvg-convert"          => "librsvg2-tools",
 492         );
 493
 494         my @tex_pkgs = (
 495                 "texlive-fontsextra",
 496         );
 497
 498         $map{"latexmk"} = "texlive-collection-basic";
 499
 500         if ($pdf) {
 501                 check_missing_file("/usr/share/fonts/google-noto-cjk/NotoSansCJK-Regular.ttc",
 502                                    "google-noto-sans-cjk-ttc-fonts", 2);
 503         }
 504
 505         check_rpm_missing(\@tex_pkgs, 2) if ($pdf);
 506         check_missing(\%map);
 507
 508         return if (!$need && !$optional);
 509         printf("You should run:\n\n\tsudo urpmi $install\n");
 510 }
 511
 512 sub give_arch_linux_hints()
 513 {
 514         my %map = (
 515                 "sphinx_rtd_theme"      => "python-sphinx_rtd_theme",
 516                 "virtualenv"            => "python-virtualenv",
 517                 "dot"                   => "graphviz",
 518                 "convert"               => "imagemagick",
 519                 "xelatex"               => "texlive-bin",
 520                 "rsvg-convert"          => "extra/librsvg",
 521         );
 522
 523         my @archlinux_tex_pkgs = (
 524                 "texlive-core",
 525                 "texlive-latexextra",
 526                 "ttf-dejavu",
 527         );
 528         check_pacman_missing(\@archlinux_tex_pkgs, 2) if ($pdf);
 529
 530         if ($pdf) {
 531                 check_missing_file("/usr/share/fonts/noto-cjk/NotoSansCJK-Regular.ttc",
 532                                    "noto-fonts-cjk", 2);
 533         }
 534
 535         check_missing(\%map);
 536
 537         return if (!$need && !$optional);
 538         printf("You should run:\n\n\tsudo pacman -S $install\n");
 539 }
 540
 541 sub give_gentoo_hints()
 542 {
 543         my %map = (
 544                 "sphinx_rtd_theme"      => "dev-python/sphinx_rtd_theme",
 545                 "virtualenv"            => "dev-python/virtualenv",
 546                 "dot"                   => "media-gfx/graphviz",
 547                 "convert"               => "media-gfx/imagemagick",
 548                 "xelatex"               => "dev-texlive/texlive-xetex media-fonts/dejavu",
 549                 "rsvg-convert"          => "gnome-base/librsvg",
 550         );
 551
 552         check_missing_file("/usr/share/fonts/dejavu/DejaVuSans.ttf",
 553                            "media-fonts/dejavu", 2) if ($pdf);
 554
 555         if ($pdf) {
 556                 check_missing_file("/usr/share/fonts/noto-cjk/NotoSansCJKsc-Regular.otf",
 557                                    "media-fonts/noto-cjk", 2);
 558         }
 559
 560         check_missing(\%map);
 561
 562         return if (!$need && !$optional);
 563
 564         printf("You should run:\n\n");
 565
 566         my $imagemagick = "media-gfx/imagemagick svg png";
 567         my $cairo = "media-gfx/graphviz cairo pdf";
 568         my $portage_imagemagick = "/etc/portage/package.use/imagemagick";
 569         my $portage_cairo = "/etc/portage/package.use/graphviz";
 570
 571         if (qx(cat $portage_imagemagick) ne "$imagemagick\n") {
 572                 printf("\tsudo su -c 'echo \"$imagemagick\" > $portage_imagemagick'\n")
 573         }
 574         if (qx(cat $portage_cairo) ne  "$cairo\n") {
 575                 printf("\tsudo su -c 'echo \"$cairo\" > $portage_cairo'\n");
 576         }
 577
 578         printf("\tsudo emerge --ask $install\n");
 579
 580 }
 581
 582 sub check_distros()
 583 {
 584         # Distro-specific hints
 585         if ($system_release =~ /Red Hat Enterprise Linux/) {
 586                 give_redhat_hints;
 587                 return;
 588         }
 589         if ($system_release =~ /CentOS/) {
 590                 give_redhat_hints;
 591                 return;
 592         }
 593         if ($system_release =~ /Scientific Linux/) {
 594                 give_redhat_hints;
 595                 return;
 596         }
 597         if ($system_release =~ /Oracle Linux Server/) {
 598                 give_redhat_hints;
 599                 return;
 600         }
 601         if ($system_release =~ /Fedora/) {
 602                 give_redhat_hints;
 603                 return;
 604         }
 605         if ($system_release =~ /Ubuntu/) {
 606                 give_debian_hints;
 607                 return;
 608         }
 609         if ($system_release =~ /Debian/) {
 610                 give_debian_hints;
 611                 return;
 612         }
 613         if ($system_release =~ /openSUSE/) {
 614                 give_opensuse_hints;
 615                 return;
 616         }
 617         if ($system_release =~ /Mageia/) {
 618                 give_mageia_hints;
 619                 return;
 620         }
 621         if ($system_release =~ /Arch Linux/) {
 622                 give_arch_linux_hints;
 623                 return;
 624         }
 625         if ($system_release =~ /Gentoo/) {
 626                 give_gentoo_hints;
 627                 return;
 628         }
 629
 630         #
 631         # Fall-back to generic hint code for other distros
 632         # That's far from ideal, specially for LaTeX dependencies.
 633         #
 634         my %map = (
 635                 "sphinx-build" => "sphinx"
 636         );
 637         check_missing_tex(2) if ($pdf);
 638         check_missing(\%map);
 639         print "I don't know distro $system_release.\n";
 640         print "So, I can't provide you a hint with the install procedure.\n";
 641         print "There are likely missing dependencies.\n";
 642 }
 643
 644 #
 645 # Common dependencies
 646 #
 647
 648 sub check_needs()
 649 {
 650         # Check for needed programs/tools
 651         check_sphinx();
 652
 653         if ($system_release) {
 654                 print "Detected OS: $system_release.\n\n";
 655         } else {
 656                 print "Unknown OS\n\n";
 657         }
 658
 659         print "To upgrade Sphinx, use:\n\n" if ($rec_sphinx_upgrade);
 660
 661         # Check for needed programs/tools
 662         check_perl_module("Pod::Usage", 0);
 663         check_program("make", 0);
 664         check_program("gcc", 0);
 665         check_python_module("sphinx_rtd_theme", 1) if (!$virtualenv);
 666         check_program("dot", 1);
 667         check_program("convert", 1);
 668
 669         # Extra PDF files - should use 2 for is_optional
 670         check_program("xelatex", 2) if ($pdf);
 671         check_program("rsvg-convert", 2) if ($pdf);
 672         check_program("latexmk", 2) if ($pdf);
 673
 674         check_distros();
 675
 676         if ($need_symlink) {
 677                 printf "\tsudo ln -sf %s /usr/bin/sphinx-build\n\n",
 678                        which("sphinx-build-3");
 679         }
 680         if ($need_sphinx || $rec_sphinx_upgrade) {
 681                 my $min_activate = "$ENV{'PWD'}/${virtenv_prefix}${min_version}/bin/activate";
 682                 my @activates = glob "$ENV{'PWD'}/${virtenv_prefix}*/bin/activate";
 683
 684                 @activates = sort {$b cmp $a} @activates;
 685
 686                 if ($need_sphinx && scalar @activates > 0 && $activates[0] ge $min_activate) {
 687                         printf "\nNeed to activate a compatible Sphinx version on virtualenv with:\n";
 688                         printf "\t. $activates[0]\n";
 689                         exit (1);
 690                 } else {
 691                         my $rec_activate = "$virtenv_dir/bin/activate";
 692                         my $virtualenv = findprog("virtualenv-3");
 693                         $virtualenv = findprog("virtualenv-3.5") if (!$virtualenv);
 694                         $virtualenv = findprog("virtualenv") if (!$virtualenv);
 695                         $virtualenv = "virtualenv" if (!$virtualenv);
 696
 697                         printf "\t$virtualenv $virtenv_dir\n";
 698                         printf "\t. $rec_activate\n";
 699                         printf "\tpip install -r $requirement_file\n";
 700
 701                         $need++ if (!$rec_sphinx_upgrade);
 702                 }
 703         }
 704         printf "\n";
 705
 706         print "All optional dependencies are met.\n" if (!$optional);
 707
 708         if ($need == 1) {
 709                 die "Can't build as $need mandatory dependency is missing";
 710         } elsif ($need) {
 711                 die "Can't build as $need mandatory dependencies are missing";
 712         }
 713
 714         print "Needed package dependencies are met.\n";
 715 }
 716
 717 #
 718 # Main
 719 #
 720
 721 while (@ARGV) {
 722         my $arg = shift(@ARGV);
 723
 724         if ($arg eq "--no-virtualenv") {
 725                 $virtualenv = 0;
 726         } elsif ($arg eq "--no-pdf"){
 727                 $pdf = 0;
 728         } elsif ($arg eq "--version-check"){
 729                 $version_check = 1;
 730         } else {
 731                 print "Usage:\n\t$0 <--no-virtualenv> <--no-pdf> <--version-check>\n\n";
 732                 print "Where:\n";
 733                 print "\t--no-virtualenv\t- Recommend installing Sphinx instead of using a virtualenv\n";
 734                 print "\t--version-check\t- if version is compatible, don't check for missing dependencies\n";
 735                 print "\t--no-pdf\t- don't check for dependencies required to build PDF docs\n\n";
 736                 exit -1;
 737         }
 738 }
 739
 740 #
 741 # Determine the system type. There's no standard unique way that would
 742 # work with all distros with a minimal package install. So, several
 743 # methods are used here.
 744 #
 745 # By default, it will use lsb_release function. If not available, it will
 746 # fail back to reading the known different places where the distro name
 747 # is stored
 748 #
 749
 750 $system_release = qx(lsb_release -d) if which("lsb_release");
 751 $system_release =~ s/Description:\s*// if ($system_release);
 752 $system_release = catcheck("/etc/system-release") if !$system_release;
 753 $system_release = catcheck("/etc/redhat-release") if !$system_release;
 754 $system_release = catcheck("/etc/lsb-release") if !$system_release;
 755 $system_release = catcheck("/etc/gentoo-release") if !$system_release;
 756 $system_release = catcheck("/etc/issue") if !$system_release;
 757 $system_release =~ s/\s+$//;
 758
 759 check_needs;