Update url's in docs to fix make -C doc linkcheck

doc/conf.py

@@ -96,6 +96,9 @@
 primary_domain = 'jl'
 highlight_language = 'julia'
 
+# Flaky links to ignore in linkcheck - permissions or empty returns
+linkcheck_ignore = ['https://www.appveyor.com',
+    'https://bugs.kde.org/show_bug.cgi\?id=136779']
 
 # -- Options for HTML output ---------------------------------------------------
 

doc/devdocs/backtraces.rst

@@ -104,4 +104,4 @@ A few terms have been used as shorthand in this guide:
 * ``<julia_root>`` refers to the root directory of the Julia source tree; e.g. it should contain folders such as ``base``, ``deps``, ``src``, ``test``, etc.....
 
 .. _gist: https://gist.github.com
-.. _issue: https://github.com/JuliaLang/julia/issues?state=open
+.. _issue: https://github.com/JuliaLang/julia/issues?q=is%3Aopen

doc/manual/calling-c-and-fortran-code.rst

@@ -41,7 +41,7 @@ functions in the Julia runtime, or functions in an application linked to
 Julia.
 
 By default, Fortran compilers `generate mangled names
-<https://en.wikipedia.org/wiki/Name_mangling#Name_mangling_in_Fortran>`_
+<https://en.wikipedia.org/wiki/Name_mangling#Fortran>`_
 (for example, converting function names to lowercase or uppercase,
 often appending an underscore), and so to call a Fortran function via
 :func:`ccall` you must pass the mangled identifier corresponding to the rule
@@ -1094,7 +1094,7 @@ More About Callbacks
 --------------------
 
 For more details on how to pass callbacks to C libraries, see this
-`blog post <http://julialang.org/blog/2013/05/callback/>`_.
+`blog post <http://julialang.org/blog/2013/05/callback>`_.
 
 C++
 ---

doc/manual/dates.rst

