Merge lp:~jtv/launchpad/custom-language-codes into lp:launchpad

[Jeroen T. Vermeulen]

[Jeroen T. Vermeulen (jtv)]

= Bug 271747: Custom Language Codes UI =

This is an oversized branch, and it's not particularly urgent. Review it only if you feel like it, or something's changed and we've begged you to do it.

Some projects or Ubuntu packages insist on using nonstandard language codes. To deal with those we created, long ago, "custom language codes" which allow the import approval process to recognize that an upload with a given "weird" language code is actually, by the project's or package's standard, a translation for a given language.

We don't advertise this feature, and it's not frequently used. Project owners do not get access to it. It's really only there for a few problem cases like OpenOffice.org, which not only use nonstandard language codes but also add or move templates regularly. If it were just a matter of a single translation, you could simply approve it once and the approver would remember the path and associate it with the right translation.

However, it is a pain in the neck to have to write SQL, get approval, and go through LOSAs every time we want one of these babies added. So this branch finally creates a simple UI for dealing with them.

The simple UI lists custom language codes, shows them in detail, adds them, and removes them. For non-admins there's a read-only view of the whole thing, which may come in handy when debugging, but we don't link to them because generally speaking, custom language codes are probably the wrong solution for a project having problem with its language codes. And it adds one more knob to twiddle, providing one more thing that may go wrong with import approvals.

One limitation: this branch allows only Launchpad admins to manipulate custom language codes. In future we'll also want to allow Rosetta admins to do this. But that required some fiddling to check for the right permissions. This branch is already oversized, so instead I intend to file a separate bug about it.

== Tests ==
{{{
./bin/test -vv -t custom-language-codes.txt
}}}

== Demo, Q/A, and UI review ==

Log in as a Launchpad administrator. Go to the Translations page for a project or source package with translations.

On staging:
    https://translations.staging.launchpad.net/josm/

On a development machine:
    https://translations.launchpad.dev/evolution/

At the bottom of the right-hand side column you'll see a note: "If necessary, you may <define custom language codes> for this project." Click on the link to get to the custom language codes UI for the project.

The page it takes you to is an overview, probably of nothing as yet. Try adding a custom language code: map a custom "language code" to an actual language, or to no language at all. (If you map to no language, uploads with that language code string will quietly disappear—useful but one of those things that can cause support headaches if misused). "Weird" characters are rejected; we don't want to be able to redefine the ".po" filename extension to refer to a language or anything like that.

Whatever you add will show up in the listing. You can also remove or view the codes. Viewing them doesn't give you much, besides a link to the language, but it was needed to make t...

[Abel Deuring (adeuring)]

Hi Jeroen,

a nice branch, the Losas will appreciate it, I am sure.

We discuessed two minor issues on IRC (NotFound error instead of UnexpectedFormData in HasCustomlagnuageCodeTraversalMixin, and a no longer needed definition of getCustomLangaugeCode in IDistribution), pleased fix them.

review: Approve (code)

=== modified file 'lib/lp/registry/browser/distributionsourcepackage.py'
--- lib/lp/registry/browser/distributionsourcepackage.py	2009-11-10 21:33:20 +0000
+++ lib/lp/registry/browser/distributionsourcepackage.py	2009-11-19 04:05:29 +0000
@@ -50,6 +50,8 @@
 from lp.registry.browser.packaging import PackagingDeleteView
 from lp.registry.interfaces.pocket import pocketsuffix
 from lp.registry.interfaces.product import IDistributionSourcePackage
+from lp.translations.browser.customlanguagecode import (
+    HasCustomLanguageCodesTraversalMixin)
 
 
 class DistributionSourcePackageBreadcrumb(Breadcrumb):
@@ -117,7 +119,8 @@
 
 
 class DistributionSourcePackageNavigation(Navigation,
-    BugTargetTraversalMixin, QuestionTargetTraversalMixin,
+    BugTargetTraversalMixin, HasCustomLanguageCodesTraversalMixin,
+    QuestionTargetTraversalMixin,
     StructuralSubscriptionTargetTraversalMixin):
 
     usedfor = IDistributionSourcePackage
 
=== modified file 'lib/lp/registry/browser/product.py'
--- lib/lp/registry/browser/product.py	2009-11-11 16:57:29 +0000
+++ lib/lp/registry/browser/product.py	2009-11-19 04:05:29 +0000
@@ -86,6 +86,8 @@
 from lp.answers.browser.faqtarget import FAQTargetNavigationMixin
 from canonical.launchpad.browser.feeds import FeedsMixin
 from lp.registry.browser.productseries import get_series_branch_error
+from lp.translations.browser.customlanguagecode import (
+    HasCustomLanguageCodesTraversalMixin)
 from canonical.launchpad.browser.multistep import MultiStepView, StepView
 from lp.answers.browser.questiontarget import (
     QuestionTargetFacetMixin, QuestionTargetTraversalMixin)
@@ -118,8 +120,8 @@
 
 class ProductNavigation(
     Navigation, BugTargetTraversalMixin,
-    FAQTargetNavigationMixin, QuestionTargetTraversalMixin,
-    StructuralSubscriptionTargetTraversalMixin):
+    FAQTargetNavigationMixin, HasCustomLanguageCodesTraversalMixin,
+    QuestionTargetTraversalMixin, StructuralSubscriptionTargetTraversalMixin):
 
     usedfor = IProduct
 
 
=== modified file 'lib/lp/registry/configure.zcml'
--- lib/lp/registry/configure.zcml	2009-11-15 01:05:49 +0000
+++ lib/lp/registry/configure.zcml	2009-11-19 04:05:29 +0000
@@ -353,6 +353,9 @@
     <class
         class="lp.registry.model.distributionsourcepackage.DistributionSourcePackage">
         <allow
+            interface="lp.translations.interfaces.customlanguagecode.IHasCustomLanguageCodes"/>
+
+        <allow
             attributes="
                 distribution
                 development_version
@@ -1045,6 +1048,8 @@
             interface="lp.registry.interfaces.product.IProductPublic"/>
         <allow
             interface="lp.translations.interfaces.translationimportqueue.IHasTranslationImports"/>
+        <allow
+            interface="lp.translations.interfaces.customlanguagecode.IHasCustomLanguageCodes"/>
         <require
             permission="launchpad.Driver"
             interface="lp.registry.interfaces.product.IProductDriverRestricted"/>
 
