Merge lp:~henninge/launchpad/intltool-detection into lp:launchpad

[Henning Eggers]

Added new code to detect po directories in intltool-based source packages and to determine the translation domain from build files.

[Henning Eggers (henninge)]

= Details =

This branch provides a bunch of functions that are able to detect an intltool setup in a package directory. The top level function is "find_intltool_dirs" which returns a list of directories that have been detected to contain all files needed to generate a template file using intltool.

Another top-level function is "get_translation_domain" which extracts the translation domain for a given intltool (gettext) directory. It searches various files and performs variable substitution as necessary.

The script "scripts/rosetta/pottery-check-intltool.py" finds intltool directories in the current directory and displays their names along with their translation domain.

The code is somewhat limited as there are many different setups of source pacakges that use intltool and not all special cases are accounted for. But it will handle the most common situtations nicely.

The code is placed in a module called "pottery" because this is all about creating POT files.

== Implementation details ==

The function "run_shell_command" is taken from the Damned Lies source code.

== Tests ==

The nature of these functions requires that different directory structures are created to run the test on. These are packaged in a group of archives called intltool_*.tar.bz2 in the lib/lp/translations/test directory. The test unpacks and deletes them as required.

bin/test -vvct pottery

== Lint ==

No relevant lint.

[Jeroen T. Vermeulen (jtv)]

"Pottery"? Nice name!

Some comments on the diff:

=== added file 'lib/lp/translations/pottery/detect_intltool.py'
--- lib/lp/translations/pottery/detect_intltool.py 1970-01-01 00:00:00 +0000
+++ lib/lp/translations/pottery/detect_intltool.py 2009-12-23 11:58:18 +0000

+import errno
+import os.path
+import re
+from subprocess import Popen, PIPE
+
+POTFILES_in = "POTFILES.in"
+STATUS_OK = 0
+
+def run_shell_command(cmd, env=None, input_data=None, raise_on_error=False):

Double blank line above & below that little variable section please.

Also, POTFILES_in looks a bit weird and is only used in one place... I'd use a literal string for now and leave this kind of thing for later.

+ """Run a shell command and return the output and status.
+
+ Copied from Damned Lies source code.
+ """