@@ -238,7 +238,7 @@ Similarly for the :func:`monthname` function, a mapping of ``locale=>Dict{Int,St
 TimeType-Period Arithmetic
 --------------------------
 
-It's good practice when using any language/date framework to be familiar with how date-period arithmetic is handled as there are some `tricky issues <http://codeblog.jonskeet.uk/2010/12/01/the-joys-of-date-time-arithmetic>`_ to deal with (though much less so for day-precision types).
+It's good practice when using any language/date framework to be familiar with how date-period arithmetic is handled as there are some `tricky issues <https://codeblog.jonskeet.uk/2010/12/01/the-joys-of-date-time-arithmetic/>`_ to deal with (though much less so for day-precision types).
 
 The :mod:`Dates` module approach tries to follow the simple principle of trying to change as little as possible when doing :class:`Period` arithmetic. This approach is also often known as *calendrical* arithmetic or what you would probably guess if someone were to ask you the same calculation in a conversation. Why all the fuss about this? Let's take a classic example: add 1 month to January 31st, 2014. What's the answer? Javascript will say `March 3 <http://www.markhneedham.com/blog/2009/01/07/javascript-add-a-month-to-a-date/>`_ (assumes 31 days). PHP says `March 2 <http://stackoverflow.com/questions/5760262/php-adding-months-to-a-date-while-not-exceeding-the-last-day-of-the-month>`_ (assumes 30 days). The fact is, there is no right answer. In the :mod:`Dates` module, it gives the result of February 28th. How does it figure that out? I like to think of the classic 7-7-7 gambling game in casinos.
 

doc/manual/getting-started.rst

@@ -162,7 +162,7 @@ In addition to this manual, there are various other resources that may
 help new users get started with Julia:
 
 - `Julia and IJulia cheatsheet <http://math.mit.edu/~stevenj/Julia-cheatsheet.pdf>`_
-- `Learn Julia in a few minutes <http://learnxinyminutes.com/docs/julia/>`_
+- `Learn Julia in a few minutes <https://learnxinyminutes.com/docs/julia/>`_
 - `Learn Julia the Hard Way <https://github.com/chrisvoncsefalvay/learn-julia-the-hard-way>`_
 - `Julia by Example <http://samuelcolvin.github.io/JuliaByExample/>`_
 - `Hands-on Julia <https://github.com/dpsanders/hands_on_julia>`_

doc/manual/integers-and-floating-point-numbers.rst

@@ -554,11 +554,11 @@ computation, and also in the following references:
 - For even more extensive documentation of the history of, rationale for,
   and issues with floating-point numbers, as well as discussion of many other
   topics in numerical computing, see the `collected writings
-  <http://www.cs.berkeley.edu/~wkahan/>`_ of `William Kahan
+  <https://people.eecs.berkeley.edu/~wkahan/>`_ of `William Kahan
   <https://en.wikipedia.org/wiki/William_Kahan>`_, commonly known as the "Father
   of Floating-Point". Of particular interest may be `An Interview with the Old
   Man of Floating-Point
-  <http://www.cs.berkeley.edu/~wkahan/ieee754status/754story.html>`_.
+  <https://people.eecs.berkeley.edu/~wkahan/ieee754status/754story.html>`_.
 
 .. _man-arbitrary-precision-arithmetic:
 

doc/manual/packages.rst

@@ -196,7 +196,7 @@ To get the latest and greatest versions of all your packages, just do :func:`Pkg
 
 The first step of updating packages is to pull new changes to ``~/.julia/v0.4/METADATA`` and see if any new registered package versions have been published.
 After this, :func:`Pkg.update` attempts to update packages that are checked out on a branch and not dirty (i.e. no changes have been made to files tracked by git) by pulling changes from the package's upstream repository.
-Upstream changes will only be applied if no merging or rebasing is necessary – i.e. if the branch can be `"fast-forwarded" <http://git-scm.com/book/en/Git-Branching-Basic-Branching-and-Merging>`_.
+Upstream changes will only be applied if no merging or rebasing is necessary – i.e. if the branch can be `"fast-forwarded" <https://git-scm.com/book/en/v2/Git-Branching-Basic-Branching-and-Merging>`_.
 If the branch cannot be fast-forwarded, it is assumed that you're working on it and will update the repository yourself.
 
 Finally, the update process recomputes an optimal set of package versions to have installed to satisfy your top-level requirements and the requirements of "fixed" packages.
@@ -360,7 +360,7 @@ We recommend that you create a `free account <https://github.com/join>`_ on GitH
 
 where ``USERNAME`` is your actual GitHub user name.
 Once you do this, the package manager knows your GitHub user name and can configure things accordingly.
-You should also `upload <https://github.com/settings/ssh>`_ your public SSH key to GitHub and set up an `SSH agent <http://linux.die.net/man/1/ssh-agent>`_ on your development machine so that you can push changes with minimal hassle.
+You should also `upload <https://github.com/login?return_to=https%3A%2F%2Fgithub.com%2Fsettings%2Fssh>`_ your public SSH key to GitHub and set up an `SSH agent <http://linux.die.net/man/1/ssh-agent>`_ on your development machine so that you can push changes with minimal hassle.
 In the future, we will make this system extensible and support other common git hosting options like `BitBucket <https://bitbucket.org>`_ and allow developers to choose their favorite.
 Since the package development functions has been moved to the `PkgDev <https://github.com/JuliaLang/PkgDev.jl>`_ package, you need to run ``Pkg.add("PkgDev"); import PkgDev`` to access the functions starting with ``PkgDev.`` in the document below.
 
@@ -455,7 +455,7 @@ are several possible approaches, here is one that is widely used:
   ``fixbar``). By creating a branch, you ensure that you can easily go
   back and forth between your new work and the current ``master``
   branch (see
-  `<http://git-scm.com/book/en/v2/Git-Branching-Branches-in-a-Nutshell>`_).
+  `<https://git-scm.com/book/en/v2/Git-Branching-Branches-in-a-Nutshell>`_).
 
   If you forget to do this step until after you've already made some
   changes, don't worry: see :ref:`more detail about branching
@@ -486,7 +486,7 @@ are several possible approaches, here is one that is widely used:
     ``src/`` folder.
 
 
-- Commit your changes: see `<http://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository>`_.
+- Commit your changes: see `<https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository>`_.
 
 - Submit your changes: From the Julia prompt, type
   :func:`PkgDev.submit("Foo") <PkgDev.submit>`. This will push your changes to your
@@ -555,7 +555,7 @@ following procedure:
   until you have resolved the problems, or you may lose your changes.
 - *Reset* ``master`` (your current branch) back to an earlier state
   with ``git reset --hard origin/master`` (see
-  `<http://git-scm.com/blog/2011/07/11/reset.html>`_).
+  `<https://git-scm.com/blog/2011/07/11/reset.html>`_).
 
 This requires a bit more familiarity with git, so it's much better to
 get in the habit of creating a branch at the outset.
