rename Hudson to Jenkins everywhere

13 files changed, 50 insertions, 46 deletions

diff --git a/CHANGELOG.txt b/CHANGELOG.txt
index 2115bdc..edc6562 100644
--- a/CHANGELOG.txt
+++ b/CHANGELOG.txt
@@ -4,6 +4,9 @@
 - require virtualenv-1.5.1 as to make pypy-1.4 work
 - fix issue14: report errors related to test command
 - fix issue20: document format of URLs for specifying dependencies
+- fix issue19: substitute Hudson for Jenkins everywhere following the renaming
+  of the project.  NOTE: if you used the special [tox:jenkins]
+  section it will now need to be named [tox:jenkins].
 
 0.9
 -----------------
diff --git a/doc/announce/release-0.5.txt b/doc/announce/release-0.5.txt
index e770566..8a1239e 100644
--- a/doc/announce/release-0.5.txt
+++ b/doc/announce/release-0.5.txt
@@ -12,7 +12,7 @@ from a simple ``tox.ini`` file, including:
 * testing packages against each other without needing to upload to PyPI
 
 ``tox`` runs well on Python2.4 up until Python3.1 and integrates
-well with Continous Integration servers Hudson. There are many
+well with Continous Integration servers Jenkins. There are many
 real-life examples and a good chunk of docs.  Read it up on
 
     http://codespeak.net/tox
diff --git a/doc/config.txt b/doc/config.txt
index 4fdbb7f..5187dc1 100644
--- a/doc/config.txt
+++ b/doc/config.txt
@@ -21,13 +21,13 @@ List of optional global options::
     envlist=ENVLIST   # defaults to the list of all environments
 
 
-``tox`` autodetects if it is running in a Hudson_ context
+``tox`` autodetects if it is running in a Jenkins_ context
 (by checking for existence of the ``HUDSON_URL`` environment variable)
 and will first lookup global tox settings in this section::
 
-    [tox:hudson]
-    ...               # override [tox] settings for the hudson context
-    # note: for hudson distshare defaults to ``{toxworkdir}/distshare``.
+    [tox:jenkins]
+    ...               # override [tox] settings for the jenkins context
+    # note: for jenkins distshare defaults to ``{toxworkdir}/distshare``.
 
 
 envlist setting
@@ -104,7 +104,7 @@ Complete list of settings that you can put into ``testenv*`` sections:
     package installation.  Each line defines a dependency, which will be
     passed to easy_install/pip for processing.  It can be a file,
     and URL or a package name.  You can additionally specify
-    an :ref:`indexserver` to use for installing this dependency.
+    an :confval:`indexserver` to use for installing this dependency.
     All derived dependencies (deps required by the dep) will be
     loaded from the specified indexserver::
 
diff --git a/doc/example/general.txt b/doc/example/general.txt
index d4ab70a..f0bb43d 100644
--- a/doc/example/general.txt
+++ b/doc/example/general.txt
@@ -113,7 +113,7 @@ into the ``distshare`` directory after which a ``tox`` run on project
 highest version will be taken.  ``tox`` uses verlib_  to compare version
 strings which must be compliant with :pep:`386`.
 
-If you want to use this with Hudson_, also checkout the :ref:`hudson artifact example`.
+If you want to use this with Jenkins_, also checkout the :ref:`jenkins artifact example`.
 
 .. _verlib: http://bitbucket.org/tarek/distutilsversion/
 
diff --git a/doc/example/hudson.txt b/doc/example/jenkins.txt
index d0a1691..ad26f60 100644
--- a/doc/example/hudson.txt
+++ b/doc/example/jenkins.txt
@@ -1,23 +1,23 @@
 
-Using Tox with the Hudson Integration Server
+Using Tox with the Jenkins Integration Server
 =================================================
 
-Using Hudson multi-configuration jobs
+Using Jenkins multi-configuration jobs
 -------------------------------------------
 
-The Hudson_ continous integration server allows to define "jobs" with
+The Jenkins_ continous integration server allows to define "jobs" with
 "build steps" which can be test invocations.  If you :doc:`install <../install>` ``tox`` on your
-default Python installation on each Hudson slave, you can easily create
-a Hudson multi-configuration job that will drive your tox runs from the CI-server side,
+default Python installation on each Jenkins slave, you can easily create
+a Jenkins multi-configuration job that will drive your tox runs from the CI-server side,
 using these steps:
 
 * create a "multi-configuration" job, give it a name of your choice
-* configure your repository so that Hudson can pull it
+* configure your repository so that Jenkins can pull it
 * (optional) configure multiple nodes so that tox-runs are performed
   on multiple hosts
 * configure ``axes`` by using :ref:`TOXENV <TOXENV>` as an axis
   name and as values provide space-separated test environment names
-  you want Hudson/tox to execute.
+  you want Jenkins/tox to execute.
 
 * add a **Python-build step** with this content (see also next example)::
 
@@ -25,7 +25,7 @@ using these steps:
     tox.cmdline() # environment is selected by ``TOXENV`` env variable
 
 * check ``Publish JUnit test result report`` and enter