It does a lot of things you don't need though. AFAICS what you need here is about 4 lines of code, not a lot of functionality that's not being tested in our codebase. (It may be tested somewhere else, but that won't cause any alarm bells to go off on our end when it needs updating).

+ stdin = None
+ if input_data:
+ stdin = PIPE
+ if env:
+ os.environ.update(env)
+ env = os.environ
+ pipe = Popen(
+ cmd, shell=True, env=env, stdin=stdin, stdout=PIPE, stderr=PIPE)
+ if input_data:
+ try:
+ pipe.stdin.write(input_data)
+ except IOError, e:
+ if e.errno != errno.EPIPE:
+ raise
+ (output, errout) = pipe.communicate()
+ status = pipe.returncode
+ if raise_on_error and status != STATUS_OK:
+ raise OSError(status, errout)
+
+ return (status, output, errout)
+
+
+def find_potfiles_in():
+ """ Search the current directory and its subdirectories for POTFILES.in.

Extra space at beginning of docstring.

+
+ :returns: A list of names of directories that contain a file POTFILES.in.
+ """
+ result_dirs = []
+ for dirpath, dirnames, dirfiles in os.walk("."):
+ if POTFILES_in in dirfiles:
+ result_dirs.append(dirpath)
+ return result_dirs
+
+
+def check_potfiles_in(path):
+ """Check if the files listed in the POTFILES.in file exist."""
+ command = ("cd \"%(dir)s\" && rm -f missing notexist && "
+ "intltool-update -m" % { "dir" : path, })

This is a bit hard to read. Also, %(dir)s probably ought to be escaped.

(On a sidenote, when you execute commands like "cd %s" on a GNU system, it can be a good habit to use the "--" option to indicate that there are no command-line options after that point. Just in case you run across a "%s" that starts with a dash for whatever reason.)

+ (status, output, errs) = run_shell_command(command)
+
+ if status != 0:
+ return False

You're spelling STATUS_OK a bit inconsistently. :-)

+
+ notexist = os.path.join(path, "notexist")
+ return not os.access(notexist, os.R_OK)
+
+
+def find_intltool_dirs():
+ """Search the current directory and its subdiretories for intltool
+ structure.
+ """
+ return sorted(filter(check_potfiles_in, find_potfiles_in()))

Nice & compact.

+def get_translation_domain(dirname):
+ """Determine the transl...

[Jeroen T. Vermeulen (jtv)]

Nice test suite for get_translation_domain by the way!

[Henning Eggers (henninge)]

Good Morning Jeroen!

Thank you for staying up so late to do this review. Please find my
comments below.

Am 23.12.2009 17:18, Jeroen T. Vermeulen schrieb:
> "Pottery"? Nice name!

Yeah, Danilo and I were throwing ideas at another about where to put
this code. Eventually I said "I might even call it pottery" and he said
"I like that!" ;-)

>
> Some comments on the diff:
>
> === added file 'lib/lp/translations/pottery/detect_intltool.py'
> --- lib/lp/translations/pottery/detect_intltool.py 1970-01-01 00:00:00 +0000
> +++ lib/lp/translations/pottery/detect_intltool.py 2009-12-23 11:58:18 +0000
>
> +import errno
> +import os.path
> +import re
> +from subprocess import Popen, PIPE
> +
> +POTFILES_in = "POTFILES.in"
> +STATUS_OK = 0
> +
> +def run_shell_command(cmd, env=None, input_data=None, raise_on_error=False):
>
> Double blank line above & below that little variable section please.
>
> Also, POTFILES_in looks a bit weird and is only used in one place... I'd use a literal string for now and leave this kind of thing for later.

At first I thought I'd need more of these but turned out I didn't. This
section is gone now.

>
>
> + """Run a shell command and return the output and status.
> +
> + Copied from Damned Lies source code.
> + """
>
> It does a lot of things you don't need though. AFAICS what you need here is about 4 lines of code, not a lot of functionality that's not being tested in our codebase. (It may be tested somewhere else, but that won't cause any alarm bells to go off on our end when it needs updating).

It's gone now as your already saw.

[...]

> +
> +def find_potfiles_in():
> + """ Search the current directory and its subdirectories for POTFILES.in.
>
> Extra space at beginning of docstring.

Gone.

>
>
> +
> + :returns: A list of names of directories that contain a file POTFILES.in.
> + """
> + result_dirs = []
> + for dirpath, dirnames, dirfiles in os.walk("."):
> + if POTFILES_in in dirfiles:
> + result_dirs.append(dirpath)
> + return result_dirs
> +
> +
> +def check_potfiles_in(path):
> + """Check if the files listed in the POTFILES.in file exist."""
> + command = ("cd \"%(dir)s\" && rm -f missing notexist && "
> + "intltool-update -m" % { "dir" : path, })
>
> This is a bit hard to read. Also, %(dir)s probably ought to be escaped.
>
> (On a sidenote, when you execute commands like "cd %s" on a GNU system, it can be a good habit to use the "--" option to indicate that there are no command-line options after that point. Just in case you run across a "%s" that starts with a dash for whatever reason.)

This has changed completely as you saw in the diff you admired ... ;)

[...]

> +
> +def find_intltool_dirs():
> + """Search the current directory and its subdiretories for intltool
> + structure.
> + """
> + return sorted(filter(check_potfiles_in, find_potfiles_in()))
>
> Nice & compact.

Yes, that's one of the features I like about Python.

>
>
> +def get_translation_domain(dirname):
> + """Determine the translation domain by parsing various files.
>
> I find this very unclear. It says too much about _how_ it does its job, ...

[Jeroen T. Vermeulen (jtv)]

Thanks for the changes.

review: Approve (code)

=== modified file 'lib/devscripts/ec2test/account.py'
--- lib/devscripts/ec2test/account.py	2009-10-08 14:50:19 +0000
+++ lib/devscripts/ec2test/account.py	2010-02-01 09:53:14 +0000
@@ -24,6 +24,7 @@
     255383312499, # gary
     559320013529, # flacoste
     200337130613, # mwhudson
+    889698597288, # henninge
     # ...anyone else want in on the fun?
     )
 