=== modified file 'lib/lp/registry/interfaces/distribution.py'
--- lib/lp/registry/interfaces/distribution.py	2009-10-26 18:40:04 +0000
+++ lib/lp/registry/interfaces/distribution.py	2009-11-19 04:05:29 +0000
@@ -511,13 +511,6 @@
               bug watches or to products that use_malone.
         """
 
-    def getCustomLanguageCode(sourcepackagename, language_code):
-        """Look up `ICustomLanguageCode`.
-
-        A `SourcePackageName` in a Distribution may override some
-        language codes for translation import purposes.
-        """
-
     def userCanEdit(user):
         """Can the user edit this distribution?"""
 
 
=== modified file 'lib/lp/registry/interfaces/product.py'
--- lib/lp/registry/interfaces/product.py	2009-10-26 18:40:04 +0000
+++ lib/lp/registry/interfaces/product.py	2009-11-19 04:05:29 +0000
@@ -668,13 +668,6 @@
     def packagedInDistros():
         """Returns the distributions this product has been packaged in."""
 
-    def getCustomLanguageCode(language_code):
-        """Look up `ICustomLanguageCode` for `language_code`, if any.
-
-        Products may override language code definitions for translation
-        import purposes.
-        """
-
     def userCanEdit(user):
         """Can the user edit this product?"""
 
 
=== modified file 'lib/lp/registry/model/distribution.py'
--- lib/lp/registry/model/distribution.py	2009-11-06 21:10:13 +0000
+++ lib/lp/registry/model/distribution.py	2009-11-19 04:05:29 +0000
@@ -37,7 +37,6 @@
     BugTargetBase, OfficialBugTagTargetMixin)
 from lp.bugs.model.bugtask import BugTask
 from lp.soyuz.model.build import Build
-from lp.translations.model.customlanguagecode import CustomLanguageCode
 from lp.registry.model.distributionmirror import DistributionMirror
 from lp.registry.model.distributionsourcepackage import (
     DistributionSourcePackage)
@@ -1458,12 +1457,6 @@
                  bugs_affecting_upstream, bugs_with_upstream_bugwatch))
         return results
 
-    def getCustomLanguageCode(self, sourcepackagename, language_code):
-        """See `IDistribution`."""
-        return CustomLanguageCode.selectOneBy(
-            distribution=self, sourcepackagename=sourcepackagename,
-            language_code=language_code)
-
     def setBugSupervisor(self, bug_supervisor, user):
         """See `IHasBugSupervisor`."""
         self.bug_supervisor = bug_supervisor
 
=== modified file 'lib/lp/registry/model/distributionsourcepackage.py'
--- lib/lp/registry/model/distributionsourcepackage.py	2009-11-17 21:14:55 +0000
+++ lib/lp/registry/model/distributionsourcepackage.py	2009-11-19 04:05:29 +0000
@@ -44,11 +44,18 @@
     DistributionSourcePackageRelease)
 from lp.soyuz.model.publishing import SourcePackagePublishingHistory
 from lp.soyuz.model.sourcepackagerelease import SourcePackageRelease
+from lp.translations.interfaces.customlanguagecode import (
+    IHasCustomLanguageCodes)
+from lp.translations.model.customlanguagecode import (
+    CustomLanguageCode, HasCustomLanguageCodesMixin)
+
 
 class DistributionSourcePackage(BugTargetBase,
                                 SourcePackageQuestionTargetMixin,
                                 StructuralSubscriptionTargetMixin,
-                                HasBranchesMixin, HasMergeProposalsMixin):
+                                HasBranchesMixin, 
+                                HasCustomLanguageCodesMixin,
+                                HasMergeProposalsMixin):
     """This is a "Magic Distribution Source Package". It is not an
     SQLObject, but instead it represents a source package with a particular
     name in a particular distribution. You can then ask it all sorts of