-  ``**/junit-*.xml`` as the pattern so that Hudson collects
+  ``**/junit-*.xml`` as the pattern so that Jenkins collects
   test results in the JUnit XML format.
 
 The last point requires that your test command creates JunitXML files,
@@ -33,16 +33,16 @@ for example with ``py.test`` it is done like this:
 
     commands=py.test --junitxml=junit-{envname}.xml
 
-See a real-life example in action with the `pytest Hudson job`_
+See a real-life example in action with the `pytest Jenkins job`_
 
-.. _`pytest Hudson job`: http://hudson.testrun.org/view/pytest/job/pytest/
+.. _`pytest Jenkins job`: http://jenkins.testrun.org/view/pytest/job/pytest/
 
 **zero-installation** for slaves
 -------------------------------------------------------------
 
 .. versionadded:: 0.9
 
-If you manage many Hudson slaves and want to use the latest officially
+If you manage many Jenkins slaves and want to use the latest officially
 released tox (or latest development version) and want to skip manually
 installing ``tox`` then substitute the above **Python build step** code
 with this::
@@ -67,10 +67,10 @@ install ``tox`` in a virtual sub environment.  Notes:
 
 .. _`toxbootstrap.py`: https://pytox.googlecode.com/hg/toxbootstrap.py
 
-Integrating "sphinx" documentation checks in a Hudson job
+Integrating "sphinx" documentation checks in a Jenkins job
 ----------------------------------------------------------------
 
-If you are using a multi-configuration Hudson job which collects
+If you are using a multi-configuration Jenkins job which collects
 JUnit Test results you will run into problems using the previous
 method of running the sphinx-build command because it will not
 generate JUnit results.  To accomodate this issue one solution
@@ -106,27 +106,27 @@ Here is an example:
               "-d", str(doctrees), ".", str(htmldir)])
 
 3. run ``tox -e docs`` and then you may integrate this environment
-   along with your other environments into Hudson.
+   along with your other environments into Jenkins.
 
 Note that ``py.test`` is only installed into the docs environment
 and does not need to be in use or installed with any other environment.
 
-.. _`hudson artifact example`:
+.. _`jenkins artifact example`:
 
-Access package artifacts between Hudson jobs
+Access package artifacts between Jenkins jobs
 --------------------------------------------------------
 
-.. _`Hudson Copy Artifact plugin`: http://wiki.hudson-ci.org/display/HUDSON/Copy+Artifact+Plugin
+.. _`Jenkins Copy Artifact plugin`: http://wiki.jenkins-ci.org/display/HUDSON/Copy+Artifact+Plugin
 
-In an extension to :ref:`artifacts` you can also configure Hudson jobs to
+In an extension to :ref:`artifacts` you can also configure Jenkins jobs to
 access each others artifacts.  ``tox`` uses the ``distshare`` directory
