Issue 5996 - Release consistent versions across WebExtensions

build.py

 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 import argparse
 import logging
 import os
 import re
 import shutil
 import subprocess
 import sys
 from functools import partial
 from StringIO import StringIO
 from zipfile import ZipFile
+from buildtools.localeTools import read_locale_config
 
 KNOWN_PLATFORMS = {'chrome', 'gecko', 'edge', 'generic'}
 
 MAIN_PARSER = argparse.ArgumentParser(
     description=__doc__,
     formatter_class=argparse.RawDescriptionHelpFormatter)
 
 SUB_PARSERS = MAIN_PARSER.add_subparsers(title='Commands', dest='action',
                                          metavar='[command]')
 
 ALL_COMMANDS = []
 
 
 def make_argument(*args, **kwargs):
     def _make_argument(*args, **kwargs):
         parser = kwargs.pop('parser')
         parser.add_argument(*args, **kwargs)
 
     return partial(_make_argument, *args, **kwargs)
 
 
-def argparse_command(valid_platforms=None, arguments=()):
+def argparse_command(valid_platforms=None, multi_platform=False, arguments=()):
     def wrapper(func):
         def func_wrapper(*args, **kwargs):
             return func(*args, **kwargs)
 
         short_desc, long_desc = func.__doc__.split(os.linesep + os.linesep, 1)
 
         ALL_COMMANDS.append({
             'name': func.__name__,
             'description': long_desc,
             'help_text': short_desc,
             'valid_platforms': valid_platforms or KNOWN_PLATFORMS,
+            'multi_platform': multi_platform,
             'function': func,
             'arguments': arguments,
         })
         return func_wrapper
-
     return wrapper
 
 
 def make_subcommand(name, description, help_text, function, arguments):
     new_parser = SUB_PARSERS.add_parser(
         name, description=description, help=help_text,
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
 
     for argument in arguments:
@@ skipping 23 matching lines @@
             types.add(p)
 
     if len(types) == 0:
         logging.error('No metadata file found in this repository. Expecting '
                       'one or more of {} to be present.'.format(
                           ', '.join('metadata.' + p for p in KNOWN_PLATFORMS)))
         build_available_subcommands._result = False
         return False
 
     for command_params in ALL_COMMANDS:
+        multi_platform = command_params.pop('multi_platform')
         platforms = types.intersection(command_params.pop('valid_platforms'))
         if len(platforms) > 1:
+            if multi_platform:
+                help_text = ('Multiple types may be specifed (each preceded '
+                             'by -t/--type)')
+                action = 'append'
+            else:
+                help_text = None
+                action = 'store'
+
             command_params['arguments'] += (
                 make_argument('-t', '--type', dest='platform', required=True,
-                              choices=platforms),
+                              choices=platforms, action=action,
+                              help=help_text),
             )
             make_subcommand(**command_params)
         elif len(platforms) == 1:
             sub_parser = make_subcommand(**command_params)
             sub_parser.set_defaults(platform=platforms.pop())
 
     build_available_subcommands._result = True
     return True
 
 
@@ skipping 61 matching lines @@
     from buildtools.packager import getDevEnvPath
     devenv_dir = getDevEnvPath(base_dir, platform)
 
     shutil.rmtree(devenv_dir, ignore_errors=True)
 
     file.seek(0)
     with ZipFile(file, 'r') as zip_file:
         zip_file.extractall(devenv_dir)
 
 
-def read_locale_config(base_dir, platform, metadata):
-    if platform != 'generic':
-        import buildtools.packagerChrome as packager
-        locale_dir = os.path.join(base_dir, '_locales')
-        locale_config = {
-            'default_locale': packager.defaultLocale,
-        }
-    else:
-        locale_dir = os.path.join(
-            base_dir, *metadata.get('locales', 'base_path').split('/')
-        )
-        locale_config = {
-            'default_locale': metadata.get('locales', 'default_locale')
-        }
-
-    locale_config['base_path'] = locale_dir
-
-    locales = [(locale.replace('_', '-'), os.path.join(locale_dir, locale))
-               for locale in os.listdir(locale_dir)]
-    locale_config['locales'] = dict(locales)
-
-    return locale_config
-
-
 project_key_argument = make_argument(
     'project_key', help='The crowdin project key.'
 )
 
 
 @argparse_command(
     arguments=(project_key_argument, )
 )
 def setuptrans(base_dir, project_key, platform, **kwargs):
     """
@@ skipping 115 matching lines @@
 
 
 def valid_version_format(value):
     if re.search(r'[^\d\.]', value):
         raise argparse.ArgumentTypeError('Wrong version number format')
 
     return value
 
 
 @argparse_command(
-    valid_platforms={'chrome', 'edge'},
+    valid_platforms={'chrome', 'gecko', 'edge'}, multi_platform=True,
     arguments=(
         make_argument(
             '-k', '--key', dest='key_file',
             help=('File containing private key and certificates required to '
                   'sign the release.')),
         make_argument(
             '-d', '--downloads-repository', dest='downloads_repository',
             help=('Directory containing downloads repository (if omitted '
                   '../downloads is assumed)')),
         make_argument(
             'version', help='Version number of the release',
             type=valid_version_format)
     )
 )
 def release(base_dir, downloads_repository, key_file, platform, version,
             **kwargs):
     """
     Run release automation.
 
     Note: If you are not the project owner then you probably don't want to run
     this!
 
     Run release automation: create downloads for the new version, tag source
     code repository as well as downloads and buildtools repository.
     """
     if downloads_repository is None:
         downloads_repository = os.path.join(base_dir, os.pardir, 'downloads')
 
-    if platform == 'chrome' and key_file is None:
+    if 'chrome' in platform and key_file is None:
         logging.error('You must specify a key file for this release')
         return
 
     import buildtools.releaseAutomation as releaseAutomation
     releaseAutomation.run(base_dir, platform, version, key_file,
                           downloads_repository)
 
 
 @argparse_command(valid_platforms={'chrome'})
 def updatepsl(base_dir, **kwargs):
@@ skipping 10 matching lines @@
     if build_available_subcommands(base_dir):
         MAIN_PARSER.set_defaults(base_dir=base_dir)
 
         # If no args are provided, this module is run directly from the command
         # line. argparse will take care of consuming sys.argv.
         arguments = MAIN_PARSER.parse_args(args if len(args) > 0 else None)
 
         function = arguments.function
         del arguments.function
         function(**vars(arguments))