@@ -56,7 +63,8 @@
     or current release, etc.
     """
 
-    implements(IDistributionSourcePackage, IQuestionTarget)
+    implements(
+        IDistributionSourcePackage, IHasCustomLanguageCodes, IQuestionTarget)
 
     def __init__(self, distribution, sourcepackagename):
         self.distribution = distribution
@@ -413,6 +421,19 @@
             'BugTask.distribution = %s AND BugTask.sourcepackagename = %s' %
                 sqlvalues(self.distribution, self.sourcepackagename))
 
+    def composeCustomLanguageCodeMatch(self):
+        """See `HasCustomLanguageCodesMixin`."""
+        return And(
+            CustomLanguageCode.distribution == self.distribution,
+            CustomLanguageCode.sourcepackagename == self.sourcepackagename)
+
+    def createCustomLanguageCode(self, language_code, language):
+        """See `IHasCustomLanguageCodes`."""
+        return CustomLanguageCode(
+            distribution=self.distribution,
+            sourcepackagename=self.sourcepackagename,
+            language_code=language_code, language=language)
+
     @staticmethod
     def getPersonsByEmail(email_addresses):
         """[(EmailAddress,Person), ..] iterable for given email addresses."""
 
=== modified file 'lib/lp/registry/model/product.py'
--- lib/lp/registry/model/product.py	2009-11-06 21:06:38 +0000
+++ lib/lp/registry/model/product.py	2009-11-19 04:05:29 +0000
@@ -1,6 +1,5 @@
 # Copyright 2009 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
-
 # pylint: disable-msg=E0611,W0212
 
 """Database classes including and related to Product."""
@@ -45,7 +44,8 @@
 from lp.bugs.model.bugwatch import BugWatch
 from lp.registry.model.commercialsubscription import (
     CommercialSubscription)
-from lp.translations.model.customlanguagecode import CustomLanguageCode
+from lp.translations.model.customlanguagecode import (
+    CustomLanguageCode, HasCustomLanguageCodesMixin)
 from lp.translations.model.potemplate import POTemplate
 from lp.registry.model.distroseries import DistroSeries
 from lp.registry.model.distribution import Distribution
@@ -81,6 +81,8 @@
 from canonical.launchpad.interfaces.launchpad import (
     IHasIcon, IHasLogo, IHasMugshot, ILaunchpadCelebrities, ILaunchpadUsage,
     NotFoundError)
+from lp.translations.interfaces.customlanguagecode import (
+    IHasCustomLanguageCodes)
 from canonical.launchpad.interfaces.launchpadstatistic import (
     ILaunchpadStatisticSet)
 from lp.registry.interfaces.person import IPersonSet
@@ -166,13 +168,13 @@
               QuestionTargetMixin, HasTranslationImportsMixin,
               HasAliasMixin, StructuralSubscriptionTargetMixin,
               HasMilestonesMixin, OfficialBugTagTargetMixin, HasBranchesMixin,
-              HasMergeProposalsMixin):
+              HasCustomLanguageCodesMixin, HasMergeProposalsMixin):
 
     """A Product."""
 
     implements(
-        IFAQTarget, IHasBugSupervisor, IHasIcon, IHasLogo,
-        IHasMugshot, ILaunchpadUsage, IProduct, IQuestionTarget)
+        IFAQTarget, IHasBugSupervisor, IHasCustomLanguageCodes, IHasIcon,
+        IHasLogo, IHasMugshot, ILaunchpadUsage, IProduct, IQuestionTarget)
 
     _table = 'Product'
 
@@ -964,10 +966,14 @@
         if bug_supervisor is not None:
             subscription = self.addBugSubscription(bug_supervisor, user)
 
-    def getCustomLanguageCode(self, language_code):
-        """See `IProduct`."""
-        return CustomLanguageCode.selectOneBy(
-            product=self, language_code=language_code)
+    def composeCustomLanguageCodeMatch(self):
+        """See `HasCustomLanguageCodesMixin`."""
+        return CustomLanguageCode.product == self
+
+    def createCustomLanguageCode(self, language_code, language):
+        """See `IHasCustomLanguageCodes`."""
+        return CustomLanguageCode(
+            product=self, language_code=language_code, language=language)
 
     def userCanEdit(self, user):
         """See `IProduct`."""
 
=== modified file 'lib/lp/translations/browser/configure.zcml'
--- lib/lp/translations/browser/configure.zcml	2009-10-31 12:03:43 +0000
+++ lib/lp/translations/browser/configure.zcml	2009-11-19 04:05:29 +0000
@@ -977,5 +977,50 @@
         name="+language-packs"
         template="../templates/distroseries-language-packs.pt"/>
 
+
+<!-- CustomLanguageCode -->
+
+    <browser:defaultView
+        for="lp.translations.interfaces.customlanguagecode.ICustomLanguageCode"
+        name="+index"
+        layer="canonical.launchpad.layers.TranslationsLayer"/>
+    <browser:url
+        for="lp.translations.interfaces.customlanguagecode.ICustomLanguageCode"
+        path_expression="string:+customcode/${language_code}"
+        attribute_to_parent="translation_target"
+        />
+    <browser:page
+        name="+index"
+        for="lp.translations.interfaces.customlanguagecode.ICustomLanguageCode"
+        permission="zope.Public"
+        class="lp.translations.browser.customlanguagecode.CustomLanguageCodeView"
+        template="../templates/customlanguagecode-index.pt"
+        layer="canonical.launchpad.layers.TranslationsLayer"/>
+
+    <browser:page
+        name="+remove"
+        for="lp.translations.interfaces.customlanguagecode.ICustomLanguageCode"
+        permission="launchpad.Admin"
+        class="lp.translations.browser.customlanguagecode.CustomLanguageCodeRemoveView"
+        template="../../app/templates/generic-edit.pt"
+        layer="canonical.launchpad.layers.TranslationsLayer"/>
+
+<!-- IHasCustomLanguageCodes -->
+
+    <browser:page
+        name="+custom-language-codes"
+        for="lp.translations.interfaces.customlanguagecode.IHasCustomLanguageCodes"
+        layer="canonical.launchpad.layers.TranslationsLayer"
+        class="lp.translations.browser.customlanguagecode.CustomLanguageCodesIndexView"
+        template="../templates/customlanguagecodes-index.pt"
+        permission="zope.Public"/>
+    <browser:page
+        name="+add-custom-language-code"
+        for="lp.translations.interfaces.customlanguagecode.IHasCustomLanguageCodes"
+        layer="canonical.launchpad.layers.TranslationsLayer"
+        class="lp.translations.browser.customlanguagecode.CustomLanguageCodeAddView"
+        template="../templates/customlanguagecode-add.pt"
+        permission="launchpad.Admin"/>
+
     </facet>
 </configure>
 
=== added file 'lib/lp/translations/browser/customlanguagecode.py'
--- lib/lp/translations/browser/customlanguagecode.py	1970-01-01 00:00:00 +0000
+++ lib/lp/translations/browser/customlanguagecode.py	2009-11-19 04:05:29 +0000
@@ -0,0 +1,171 @@
+# Copyright 2009 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+__metaclass__ = type
+
+__all__ = [
+    'CustomLanguageCodeAddView',
+    'CustomLanguageCodeBreadcrumb',
+    'CustomLanguageCodesIndexView',
+    'CustomLanguageCodeRemoveView',
+    'CustomLanguageCodeView',
+    'HasCustomLanguageCodesNavigation',
+    'HasCustomLanguageCodesTraversalMixin',
+	]
+
+
+import re
+
+from canonical.lazr.utils import smartquote
+
+from lp.translations.interfaces.customlanguagecode import (
+    ICustomLanguageCode, IHasCustomLanguageCodes)
+
+from canonical.launchpad.webapp import (
+    action, canonical_url, LaunchpadFormView, LaunchpadView, Navigation,
+    stepthrough)
+from canonical.launchpad.webapp.breadcrumb import Breadcrumb
+from canonical.launchpad.webapp.interfaces import NotFoundError
+from canonical.launchpad.webapp.menu import structured
+
+
+# Regex for allowable custom language codes.
+CODE_PATTERN = "[a-zA-Z0-9_-]+$"
+
+
+def check_code(custom_code):
+    """Is this custom language code well-formed?"""
+    return re.match(CODE_PATTERN, custom_code) is not None
+
+
+class CustomLanguageCodeBreadcrumb(Breadcrumb):
+    """Breadcrumb for a `CustomLanguageCode`."""
+    @property
+    def text(self):
+        return smartquote(
+            'Custom language code "%s"' % self.context.language_code)
+
+
+class CustomLanguageCodesIndexView(LaunchpadView):
+    """Listing of `CustomLanguageCode`s for a given context."""
+
+    page_title = "Custom language codes"
+
+    @property
+    def label(self):
+        return "Custom language codes for %s" % self.context.displayname
+
+
+class CustomLanguageCodeAddView(LaunchpadFormView):
+    """Create a new custom language code."""
+    schema = ICustomLanguageCode
+    field_names = ['language_code', 'language']
+    page_title = "Add new code"
+
+    create = False
+
+    @property
+    def label(self):
+        return (
+            "Add a custom language code for %s" % self.context.displayname)
+
+    def validate(self, data):
+        self.language_code = data.get('language_code')
+        self.language = data.get('language')
+        if self.language_code is not None:
+            self.language_code = self.language_code.strip()
+
+        if not self.language_code:
+            self.setFieldError('language_code', "No code was entered.")
+            return
+
+        if not check_code(self.language_code):
+            self.setFieldError('language_code', "Invalid language code.")
+            return
+
+        existing_code = self.context.getCustomLanguageCode(self.language_code)
+        if existing_code is not None:
+            if existing_code.language != self.language:
+                self.setFieldError(
+                    'language_code',
+                    structured(
+                        "There already is a custom language code '%s'." %
+                            self.language_code))
+                return
+        else:
+            self.create = True
+
+    @action('Add', name='add')
+    def add_action(self, action, data):
+        if self.create:
+            self.context.createCustomLanguageCode(
+                self.language_code, self.language)
+
+    @property
+    def action_url(self):
+        return "%s/+add-custom-language-code" % canonical_url(self.context)
+
+    @property
+    def next_url(self):
+        """See `LaunchpadFormView`."""
+        return "%s/+custom-language-codes" % canonical_url(self.context)
+
+    @property
+    def cancel_url(self):
+        return self.next_url
+
+
+class CustomLanguageCodeView(LaunchpadView):
+    schema = ICustomLanguageCode
+
+
+class CustomLanguageCodeRemoveView(LaunchpadFormView):
+    """View for removing a `CustomLanguageCode`."""
+    schema = ICustomLanguageCode
+    field_names = []
+
+    page_title = "Remove"
+
+    @property
+    def code(self):
+        """The custom code."""
+        return self.context.language_code
+
+    @property
+    def label(self):
+        return "Remove custom language code '%s'" % self.code
+
+    @action("Remove")
+    def remove(self, action, data):
+        """Remove this `CustomLanguageCode`."""
+        code = self.code
+        self.context.translation_target.removeCustomLanguageCode(self.context)
+        self.request.response.addInfoNotification(
+            "Removed custom language code '%s'." % code)
+
+    @property
+    def next_url(self):
+        return "%s/+custom-language-codes" % canonical_url(
+            self.context.translation_target)
+
+    @property
+    def cancel_url(self):
+        return self.next_url
+
+
+class HasCustomLanguageCodesTraversalMixin:
+    """Navigate from an `IHasCustomLanguageCodes` to a `CustomLanguageCode`.
+    """
+    @stepthrough('+customcode')
+    def traverseCustomCode(self, name):
+        """Traverse +customcode URLs."""
+        if not check_code(name):
+            raise NotFoundError("Invalid custom language code.")
+
+        return self.context.getCustomLanguageCode(name)
+
+
+class HasCustomLanguageCodesNavigation(Navigation,
+                                       HasCustomLanguageCodesTraversalMixin):
+    """Generic navigation for `IHasCustomLanguageCodes`."""
+    usedfor = IHasCustomLanguageCodes
 
=== modified file 'lib/lp/translations/configure.zcml'
--- lib/lp/translations/configure.zcml	2009-09-17 14:45:59 +0000
+++ lib/lp/translations/configure.zcml	2009-11-19 04:05:29 +0000
@@ -549,6 +549,11 @@
                 interface="lp.translations.interfaces.translationmessage.ITranslationMessageSet"/>
         </securedutility>
     </facet>
+    <adapter
+        provides="canonical.launchpad.webapp.interfaces.IBreadcrumb"
+        for="lp.translations.interfaces.customlanguagecode.ICustomLanguageCode"
+        factory="lp.translations.browser.customlanguagecode.CustomLanguageCodeBreadcrumb"
+        permission="zope.Public"/>
     <class
         class="lp.translations.model.customlanguagecode.CustomLanguageCode">
         <allow
 
=== modified file 'lib/lp/translations/interfaces/customlanguagecode.py'
--- lib/lp/translations/interfaces/customlanguagecode.py	2009-07-17 00:26:05 +0000
+++ lib/lp/translations/interfaces/customlanguagecode.py	2009-11-19 04:05:29 +0000
@@ -1,5 +1,6 @@
 # Copyright 2009 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
+# pylint: disable-msg=E0213
 
 """Custom language code."""
 
@@ -7,22 +8,76 @@
 
 __all__ = [
     'ICustomLanguageCode',
+    'IHasCustomLanguageCodes',
     ]
 
-from zope.interface import Interface, Attribute
-from zope.schema import Int, TextLine
+from zope.interface import Interface
+from zope.schema import Bool, Choice, Int, Object, Set, TextLine
+from zope.schema.interfaces import IObject
 
 from canonical.launchpad import _
 
+from lp.registry.interfaces.distribution import IDistribution
+from lp.registry.interfaces.product import IProduct
+from lp.registry.interfaces.sourcepackagename import ISourcePackageName
+
 
 class ICustomLanguageCode(Interface):
     """`CustomLanguageCode` interface."""
 
-    id = Int(title=_(u"ID"), required=True, readonly=True)
-    product = Attribute(_(u"Product"))
-    distribution = Attribute(_(u"Distribution"))
-    sourcepackagename = Attribute(_(u"Source package name"))
-    language_code = TextLine(title=_(u"Language code"), required=True,
-        description=_("Language code to treat as special."))
-    language = Attribute(_(u"Language"))
-
+    id = Int(title=_("ID"), required=True, readonly=True)
+    product = Object(
+        title=_("Product"), required=False, readonly=True, schema=IProduct)
+    distribution = Object(
+        title=_("Distribution"), required=False, readonly=True,
+        schema=IDistribution)
+    sourcepackagename = Object(
+        title=_("Source package name"), required=False, readonly=True,
+        schema=ISourcePackageName)
+    language_code = TextLine(title=_("Language code"),
+        description=_("Language code to treat as special."),
+        required=True, readonly=False)
+    language = Choice(
+        title=_("Language"), required=False, readonly=False,
+        vocabulary='Language',
+        description=_("Language to map this code to.  "
+            "Leave empty to drop translations for this code."))
+
+    # Reference back to the IHasCustomLanguageCodes.
+    translation_target = Object(
+        title=_("Context this custom language code applies to"),
+        required=True, readonly=True, schema=IObject)
+
+
+class IHasCustomLanguageCodes(Interface):
+    """A context that can have custom language codes attached.
+
+    Implemented by `Product` and `SourcePackage`.
+    """
+    custom_language_codes = Set(
+        title=_("Custom language codes"),
+        description=_("Translations for these language codes are re-routed."),
+        value_type=Object(schema=ICustomLanguageCode),
+        required=False, readonly=False)
+
+    has_custom_language_codes = Bool(
+        title=_("There are custom language codes in this context."),
+        readonly=True, required=True)
+
+    def getCustomLanguageCode(language_code):
+        """Retrieve `CustomLanguageCode` for `language_code`.
+
+        :return: a `CustomLanguageCode`, or None.
+        """
+
+    def createCustomLanguageCode(language_code, language):
+        """Create `CustomLanguageCode`.
+
+        :return: the new `CustomLanguageCode` object.
+        """
+
+    def removeCustomLanguageCode(language_code):
+        """Remove `CustomLanguageCode`.
+        
+        :param language_code: A `CustomLanguageCode` object.
+        """
 
=== modified file 'lib/lp/translations/model/customlanguagecode.py'
--- lib/lp/translations/model/customlanguagecode.py	2009-07-17 00:26:05 +0000
+++ lib/lp/translations/model/customlanguagecode.py	2009-11-19 04:05:29 +0000
@@ -5,14 +5,23 @@
 
 __metaclass__ = type
 
-__all__ = ['CustomLanguageCode']
-
+__all__ = [
+    'CustomLanguageCode',
+    'HasCustomLanguageCodesMixin',
+    ]
+
+
+from zope.interface import implements
 
 from sqlobject import ForeignKey, StringCol
-from zope.interface import implements
+from storm.expr import And
 
 from canonical.database.sqlbase import SQLBase
+from canonical.launchpad.interfaces.lpstorm import IStore
+
 from lp.translations.interfaces.customlanguagecode import ICustomLanguageCode
+
+
 class CustomLanguageCode(SQLBase):
     """See `ICustomLanguageCode`."""
 
@@ -32,3 +41,63 @@
     language = ForeignKey(
         dbName='language', foreignKey='Language', notNull=False, default=None)
 
+    @property
+    def translation_target(self):
+        """See `ICustomLanguageCode`."""
+        # Avoid circular imports
+        from lp.registry.model.distributionsourcepackage import (
+            DistributionSourcePackage)
+        if self.product:
+            return self.product
+        else:
+            return DistributionSourcePackage(
+                self.distribution, self.sourcepackagename)
+
+
+class HasCustomLanguageCodesMixin:
+    """Helper class to implement `IHasCustomLanguageCodes`."""
+
+    def composeCustomLanguageCodeMatch(self):
+        """Define in child: compose Storm match clause.
+
+        This should return a condition for use in a Storm query to match
+        `CustomLanguageCode` objects to `self`.
+        """
+        raise NotImplementedError("composeCustomLanguageCodeMatch")
+
+    def createCustomLanguageCode(self, language_code, language):
+        """Define in child.  See `IHasCustomLanguageCodes`."""
+        raise NotImplementedError("createCustomLanguageCode")
+
+    def _queryCustomLanguageCodes(self, language_code=None):
+        """Query `CustomLanguageCodes` belonging to `self`.
+
+        :param language_code: Optional custom language code to look for.
+            If not given, all codes will match.
+        :return: A Storm result set.
+        """
+        match = self.composeCustomLanguageCodeMatch()
+        store = IStore(CustomLanguageCode)
+        if language_code is not None:
+            match = And(
+                match, CustomLanguageCode.language_code == language_code)
+        return store.find(CustomLanguageCode, match)
+
+    @property
+    def has_custom_language_codes(self):
+        """See `IHasCustomLanguageCodes`."""
+        return self._queryCustomLanguageCodes().any() is not None
+
+    @property
+    def custom_language_codes(self):
+        """See `IHasCustomLanguageCodes`."""
+        return self._queryCustomLanguageCodes().order_by('language_code')
+
+    def getCustomLanguageCode(self, language_code):
+        """See `IHasCustomLanguageCodes`."""
+        return self._queryCustomLanguageCodes(language_code).one()
+
+    def removeCustomLanguageCode(self, custom_code):
+        """See `IHasCustomLanguageCodes`."""
+        language_code = custom_code.language_code
+        return self._queryCustomLanguageCodes(language_code).remove()
 
=== modified file 'lib/lp/translations/model/translationimportqueue.py'
--- lib/lp/translations/model/translationimportqueue.py	2009-11-18 11:45:59 +0000
+++ lib/lp/translations/model/translationimportqueue.py	2009-11-19 04:05:29 +0000
@@ -342,11 +342,12 @@
     def _findCustomLanguageCode(self, language_code):
         """Find applicable custom language code, if any."""
         if self.distroseries is not None:
-            return self.distroseries.distribution.getCustomLanguageCode(
-                self.sourcepackagename, language_code)
+            target = self.distroseries.distribution.getSourcePackage(
+                self.sourcepackagename)
         else:
-            return self.productseries.product.getCustomLanguageCode(
-                language_code)
+            target = self.productseries.product
+        
+        return target.getCustomLanguageCode(language_code)
 
     def _guessLanguage(self):
         """See ITranslationImportQueueEntry."""
 
=== added file 'lib/lp/translations/stories/standalone/custom-language-codes.txt'
--- lib/lp/translations/stories/standalone/custom-language-codes.txt	1970-01-01 00:00:00 +0000
+++ lib/lp/translations/stories/standalone/custom-language-codes.txt	2009-11-19 04:05:29 +0000
@@ -0,0 +1,276 @@
+Custom Language Codes
+---------------------
+
+Some projects insist on using nonstandard language codes, such as es_ES
+for standard Spanish or pt-BR instead of pt_BR.  Custom language codes
+are a feature that helps deal with this during translation import.  A
+custom language code maps a language code as the project (or package)
+uses it to a language, regardless of whether the code is for an existing
+language or not.
+
+Custom language codes are attached to either a product or a source
+package.
+
+    >>> import re
+    >>> from zope.component import getUtility
+    >>> from zope.security.proxy import removeSecurityProxy
+    >>> from canonical.launchpad.interfaces.launchpad import (
+    ...     ILaunchpadCelebrities)
+
+    >>> def find_custom_language_codes_link(browser):
+    ...     """Find reference to custom language codes on a page."""
+    ...     return find_tag_by_id(browser.contents, 'custom-language-codes')
+
+    >>> login(ANONYMOUS)
+    >>> owner = factory.makePerson(email='[e-mail]', password='test')
+    >>> rosetta_admin = factory.makePerson(
+    ...     email='[e-mail]', password='test')
+    >>> rosetta_admin.join(getUtility(ILaunchpadCelebrities).rosetta_experts)
+    >>> product = factory.makeProduct(displayname="Foo", owner=owner)
+    >>> trunk = product.getSeries('trunk')
+    >>> removeSecurityProxy(product).official_rosetta = True
+    >>> template = factory.makePOTemplate(productseries=trunk)
+    >>> product_page = canonical_url(product, rootsite='translations')
+    >>> logout()
+
+    >>> owner_browser = setupBrowser("Basic [e-mail]:test")
+
+An administrator sees the link to the custom language codes on a
+project's main translations page.
+
+    >>> admin_browser.open(product_page)
+    >>> tag = find_custom_language_codes_link(admin_browser)
+    >>> print extract_text(tag.renderContents())
+    If necessary, you may
+    define custom language codes
+    for this project.
+
+The link goes to the custom language codes management page.
+
+    >>> admin_browser.getLink("define custom language codes").click()
+    >>> custom_language_codes_page = admin_browser.url
+
+Non-admins, even the project's owner, don't see this link.  We do not
+advertise this feature, since the proper solution is generally to use
+the right language codes.
+
+    >>> owner_browser.open(product_page)
+    >>> print find_custom_language_codes_link(owner_browser)
+    None
+
+Initially the page shows no custom language codes for the project.
+
+    >>> tag = find_tag_by_id(admin_browser.contents, 'empty')
+    >>> print extract_text(tag.renderContents())
+    No custom language codes have been defined.
+
+The admin can add a custom language code.
+
+    >>> admin_browser.getLink("Add a custom language code").click()
+    >>> add_page = admin_browser.url
+
+    >>> admin_browser.getControl("Language code:").value = 'no'
+    >>> admin_browser.getControl("Language:").value = ['nn']
+    >>> admin_browser.getControl("Add").click()
+
+This leads back to the custom language codes overview, where the new
+code is now shown.
+
+    >>> admin_browser.url == custom_language_codes_page
+    True
+
+    >>> tag = find_tag_by_id(admin_browser.contents, 'nonempty')
+    >>> print extract_text(tag.renderContents())
+    Foo uses the following custom language codes:
+    Code...     ...maps to language
+    no          Norwegian Nynorsk
+
+There is an overview page for the custom code, though there's not much
+to see there.
+
+    >>> admin_browser.getLink("no").click()
+    >>> main = find_main_content(admin_browser.contents)
+    >>> print extract_text(main.renderContents())
+    Foo Translations Custom language code ...no...
+    For Foo, uploads with the language code
+    &ldquo;no&rdquo;
+    are associated with the language
+    Norwegian Nynorsk.
+    remove custom language code
+    custom language codes overview
+
+The overview page leads back to the custom language codes overview.
+
+    >>> code_page = admin_browser.url
+    >>> admin_browser.getLink("custom language codes overview").click()
+    >>> admin_browser.url == custom_language_codes_page
+    True
+
+    >>> admin_browser.open(code_page)
+
+There is also a link for removing codes.  The admin follows the link and
+removes the "no" custom language code.
+
+    >>> admin_browser.getLink("remove custom language code").click()
+    >>> remove_page = admin_browser.url
+    >>> admin_browser.getControl("Remove").click()
+
+This leads back to the overview page.
+
+    >>> admin_browser.url == custom_language_codes_page
+    True
+
+    >>> tag = find_tag_by_id(admin_browser.contents, 'empty')
+    >>> print extract_text(tag.renderContents())
+    No custom language codes have been defined.
+
+
+Non-admin access
+================
+
+A non-admin can see the page, actually, if they know the URL.  This can
+be convenient for debugging.
+
+    >>> owner_browser.open(custom_language_codes_page)
+
+    >>> tag = find_tag_by_id(owner_browser.contents, 'empty')
+    >>> print extract_text(tag.renderContents())
+    No custom language codes have been defined.
+
+However all they get is a read-only version of the page.
+
+    >>> owner_browser.getLink("Add a custom language code").click()
+    Traceback (most recent call last):
+    ...
+    LinkNotFoundError
+
+The page for adding custom language codes is not accessible to them.
+
+    >>> owner_browser.open(add_page)
+    Traceback (most recent call last):
+    ...
+    Unauthorized: ...
+
+And naturally, if an admin creates a custom language code again, a
+non-admin can't remove it.
+
+    >>> admin_browser.open(add_page)
+    >>> admin_browser.getControl("Language code:").value = 'no'
+    >>> admin_browser.getControl("Language:").value = ['nn']
+    >>> admin_browser.getControl("Add").click()
+
+    >>> owner_browser.open(custom_language_codes_page)
+    >>> tag = find_tag_by_id(owner_browser.contents, 'nonempty')
+    >>> print extract_text(tag.renderContents())
+    Foo uses the following custom language codes:
+    Code...     ...maps to language
+    no          Norwegian Nynorsk
+
+    >>> owner_browser.getLink("no").click()
+    >>> owner_browser.getLink("remove custom language code")
+    Traceback (most recent call last):
+    ...
+    LinkNotFoundError
+
+    >>> owner_browser.open(remove_page)
+    Traceback (most recent call last):
+    ...
+    Unauthorized: ...
+
+
+Source packages
+===============
+
+The story for source packages is very similar to that for products.  In
+this case, the custom language code is tied to the distribution source
+package--i.e. the combination of a distribution and a source package
+name.  However, since there is no Translations page for that type of
+object (and we'd probably never go there if there were), the link is
+shown on the source package page.
+
+    >>> login(ANONYMOUS)
+    >>> from lp.registry.model.sourcepackage import SourcePackage
+    >>> from lp.registry.model.sourcepackagename import SourcePackageName
+
+    >>> distro = factory.makeDistribution('distro')
+    >>> distroseries = factory.makeDistroRelease(distribution=distro)
+    >>> sourcepackagename = SourcePackageName(name='bar')
+    >>> package = factory.makeSourcePackage(
+    ...     sourcepackagename=sourcepackagename, distroseries=distroseries)
+    >>> removeSecurityProxy(distro).official_rosetta = True
+    >>> other_series = factory.makeDistroRelease(distribution=distro)
+    >>> template = factory.makePOTemplate(
+    ...     distroseries=package.distroseries,
+    ...     sourcepackagename=package.sourcepackagename)
+    >>> package_page = canonical_url(package, rootsite="translations")
+    >>> page_in_other_series = canonical_url(SourcePackage(
+    ...     distroseries=other_series,
+    ...     sourcepackagename=package.sourcepackagename),
+    ...     rootsite="translations")
+    >>> logout()
+
+    >>> admin_browser.open(package_page)
+
+Of course in this case, the notice about there being no custom language
+codes talks about a package, not a project.
+
+    >>> tag = find_custom_language_codes_link(admin_browser)
+    >>> print extract_text(tag.renderContents())
+    If necessary, you may
+    define custom language codes
+    for this package.
+
+    >>> admin_browser.getLink("define custom language codes").click()
+    >>> custom_language_codes_page = admin_browser.url
+
+    >>> tag = find_tag_by_id(admin_browser.contents, 'empty')
+    >>> print extract_text(tag.renderContents())
+    No custom language codes have been defined.
+
+Again, an admin can add a language code.
+
+    >>> admin_browser.getLink("Add a custom language code").click()
+    >>> add_page = admin_browser.url
+
+    >>> admin_browser.getControl("Language code:").value = 'pt-br'
+    >>> admin_browser.getControl("Language:").value = ['pt_BR']
+    >>> admin_browser.getControl("Add").click()
+
+The language code is displayed.
+
+    >>> tag = find_tag_by_id(admin_browser.contents, 'nonempty')
+    >>> print extract_text(tag.renderContents())
+    bar in distro uses the following custom language codes:
+    Code...     ...maps to language
+    pt-br       Portuguese (Brazil)
+
+It's also displayed identically on the same package but in another
+release series of the same distribution.
+
+    >>> admin_browser.open(page_in_other_series)
+    >>> tag = find_custom_language_codes_link(admin_browser)
+    >>> print extract_text(tag.renderContents())
+    If necessary, you may
+    define custom language codes
+    for this package.
+
+    >>> admin_browser.getLink("define custom language codes").click()
+    >>> tag = find_tag_by_id(admin_browser.contents, 'nonempty')
+    >>> print extract_text(tag.renderContents())
+    bar in distro uses the following custom language codes:
+    Code...     ...maps to language
+    pt-br       Portuguese (Brazil)
+
+
+The new code has a link there...
+
+    >>> admin_browser.getLink("pt-br").click()
+
+...and can be deleted.
+
+    >>> admin_browser.getLink("remove custom language code").click()
+    >>> admin_browser.getControl("Remove").click()
+
+    >>> tag = find_tag_by_id(admin_browser.contents, 'empty')
+    >>> print extract_text(tag.renderContents())
+    No custom language codes have been defined.
 
=== added file 'lib/lp/translations/templates/customlanguagecode-add.pt'
--- lib/lp/translations/templates/customlanguagecode-add.pt	1970-01-01 00:00:00 +0000
+++ lib/lp/translations/templates/customlanguagecode-add.pt	2009-11-19 04:05:29 +0000
@@ -0,0 +1,29 @@
+<html
+  xmlns="http://www.w3.org/1999/xhtml"
+  xmlns:tal="http://xml.zope.org/namespaces/tal"
+  xmlns:metal="http://xml.zope.org/namespaces/metal"
+  xmlns:i18n="http://xml.zope.org/namespaces/i18n"
+  metal:use-macro="view/macro:page/main_only"
+  i18n:domain="launchpad">
+
+<body>
+  <div metal:fill-slot="main">
+    <div metal:use-macro="context/@@launchpad_form/form">
+      <metal:extra-info metal:fill-slot="extra_info">
+        <p>
+          Enter a language code, and select what language it should map
+          to during upload auto-approval.
+         </p>
+         <p>
+          Avoid using this capability if possible, since it makes
+          it harder to keep track of what goes where.  For cases with
+          few templates, where a code would only cover one or two
+          translation files, it may be better to approve those
+          uploads manually.  Launchpad will remember the filename and
+          approve it automatically next time it comes along.
+        </p>
+      </metal:extra-info>
+    </div>
+  </div>
+</body>
+</html>
 
=== added file 'lib/lp/translations/templates/customlanguagecode-index.pt'
--- lib/lp/translations/templates/customlanguagecode-index.pt	1970-01-01 00:00:00 +0000
+++ lib/lp/translations/templates/customlanguagecode-index.pt	2009-11-19 04:05:29 +0000
@@ -0,0 +1,46 @@
+<html
+  xmlns="http://www.w3.org/1999/xhtml"
+  xmlns:tal="http://xml.zope.org/namespaces/tal"
+  xmlns:metal="http://xml.zope.org/namespaces/metal"
+  xmlns:i18n="http://xml.zope.org/namespaces/i18n"
+  metal:use-macro="view/macro:page/main_only"
+  i18n:domain="launchpad"
+  >
+<body>
+  <div metal:fill-slot="main">
+    <div class="top-portlet">
+      For
+      <tal:target replace="context/translation_target/displayname">
+        Evolution</tal:target>,
+      uploads with the language code
+      &ldquo;<strong tal:content="context/language_code">pt-BR</strong>&rdquo;
+      <tal:language condition="context/language">
+        are associated with the language
+        <a tal:replace="structure context/language/fmt:link">
+            Brazilian Portuguese</a>.
+      </tal:language>
+      <tal:no-language condition="not: context/language">
+        are ignored.
+      </tal:no-language>
+    </div>
+
+    <div class="portlet">
+      <ul class="horizontal">
+        <li tal:condition="context/required:launchpad.Admin">
+          <a class="remove sprite"
+             tal:attributes="href context/fmt:url/+remove">
+            remove custom language code
+          </a>
+        </li>
+        <li>
+          <a class="info sprite"
+             tal:attributes="href context/translation_target/fmt:url/+custom-language-codes">
+            custom language codes overview
+          </a>
+        </li>
+      </ul>
+    </div>
+  </div>
+</body>
+</html>
+
 
=== added file 'lib/lp/translations/templates/customlanguagecodes-index.pt'
--- lib/lp/translations/templates/customlanguagecodes-index.pt	1970-01-01 00:00:00 +0000
+++ lib/lp/translations/templates/customlanguagecodes-index.pt	2009-11-19 04:05:29 +0000
@@ -0,0 +1,80 @@
+<html
+  xmlns="http://www.w3.org/1999/xhtml"
+  xmlns:tal="http://xml.zope.org/namespaces/tal"
+  xmlns:metal="http://xml.zope.org/namespaces/metal"
+  xmlns:i18n="http://xml.zope.org/namespaces/i18n"
+  metal:use-macro="view/macro:page/main_only"
+  i18n:domain="launchpad"
+  >
+<body>
+  <div metal:fill-slot="main">
+    <div class="top-portlet">
+      <p>
+        You can define custom language codes for
+        <tal:target replace="structure context/displayname">Evolution</tal:target>
+        here.  Custom language codes will be treated like proper
+        language codes by translations imports, except each is
+        associated with a language you choose.
+      </p>
+      <p>
+        Avoid doing this if possible; it makes it harder to keep track
+        of what goes where during translations import, and why.
+      </p>
+    </div>
+    <div tal:condition="context/has_custom_language_codes"
+         class="portlet"
+         id="nonempty">
+      <p>
+        <tal:block replace="context/displayname">Evolution</tal:block>
+        uses the following custom language codes:
+      </p>
+      <table class="listing" style="max-width:800px">
+        <thead>
+          <tr>
+            <th>Code...</th>
+            <th>...maps to language</th>
+            <th tal:condition="context/required:launchpad.Admin"></th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr tal:repeat="entry context/custom_language_codes">
+            <td align="center">
+              <a tal:attributes="href entry/fmt:url"
+                 tal:content="entry/language_code">pt-PT</a>
+            </td>
+            <td>
+              <a tal:condition="entry/language"
+                 tal:replace="structure entry/language/fmt:link">
+                Portuguese (pt)
+              </a>
+              <tal:nolanguage condition="not: entry/language">
+                &mdash;
+              </tal:nolanguage>
+            </td>
+            <td tal:condition="context/required:launchpad.Admin">
+              <a tal:attributes="href entry/fmt:url/+remove"
+                 alt="Remove"
+                 title="Remove"
+                 class="remove sprite"></a>
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+
+    <p tal:condition="not: context/has_custom_language_codes"
+         class="portlet"
+         id="empty">
+      No custom language codes have been defined.
+    </p>
+
+    <div>
+      <a tal:attributes="href context/fmt:url/+add-custom-language-code"
+         tal:condition="context/required:launchpad.Admin"
+         class="add sprite">
+        Add a custom language code
+      </a>
+    </div>
+  </div>
+</body>
+</html>
 
=== modified file 'lib/lp/translations/templates/product-portlet-translatables.pt'
--- lib/lp/translations/templates/product-portlet-translatables.pt	2009-10-31 12:03:43 +0000
+++ lib/lp/translations/templates/product-portlet-translatables.pt	2009-11-19 04:05:29 +0000
@@ -63,4 +63,16 @@
   </div>
 
 </div>
+
+<div class="portlet"
+     tal:condition="context/required:launchpad.Admin"
+     id="custom-language-codes">
+  If necessary, you may
+  <a tal:attributes="href context/fmt:url/+custom-language-codes"
+     class="edit sprite">
+    define custom language codes
+  </a>
+  for this project.
+</div>
+
 </tal:root>
 
=== modified file 'lib/lp/translations/templates/sourcepackage-translations.pt'
--- lib/lp/translations/templates/sourcepackage-translations.pt	2009-09-25 16:07:06 +0000
+++ lib/lp/translations/templates/sourcepackage-translations.pt	2009-11-19 04:05:29 +0000
@@ -39,6 +39,15 @@
               <a tal:attributes="href context/menu:navigation/download/url">
                 download a full tarball</a> with translations.
             </p>
+            <p tal:condition="context/required:launchpad.Admin"
+               id="custom-language-codes">
+              If necessary, you may
+              <a tal:attributes="href context/distribution_sourcepackage/fmt:url/+custom-language-codes"
+                 class="edit sprite">
+                define custom language codes
+              </a>
+              for this package.
+            </p>
           </div>
         </div>
       </div>
 
=== modified file 'lib/lp/translations/tests/test_autoapproval.py'
--- lib/lp/translations/tests/test_autoapproval.py	2009-11-17 09:50:33 +0000
+++ lib/lp/translations/tests/test_autoapproval.py	2009-11-19 04:05:29 +0000
@@ -89,26 +89,23 @@
         self.assertEqual(fresh_product.getCustomLanguageCode('pt_PT'), None)
 
         fresh_distro = Distribution.byName('gentoo')
-        nocode = fresh_distro.getCustomLanguageCode(
-            self.sourcepackagename, 'nocode')
+        gentoo_package = fresh_distro.getSourcePackage(self.sourcepackagename)
+        nocode = gentoo_package.getCustomLanguageCode('nocode')
         self.assertEqual(nocode, None)
-        brazilian = fresh_distro.getCustomLanguageCode(
-            self.sourcepackagename, 'Brazilian')
+        brazilian = gentoo_package.getCustomLanguageCode('Brazilian')
         self.assertEqual(brazilian, None)
 
-        fresh_package = SourcePackageName.byName('cnews')
-        self.assertEqual(self.distro.getCustomLanguageCode(
-            fresh_package, 'nocode'), None)
-        self.assertEqual(self.distro.getCustomLanguageCode(
-            fresh_package, 'Brazilian'), None)
+        cnews = SourcePackageName.byName('cnews')
+        cnews_package = self.distro.getSourcePackage(cnews)
+        self.assertEqual(cnews_package.getCustomLanguageCode('nocode'), None)
+        self.assertEqual(
+            cnews_package.getCustomLanguageCode('Brazilian'), None)
 
     def test_UnsuccessfulCustomLanguageCodeLookup(self):
         # Look up nonexistent custom language code for product.
         self.assertEqual(self.product.getCustomLanguageCode('nocode'), None)
-        self.assertEqual(
-            self.distro.getCustomLanguageCode(
-                self.sourcepackagename, 'nocode'),
-            None)
+        package = self.distro.getSourcePackage(self.sourcepackagename)
+        self.assertEqual(package.getCustomLanguageCode('nocode'), None)
 
     def test_SuccessfulProductCustomLanguageCodeLookup(self):
         # Look up custom language code.
@@ -122,8 +119,8 @@
 
     def test_SuccessfulPackageCustomLanguageCodeLookup(self):
         # Look up custom language code.
-        Brazilian_code = self.distro.getCustomLanguageCode(
-            self.sourcepackagename, 'Brazilian')
+        package = self.distro.getSourcePackage(self.sourcepackagename)
+        Brazilian_code = package.getCustomLanguageCode('Brazilian')
         self.assertEqual(Brazilian_code, self.package_codes['Brazilian'])
         self.assertEqual(Brazilian_code.product, None)
         self.assertEqual(Brazilian_code.distribution, self.distro)