-to access artifacts and in a Hudson context (detected via existence
+to access artifacts and in a Jenkins context (detected via existence
 of the environment variable ``HUDSON_URL``); it defaults to
 to ``{toxworkdir}/distshare``.
 
 This means that each workspace will have its own ``distshare``
-directory and we need to configure Hudson to perform artifact copying.
-The recommend way to do this is to install the `Hudson Copy Artifact plugin`_
+directory and we need to configure Jenkins to perform artifact copying.
+The recommend way to do this is to install the `Jenkins Copy Artifact plugin`_
 and for each job which "receives" artifacts you add a **Copy artifacts from another project** build step using roughly this configuration::
 
     Project-name: name of the other (tox-managed) job you want the artifact from
@@ -145,7 +145,7 @@ Now everything proceeds as :ref:`artifacts` shows it.
 
 So if you are using defaults you can re-use and debug exactly the
 same ``tox.ini`` file and make use of automatical sharing of
-your artifacts between runs or Hudson jobs.
+your artifacts between runs or Jenkins jobs.
 
 .. include:: ../links.txt
 
diff --git a/doc/examples.txt b/doc/examples.txt
index ec40dfa..523a211 100644
--- a/doc/examples.txt
+++ b/doc/examples.txt
@@ -10,5 +10,5 @@ tox configuration and usage examples
    example/unittest
    example/nose.txt
    example/general.txt
-   example/hudson.txt
+   example/jenkins.txt
 
diff --git a/doc/index.txt b/doc/index.txt
index f3305fa..e4a05b6 100644
--- a/doc/index.txt
+++ b/doc/index.txt
@@ -72,11 +72,12 @@ Current features
 
 * **cross-platform**: Windows and Unix style environments
 
-* **integrates with continous integration servers** like Hudson_ and helps
-  you to avoid boilerplatish and platform-specific build-step hacks.
+* **integrates with continous integration servers** like Jenkins_
+  (formerly known as Hudson) and helps you to avoid boilerplatish 
+  and platform-specific build-step hacks.
 
 * **unified automatic artifact management** between ``tox`` runs both
-  in a local developer shell as well as in a CI/Hudson context.
+  in a local developer shell as well as in a CI/Jenkins context.
 
 * **driven by a simple ini-style config file**
 
diff --git a/doc/links.txt b/doc/links.txt
index 0f5b744..f1f979f 100644
--- a/doc/links.txt
+++ b/doc/links.txt
@@ -13,7 +13,7 @@
 .. _pip: http://pypi.python.org/pypi/pip
 .. _setuptools: http://pypi.python.org/pypi/setuptools
 .. _distribute: http://pypi.python.org/pypi/distribute
-.. _`hudson`: http://hudson-ci.org/
+.. _`jenkins`: http://jenkins-ci.org/
 .. _sphinx: http://pypi.python.org/pypi/Sphinx
 .. _discover: http://pypi.python.org/pypi/discover
 .. _unittest2: http://pypi.python.org/pypi/unittest2
diff --git a/setup.py b/setup.py
index a66916f..1e31289 100644
--- a/setup.py
+++ b/setup.py
@@ -35,7 +35,7 @@ def main():
         description='virtualenv-based automation of test activities',
         long_description=long_description,
         url='http://codespeak.net/tox',
-        version='0.9.1.dev2',
+        version='0.9.1.dev3',
         license='GPLv2 or later',
         platforms=['unix', 'linux', 'osx', 'cygwin', 'win32'],
         author='holger krekel',
diff --git a/tests/test_config.py b/tests/test_config.py
index 3f9c93d..7a0a28c 100644
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -395,7 +395,7 @@ class TestGlobalOptions:
         config = newconfig(["-vv"], "")
         assert config.opts.verbosity == 2
 
-    def test_substitution_hudson_default(self, tmpdir, monkeypatch, newconfig):
+    def test_substitution_jenkins_default(self, tmpdir, monkeypatch, newconfig):
         monkeypatch.setenv("HUDSON_URL", "xyz")
         config = newconfig("""
             [testenv:py24]
@@ -407,11 +407,11 @@ class TestGlobalOptions:
         expect_path = config.toxworkdir.join("distshare")
         assert argv[0][0] == expect_path
 
-    def test_substitution_hudson_context(self, tmpdir, monkeypatch, newconfig):
+    def test_substitution_jenkins_context(self, tmpdir, monkeypatch, newconfig):
         monkeypatch.setenv("HUDSON_URL", "xyz")
         monkeypatch.setenv("WORKSPACE", tmpdir)
         config = newconfig("""
-            [tox:hudson]
+            [tox:jenkins]
             distshare = {env:WORKSPACE}/hello
             [testenv:py24]
             commands =
diff --git a/tox/__init__.py b/tox/__init__.py
index c29b430..1de44ba 100644
--- a/tox/__init__.py
+++ b/tox/__init__.py
@@ -1,5 +1,5 @@
 #
-__version__ = '0.9.1.dev2'
+__version__ = '0.9.1.dev3'
 
 from py.apipkg import initpkg
 
diff --git a/tox/_config.py b/tox/_config.py
index 3991ad5..e5dabce 100644
--- a/tox/_config.py
+++ b/tox/_config.py
@@ -109,7 +109,7 @@ class parseini:
         config._cfg = self._cfg
         self.config = config
         ctxname = getcontextname()
-        if ctxname == "hudson":
+        if ctxname == "jenkins":
             reader = IniReader(self._cfg, fallbacksections=['tox'])
             toxsection = "tox:%s" % ctxname
             distshare_default = "{toxworkdir}/distshare"
@@ -375,5 +375,5 @@ class IniReader:
 
 def getcontextname():
     if 'HUDSON_URL' in os.environ:
-        return 'hudson'
+        return 'jenkins'
     return None
diff --git a/toxbootstrap.py b/toxbootstrap.py
index e10add4..a30692a 100644
--- a/toxbootstrap.py
+++ b/toxbootstrap.py
@@ -23,9 +23,9 @@ tox-bootstrap
 =============
 
 A bootstrap script to automatically install tox on machines that do not already
-have it.  This is especially useful when configuring a number of Hudson slaves
+have it.  This is especially useful when configuring a number of Jenkins slaves
 quickly (see `zero installation for slaves
-<http://codespeak.net/tox/example/hudson.html#zero-installation-for-slaves>` in
+<http://codespeak.net/tox/example/jenkins.html#zero-installation-for-slaves>` in
 tox documentation); only Python needs to be pre-installed.
 
 Getting started
@@ -44,8 +44,8 @@ will take care of installing tox (if not already installed into
 
     $ python toxbootstrap.py
 
-Note that, when configuring Hudson slaves, you need not add `toxbootstrap.py` to
-your source tree; see the above linked Hudson configuration example in tox
+Note that, when configuring Jenkins slaves, you need not add `toxbootstrap.py` to
+your source tree; see the above linked Jenkins configuration example in tox
 documentation.
 
 ToDo
@@ -58,7 +58,7 @@ ToDo
 
 """
 
-__version__ = '0.9.1.dev2'
+__version__ = '0.9.1.dev3'
 
 import sys
 import os