=== added directory 'lib/lp/translations/pottery'
=== added file 'lib/lp/translations/pottery/__init__.py'
=== added file 'lib/lp/translations/pottery/detect_intltool.py'
--- lib/lp/translations/pottery/detect_intltool.py	1970-01-01 00:00:00 +0000
+++ lib/lp/translations/pottery/detect_intltool.py	2010-02-01 09:53:14 +0000
@@ -0,0 +1,215 @@
+#! /usr/bin/python2.5
+#
+# Copyright 2009 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Functions to detect if intltool can be used to generate a POT file for the
+package in the current directory."""
+
+__metaclass__ = type
+__all__ = [
+    'check_potfiles_in',
+    'get_translation_domain',
+    'find_intltool_dirs',
+    'find_potfiles_in',
+    ]
+
+import errno
+import os.path
+import re
+from subprocess import call
+
+
+def find_potfiles_in():
+    """Search the current directory and its subdirectories for POTFILES.in.
+
+    :returns: A list of names of directories that contain a file POTFILES.in.
+    """
+    result_dirs = []
+    for dirpath, dirnames, dirfiles in os.walk("."):
+        if "POTFILES.in" in dirfiles:
+            result_dirs.append(dirpath)
+    return result_dirs
+
+
+def check_potfiles_in(path):
+    """Check if the files listed in the POTFILES.in file exist."""
+    current_path = os.getcwd()
+
+    try:
+        os.chdir(path)
+    except OSError, e:
+        # Abort nicely if directory does not exist.
+        if e.errno == errno.ENOENT:
+            return False
+        raise
+    try:
+        for unlink_name in ['missing', 'notexist']:
+            try:
+                os.unlink(unlink_name)
+            except OSError, e:
+                # It's ok if the files are missing.
+                if e.errno != errno.ENOENT:
+                    raise
+        devnull = open("/dev/null", "w")
+        returncode = call(
+            ["/usr/bin/intltool-update", "-m"],
+            stdout=devnull, stderr=devnull)
+        devnull.close()
+    finally:
+        os.chdir(current_path)
+
+    if returncode != 0:
+        return False
+
+    notexist = os.path.join(path, "notexist")
+    return not os.access(notexist, os.R_OK)
+
+
+def find_intltool_dirs():
+    """Search the current directory and its subdiretories for intltool
+    structure.
+    """
+    return sorted(filter(check_potfiles_in, find_potfiles_in()))
+
+
+def _try_substitution(path, substitution):
+    """Try to find a substitution in the given config file.
+
+    :returns: The completed substitution or None if none was found.
+    """
+    subst_value = ConfigFile(path).getVariable(substitution.name)
+    if subst_value is None:
+        # No substitution found.
+        return None
+    return substitution.replace(subst_value)
+
+
+def get_translation_domain(dirname):
+    """Get the translation domain for this PO directory.
+
+    Imitates some of the behavior of intltool-update to find out which
+    translation domain the build environment provides. The domain is usually
+    defined in the GETTEXT_PACKAGE variable in one of the build files. Another
+    variant is DOMAIN in the Makevars file. This function goes through the
+    ordered list of these possible locations, the order having been copied
+    from intltool-update, and tries to find a valid value.
+
+    If the found value contains a substitution, either autoconf style (@...@)
+    or make style ($(...)), the search is continued in the same file and down
+    the list of files, now searching for the substitution. Multiple
+    substitutions or multi-level substitutions are not supported.
+    """
+    locations = [
+        ('Makefile.in.in', 'GETTEXT_PACKAGE'),
+        ('../configure.ac', 'GETTEXT_PACKAGE'),
+        ('../configure.in', 'GETTEXT_PACKAGE'),
+        ('Makevars', 'DOMAIN'),
+    ]
+    value = None
+    substitution = None
+    for filename, varname in locations:
+        path = os.path.join(dirname, filename)
+        if not os.access(path, os.R_OK):
+            # Skip non-existent files.
+            continue
+        if substitution is None:
+            value = ConfigFile(path).getVariable(varname)
+            if value is not None:
+                # Check if the value need a substitution.
+                substitution = Substitution.get(value)
+                if substitution is not None:
+                    # Try to substitute with value from current file but
+                    # avoid recursion.
+                    if substitution.name != varname:
+                        value = _try_substitution(path, substitution)
+                    else:
+                        # The value has not been found yet but is now stored
+                        # in the Substitution instance.
+                        value = None
+        else:
+            value = _try_substitution(path, substitution)
+        if value is not None:
+            # A value has been found.
+            break
+    if substitution is not None and not substitution.replaced:
+        # Substitution failed.
+        return None
+    return value
+
+
+class ConfigFile(object):
+    """Represent a config file and return variables defined in it."""
+
+    def __init__(self, file_or_name):
+        if isinstance(file_or_name, basestring):
+            conf_file = file(file_or_name)
+        else:
+            conf_file = file_or_name
+        self.content_lines = conf_file.readlines()
+
+    def getVariable(self, name):
+        """Search the file for a variable definition with this name."""
+        pattern = re.compile("^%s[ \t]*=[ \t]*([^\s]*)" % re.escape(name))
+        variable = None
+        for line in self.content_lines:
+            result = pattern.match(line)
+            if result is not None:
+                variable = result.group(1)
+        return variable
+
+
+class Substitution(object):
+    """Find and replace substitutions.
+
+    Variable texts may contain other variables which should be substituted
+    for their value. These are either marked by surrounding @ signs (autoconf
+    style) or preceded by a $ sign with optional () (make style).
+
+    This class identifies a single such substitution in a variable text and
+    extract the name of the variable who's value is to be inserted. It also
+    facilitates the actual replacement so that caller does not have to worry
+    about the substitution style that is being used.
+    """
+
+    autoconf_pattern = re.compile("@([^@]+)@")
+    makefile_pattern = re.compile("\$\(?([^\s\)]+)\)?")
+
+    @staticmethod
+    def get(variabletext):
+        """Factory method.
+
+        Creates a Substitution instance and checks if it found a substitution.
+
+        :param variabletext: A variable value with possible substitution.
+        :returns: A Substitution object or None if no substitution was found.
+        """
+        subst = Substitution(variabletext)
+        if subst.name is not None:
+            return subst
+        return None
+
+    def _searchForPatterns(self):
+        """Search for all the available patterns in variable text."""
+        result = self.autoconf_pattern.search(self.text)
+        if result is None:
+            result = self.makefile_pattern.search(self.text)
+        return result
+
+    def __init__(self, variabletext):
+        """Extract substitution name from variable text."""
+        self.text = variabletext
+        self.replaced = False
+        result = self._searchForPatterns()
+        if result is None:
+            self._replacement = None
+            self.name = None
+        else:
+            self._replacement = result.group(0)
+            self.name = result.group(1)
+
+    def replace(self, value):
+        """Return a copy of the variable text with the substitution resolved.
+        """
+        self.replaced = True
+        return self.text.replace(self._replacement, value)

=== added file 'lib/lp/translations/tests/intltool_POTFILES_in_1.tar.bz2'
Binary files lib/lp/translations/tests/intltool_POTFILES_in_1.tar.bz2	1970-01-01 00:00:00 +0000 and lib/lp/translations/tests/intltool_POTFILES_in_1.tar.bz2	2010-02-01 09:53:14 +0000 differ
=== added file 'lib/lp/translations/tests/intltool_POTFILES_in_2.tar.bz2'
Binary files lib/lp/translations/tests/intltool_POTFILES_in_2.tar.bz2	1970-01-01 00:00:00 +0000 and lib/lp/translations/tests/intltool_POTFILES_in_2.tar.bz2	2010-02-01 09:53:14 +0000 differ
=== added file 'lib/lp/translations/tests/intltool_domain_configure_ac.tar.bz2'
Binary files lib/lp/translations/tests/intltool_domain_configure_ac.tar.bz2	1970-01-01 00:00:00 +0000 and lib/lp/translations/tests/intltool_domain_configure_ac.tar.bz2	2010-02-01 09:53:14 +0000 differ
=== added file 'lib/lp/translations/tests/intltool_domain_configure_in.tar.bz2'
Binary files lib/lp/translations/tests/intltool_domain_configure_in.tar.bz2	1970-01-01 00:00:00 +0000 and lib/lp/translations/tests/intltool_domain_configure_in.tar.bz2	2010-02-01 09:53:14 +0000 differ
=== added file 'lib/lp/translations/tests/intltool_domain_configure_in_substitute_version.tar.bz2'
Binary files lib/lp/translations/tests/intltool_domain_configure_in_substitute_version.tar.bz2	1970-01-01 00:00:00 +0000 and lib/lp/translations/tests/intltool_domain_configure_in_substitute_version.tar.bz2	2010-02-01 09:53:14 +0000 differ
=== added file 'lib/lp/translations/tests/intltool_domain_makefile_in_in.tar.bz2'
Binary files lib/lp/translations/tests/intltool_domain_makefile_in_in.tar.bz2	1970-01-01 00:00:00 +0000 and lib/lp/translations/tests/intltool_domain_makefile_in_in.tar.bz2	2010-02-01 09:53:14 +0000 differ
=== added file 'lib/lp/translations/tests/intltool_domain_makefile_in_in_substitute.tar.bz2'
Binary files lib/lp/translations/tests/intltool_domain_makefile_in_in_substitute.tar.bz2	1970-01-01 00:00:00 +0000 and lib/lp/translations/tests/intltool_domain_makefile_in_in_substitute.tar.bz2	2010-02-01 09:53:14 +0000 differ
=== added file 'lib/lp/translations/tests/intltool_domain_makefile_in_in_substitute_broken.tar.bz2'
Binary files lib/lp/translations/tests/intltool_domain_makefile_in_in_substitute_broken.tar.bz2	1970-01-01 00:00:00 +0000 and lib/lp/translations/tests/intltool_domain_makefile_in_in_substitute_broken.tar.bz2	2010-02-01 09:53:14 +0000 differ
=== added file 'lib/lp/translations/tests/intltool_domain_makefile_in_in_substitute_same_file.tar.bz2'
Binary files lib/lp/translations/tests/intltool_domain_makefile_in_in_substitute_same_file.tar.bz2	1970-01-01 00:00:00 +0000 and lib/lp/translations/tests/intltool_domain_makefile_in_in_substitute_same_file.tar.bz2	2010-02-01 09:53:14 +0000 differ
=== added file 'lib/lp/translations/tests/intltool_domain_makefile_in_in_substitute_same_name.tar.bz2'
Binary files lib/lp/translations/tests/intltool_domain_makefile_in_in_substitute_same_name.tar.bz2	1970-01-01 00:00:00 +0000 and lib/lp/translations/tests/intltool_domain_makefile_in_in_substitute_same_name.tar.bz2	2010-02-01 09:53:14 +0000 differ
=== added file 'lib/lp/translations/tests/intltool_domain_makevars.tar.bz2'
Binary files lib/lp/translations/tests/intltool_domain_makevars.tar.bz2	1970-01-01 00:00:00 +0000 and lib/lp/translations/tests/intltool_domain_makevars.tar.bz2	2010-02-01 09:53:14 +0000 differ
=== added file 'lib/lp/translations/tests/intltool_full_ok.tar.bz2'
Binary files lib/lp/translations/tests/intltool_full_ok.tar.bz2	1970-01-01 00:00:00 +0000 and lib/lp/translations/tests/intltool_full_ok.tar.bz2	2010-02-01 09:53:14 +0000 differ
=== added file 'lib/lp/translations/tests/intltool_single_ok.tar.bz2'
Binary files lib/lp/translations/tests/intltool_single_ok.tar.bz2	1970-01-01 00:00:00 +0000 and lib/lp/translations/tests/intltool_single_ok.tar.bz2	2010-02-01 09:53:14 +0000 differ
=== added file 'lib/lp/translations/tests/test_pottery_detect_intltool.py'
--- lib/lp/translations/tests/test_pottery_detect_intltool.py	1970-01-01 00:00:00 +0000
+++ lib/lp/translations/tests/test_pottery_detect_intltool.py	2010-02-01 09:53:14 +0000
@@ -0,0 +1,209 @@
+# Copyright 2009 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+import os
+import shutil
+import tarfile
+import tempfile
+import unittest
+
+from StringIO import StringIO
+from textwrap import dedent
+
+from canonical.launchpad.scripts.tests import run_script
+from lp.translations.pottery.detect_intltool import (
+    ConfigFile, check_potfiles_in, find_intltool_dirs, find_potfiles_in,
+    get_translation_domain)
+from lp.testing import TestCase
+
+class TestDetectIntltool(TestCase):
+
+    def setUp(self):
+        super(TestDetectIntltool, self).setUp()
+        # Determine test directory and create temporary working directory.
+        self.curdir = os.getcwd()
+        self.testdir = os.path.join(self.curdir, os.path.dirname(__file__))
+        self.workdir = tempfile.mkdtemp()
+        os.chdir(self.workdir)
+
+    def tearDown(self):
+        # Remove temporary directory.
+        os.chdir(self.curdir)
+        shutil.rmtree(self.workdir)
+        super(TestDetectIntltool, self).tearDown()
+
+    def _prepare_package(self, packagename):
+        # Unpack the specified pacakge to run the test against it.
+        # Change to this directory.
+        packagepath = os.path.join(self.testdir, packagename+".tar.bz2")
+        tar = tarfile.open(packagepath, "r:bz2")
+        tar.extractall()
+        tar.close()
+        os.chdir(packagename)
+
+    def test_detect_potfiles_in(self):
+        # Find POTFILES.in in a package with multiple dirs when only one has
+        # POTFILES.in.
+        self._prepare_package("intltool_POTFILES_in_1")
+        dirs = find_potfiles_in()
+        self.assertContentEqual(["./po-intltool"], dirs)
+
+    def test_detect_potfiles_in_module(self):
+        # Find POTFILES.in in a package with POTFILES.in at different levels.
+        self._prepare_package("intltool_POTFILES_in_2")
+        dirs = find_potfiles_in()
+        self.assertContentEqual(["./po", "./module1/po"], dirs)
+
+    def test_check_potfiles_in_content_ok(self):
+        # Ideally all files listed in POTFILES.in exist in the source package.
+        self._prepare_package("intltool_single_ok")
+        self.assertTrue(check_potfiles_in("./po")) 
+
+    def test_check_potfiles_in_content_ok_file_added(self):
+        # If a file is not listed in POTFILES.in, the file is still good for
+        # our purposes.
+        self._prepare_package("intltool_single_ok")
+        added_file = file("./src/sourcefile_new.c", "w")
+        added_file.write("/* Test file. */")
+        added_file.close()
+        self.assertTrue(check_potfiles_in("./po")) 
+
+    def test_check_potfiles_in_content_not_ok_file_removed(self):
+        # If a file is missing that is listed in POTFILES.in, the file
+        # intltool structure is probably broken and cannot be used for
+        # our purposes.
+        self._prepare_package("intltool_single_ok")
+        os.remove("./src/sourcefile1.c")
+        self.assertFalse(check_potfiles_in("./po")) 
+
+    def test_check_potfiles_in_wrong_directory(self):
+        # Passing in the wrong directory will cause the check to fail
+        # gracefully and return False.
+        self._prepare_package("intltool_single_ok")
+        self.assertFalse(check_potfiles_in("./foo")) 
+
+    def test_find_intltool_dirs(self):
+        # Complete run: find all directories with intltool structure.
+        self._prepare_package("intltool_full_ok")
+        self.assertEqual(
+            ["./po-module1", "./po-module2"], find_intltool_dirs())
+
+    def test_find_intltool_dirs_broken(self):
+        # Complete run: part of the intltool structure is broken.
+        self._prepare_package("intltool_full_ok")
+        os.remove("./src/module1/sourcefile1.c")
+        self.assertEqual(
+            ["./po-module2"], find_intltool_dirs())
+
+    def test_get_translation_domain_makevars(self):
+        # Find a translation domain in Makevars.
+        self._prepare_package("intltool_domain_makevars")
+        self.assertEqual(
+            "translationdomain",
+            get_translation_domain("po"))
+
+    def test_get_translation_domain_makefile_in_in(self):
+        # Find a translation domain in Makefile.in.in.
+        self._prepare_package("intltool_domain_makefile_in_in")
+        self.assertEqual(
+            "packagename-in-in",
+            get_translation_domain("po"))
+
+    def test_get_translation_domain_configure_ac(self):
+        # Find a translation domain in configure.ac.
+        self._prepare_package("intltool_domain_configure_ac")
+        self.assertEqual(
+            "packagename-ac",
+            get_translation_domain("po"))
+
+    def test_get_translation_domain_configure_in(self):
+        # Find a translation domain in configure.in.
+        self._prepare_package("intltool_domain_configure_in")
+        self.assertEqual(
+            "packagename-in",
+            get_translation_domain("po"))
+
+    def test_get_translation_domain_makefile_in_in_substitute(self):
+        # Find a translation domain in Makefile.in.in with substitution from
+        # configure.ac.
+        self._prepare_package("intltool_domain_makefile_in_in_substitute")
+        self.assertEqual(
+            "domainname-ac-in-in",
+            get_translation_domain("po"))
+
+    def test_get_translation_domain_makefile_in_in_substitute_same_name(self):
+        # Find a translation domain in Makefile.in.in with substitution from
+        # configure.ac from a variable with the same name as in
+        # Makefile.in.in.
+        self._prepare_package(
+            "intltool_domain_makefile_in_in_substitute_same_name")
+        self.assertEqual(
+            "packagename-ac-in-in",
+            get_translation_domain("po"))
+
+    def test_get_translation_domain_makefile_in_in_substitute_same_file(self):
+        # Find a translation domain in Makefile.in.in with substitution from
+        # the same file.
+        self._prepare_package(
+            "intltool_domain_makefile_in_in_substitute_same_file")
+        self.assertEqual(
+            "domain-in-in-in-in",
+            get_translation_domain("po"))
+
+    def test_get_translation_domain_makefile_in_in_substitute_broken(self):
+        # Find no translation domain in Makefile.in.in when the substitution
+        # cannot be fulfilled.
+        self._prepare_package(
+            "intltool_domain_makefile_in_in_substitute_broken")
+        self.assertIs(None, get_translation_domain("po"))
+
+    def test_get_translation_domain_configure_in_substitute_version(self):
+        # Find a translation domain in configure.in with Makefile-style
+        # substitution from the same file.
+        self._prepare_package(
+            "intltool_domain_configure_in_substitute_version")
+        self.assertEqual(
+            "domainname-in42",
+            get_translation_domain("po"))
+
+    def test_pottery_check_intltool_script(self):
+        # Let the script run to see it works fine.
+        self._prepare_package("intltool_full_ok")
+
+        return_code, stdout, stderr = run_script(
+            'scripts/rosetta/pottery-check-intltool.py', [])
+
+        self.assertEqual(dedent("""\
+            ./po-module1 (packagename-module1)
+            ./po-module2 (packagename-module2)
+            """), stdout)
+
+
+class TestConfigFile(TestCase):
+
+    def setUp(self):
+        super(TestConfigFile, self).setUp()
+        self.configfile = ConfigFile(StringIO(dedent("""\
+            # Demo config file
+            CCC
+            AAA=
+            BBB = 
+            CCC = ccc # comment
+            DDD=dd.d
+            """)))
+
+    def test_getVariable_exists(self):
+        self.assertEqual('ccc', self.configfile.getVariable('CCC'))
+        self.assertEqual('dd.d', self.configfile.getVariable('DDD'))
+
+    def test_getVariable_empty(self):
+        self.assertEqual('', self.configfile.getVariable('AAA'))
+        self.assertEqual('', self.configfile.getVariable('BBB'))
+
+    def test_getVariable_nonexistent(self):
+        self.assertIs(None, self.configfile.getVariable('FFF'))
+
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromName(__name__)
+

=== added file 'scripts/rosetta/pottery-check-intltool.py'
--- scripts/rosetta/pottery-check-intltool.py	1970-01-01 00:00:00 +0000
+++ scripts/rosetta/pottery-check-intltool.py	2010-02-01 09:53:14 +0000
@@ -0,0 +1,18 @@
+#! /usr/bin/python2.5
+#
+# Copyright 2009 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Print a list of directories that contain a valid intltool structure."""
+
+import _pythonpath
+
+
+from lp.translations.pottery.detect_intltool import (
+    find_intltool_dirs, get_translation_domain)
+
+
+if __name__ == "__main__":
+    for dirname in find_intltool_dirs():
+        translation_domain = get_translation_domain(dirname) or "<unknown>"
+        print "%s (%s)" % (dirname, translation_domain)