scripts/sphinx-pre-install

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