@@ -583,7 +583,7 @@ quite simple but your commit history looks like this::
 
 This gets into the territory of more advanced git usage, and you're
 encouraged to do some reading
-(`<http://git-scm.com/book/en/v2/Git-Branching-Rebasing>`_).  However,
+(`<https://git-scm.com/book/en/v2/Git-Branching-Rebasing>`_).  However,
 a brief summary of the procedure is as follows:
 
 - To protect yourself from error, start from your ``fixbar`` branch
@@ -767,7 +767,7 @@ different license, you can ask us to add it to the package generator, or just pi
 
 If you created a GitHub account and configured git to know about it, :func:`PkgDev.generate` will set an appropriate origin URL
 for you.  It will also automatically generate a ``.travis.yml`` file for using the `Travis <https://travis-ci.org>`_ automated
-testing service, and an ``appveyor.yml`` file for using `AppVeyor <http://appveyor.com>`_.  You will have to enable testing on
+testing service, and an ``appveyor.yml`` file for using `AppVeyor <https://www.appveyor.com>`_.  You will have to enable testing on
 the Travis and AppVeyor websites for your package repository, but once you've done that, it will already have working tests.
 Of course, all the default testing does is verify that ``using FooBar`` in Julia works.
 
@@ -840,7 +840,7 @@ on GitHub, push your changes to your fork, and open a pull request::
     then you may have encountered an issue from using the GitHub API on
     multiple systems. The solution is to delete the "Julia Package Manager"
     personal access token `from your Github account
-    <https://github.com/settings/tokens>`_ and try again.
+    <https://github.com/login?return_to=https%3A%2F%2Fgithub.com%2Fsettings%2Ftokens>`_ and try again.
 
     Other failures may require you to circumvent :func:`PkgDev.publish` by
     `creating a pull request on GitHub
@@ -915,7 +915,7 @@ that copy exists, you can push your local changes to your copy
 (just like any other GitHub project).
 
 
-1. go to `<https://github.com/JuliaLang/METADATA.jl/fork>`_ and create your own
+1. go to `<https://github.com/login?return_to=https%3A%2F%2Fgithub.com%2FJuliaLang%2FMETADATA.jl%2Ffork>`_ and create your own
 fork.
 
 2. add your fork as a remote repository for the METADATA

doc/manual/parallel-computing.rst

@@ -15,7 +15,7 @@ it's fairly obvious that a given CPU will have fastest access to the RAM
 within the same computer (node). Perhaps more surprisingly, similar
 issues are relevant on a typical multicore laptop, due to
 differences in the speed of main memory and the
-`cache <http://www.akkadia.org/drepper/cpumemory.pdf>`_. Consequently, a
+`cache <https://www.akkadia.org/drepper/cpumemory.pdf>`_. Consequently, a
 good multiprocessing environment should allow control over the
 "ownership" of a chunk of memory by a particular CPU. Julia provides a
 multiprocessing environment based on message passing to allow programs

doc/manual/performance-tips.rst

@@ -770,7 +770,7 @@ code.
 
 Some run-time benchmarks comparing (1) type dispatch, (2) dictionary
 lookup, and (3) a "switch" statement can be found `on the mailing list
-<https://groups.google.com/d/msg/julia-users/jUMu9A3QKQQ/qjgVWr7vAwAJ>`_.
+<https://groups.google.com/forum/#!msg/julia-users/jUMu9A3QKQQ/qjgVWr7vAwAJ>`_.
 
 Perhaps even worse than the run-time impact is the compile-time
 impact: Julia will compile specialized functions for each different

doc/stdlib/pkg.rst

@@ -7,7 +7,7 @@
 All package manager functions are defined in the ``Pkg`` module. None of the ``Pkg`` module's functions are exported;
 to use them, you'll need to prefix each function call with an explicit ``Pkg.``, e.g. ``Pkg.status()`` or ``Pkg.dir()``.
 
-Functions for package development (e.g. ``tag``, ``publish``, etc.) have been moved to the `PkgDev <https://github.com/JuliaLang/PkgDev.jl>`_ package. See `PkgDev README <https://github.com/JuliaLang/PkgDev.jl/blob/master/README.md#usage>`_ for the documentation of those functions.
+Functions for package development (e.g. ``tag``, ``publish``, etc.) have been moved to the `PkgDev <https://github.com/JuliaLang/PkgDev.jl>`_ package. See `PkgDev README <https://github.com/JuliaLang/PkgDev.jl/blob/master/README.md>`_ for the documentation of those functions.
 
 .. function:: dir() -> AbstractString