Issue 3047 - Change default search engines

mozharness/abb/transform_locales.py

 # This file is part of Adblock Plus
 # Copyright (C) 2006-2015 Eyeo GmbH
 #
 # Adblock Plus is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 3 as
 # published by the Free Software Foundation.
 #
 # Adblock Plus is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
 
 import os
 import re
 
 _LOCALE_RE = re.compile("^[a-z]{2}(-[A-Z]{2})?$")
 _SEARCH_PROPS_RE = re.compile("^browser\.search\."
                               "(defaultenginename|order\.).*$")
-_SHORTNAME_RE = re.compile("^<ShortName>.*</ShortName>$")
+_SHORTNAME_RE = re.compile("^<ShortName>(.*)</ShortName>$")
 
 _SEARCHPLUGINS_PATH = os.path.join("browser", "searchplugins")
 _LIST_TXT_PATH = os.path.join(_SEARCHPLUGINS_PATH, "list.txt")
 _REGION_PROPS_PATH = os.path.join("browser", "region.properties")
 
 _DEFAULT_LOCALE = "en-US"
 
 _SEARCH_ENGINE_ORDER = {
     "en-US": ["duckduckgo",
               "yahoo",
               "google",
               "wikipedia",
-              "amazon"],
+              "amazon"
+              ],
     "zh-CN": ["baidu",
               "duckduckgo",
               "yahoo",
               "google",
               "wikipedia",
-              "amazon"]
+              "amazon"
+              ]
 }
 
 
 def _get_shortname_from_id(needle, engine_ids, engine_names):
     """Fuzzy finds needle in engine_ids and returns ShortName"""
-    regex = re.compile("^%s.*$" % needle)
     for engine in engine_ids:
-        if regex.match(engine.lower()):
+        if engine.startswith(needle):
             return engine_names[engine]
     return None
 
 
 def _write_lines(filename, lines):
     """Writes lines into file appending \\n"""
     with open(filename, "w") as fd:
         for l in lines:
             fd.write("%s\n" % l)
 
 
-def _transform_locale(locale, path, fns):
-    fns["info"]("Processing locale '%s'..." % locale)
+def _transform_locale(locale, path, logger):
+    logger.info("Processing locale '%s'..." % locale)
 
     # Check for list.txt existence
     list_file_path = os.path.join(path, _LIST_TXT_PATH)
     if not os.path.exists(list_file_path):
-        fns["fatal"]("Missing 'list.txt' for locale '%s'" % locale)
+        logger.fatal("Missing 'list.txt' for locale '%s'" % locale)
 
     # Check for region.properties existence
     region_file_path = os.path.join(path, _REGION_PROPS_PATH)
     if not os.path.exists(region_file_path):
-        fns["fatal"]("Missing 'region.properties' for locale '%s'" % locale)
+        logger.fatal("Missing 'region.properties' for locale '%s'" % locale)
 
     # Get whitelist and build regex
     whitelist = _SEARCH_ENGINE_ORDER.get(locale,
                                          _SEARCH_ENGINE_ORDER[_DEFAULT_LOCALE])
     white_re = re.compile("^(%s).*$" % "|".join(whitelist))
 
     # Read engine IDs from list.txt, discard engines not on whitelist
     engine_ids = []
     with open(list_file_path, "r") as fd:
         for line in fd:
             line = line.strip()
             if len(line) > 0:
-                if white_re.match(line.lower()):
+                if white_re.match(line):
                     engine_ids.append(line)
                 else:
-                    fns["info"]("Removing '%s'" % line)
+                    logger.info("Removing '%s'" % line)
 
     # Make sure we still have search engines left
     if len(engine_ids) == 0:
-        fns["fatal"]("No search engines left over for '%s'" % locale)
+        logger.fatal("No search engines left over for '%s'" % locale)
 
     # 'Parse' XML to get matching 'ShortName' for all engine IDs
     engine_names = {}
     for eid in engine_ids:
         xml_file_path = os.path.join(path, _SEARCHPLUGINS_PATH, "%s.xml" % eid)
         if os.path.exists(xml_file_path):
             short_name = None
             with open(xml_file_path, "r") as fd:
                 for line in fd:
                     line = line.strip()
-                    if _SHORTNAME_RE.match(line):
-                        short_name = line[11:-12].trim()
+                    match = _SHORTNAME_RE.match(line)
+                    if match:
+                        short_name = match.group(1).strip()
 
             if not short_name:
-                fns["fatal"]("No ShortName defined for '%s' in '%s" %
+                logger.fatal("No ShortName defined for '%s' in '%s" %
                              (eid, locale))
             engine_names[eid] = short_name
         else:
-            fns["fatal"]("XML definiton for '%s' in '%s' missing" %
+            logger.fatal("XML definiton for '%s' in '%s' missing" %
                          (eid, locale))
 
-    fns["info"]("Remaining engine IDs: %s" % ", ".join(engine_ids))
+    logger.info("Remaining engine IDs: %s" % ", ".join(engine_ids))
 
     # Create search engine order with real engine names
     engine_order = []
     for eid in whitelist:
         sn = _get_shortname_from_id(eid, engine_ids, engine_names)
         if sn:
             engine_order.append(sn)
 
-    fns["info"]("Resulting ordered list: %s" % (", ".join(engine_order)))
+    logger.info("Resulting ordered list: %s" % (", ".join(engine_order)))
 
     # Read region.properties and remove browser.search.* lines
     props = []
     with open(region_file_path, "r") as fd:
         for line in fd:
             line = line.rstrip("\r\n")
             if not _SEARCH_PROPS_RE.match(line.strip()):
                 props.append(line)
 
     # Append default search engine name
     props.append("browser.search.defaultenginename=%s" % engine_order[0])
 
     # Append search engine order
     for i in range(0, min(3, len(engine_order))):
         props.append("browser.search.order.%d=%s" % (i + 1, engine_order[i]))
 
     # Write back list.txt
     _write_lines(list_file_path, engine_ids)
 
     # Write back region.properties
     _write_lines(region_file_path, props)
 
 
-def _print_info(obj):
-    """ Wrapper for 'self.info' (to be self-contained) """
-    def fn(s):
-        if obj:
-            obj.info(s)
-        else:
-            print "INFO: %s" % s
-    return fn
+class MinimalLogger:
+    def info(self, s):
+        print "INFO: %s" % s
+
+    def error(self, s):
+        print "ERROR: %s" % s
+
+    def fatal(self, s):
+        print "FATAL: %s" % s
+        exit(1)
 
 
-def _print_error(obj):
-    """ Wrapper for 'self.error' (to be self-contained) """
-    def fn(s):
-        if obj:
-            obj.error(s)
-        else:
-            print "ERROR: %s" % s
-    return fn
-
-
-def _exit_fatal(obj):
-    """ Wrapper for 'self.fatal' (to be self-contained) """
-    def fn(s):
-        if obj:
-            obj.fatal(s)
-        else:
-            print "FATAL: %s" % s
-            exit(1)
-    return fn
-
-
-def transform_locales(build_object, obj_dir):
-    fns = {"info": _print_info(build_object),
-           "error": _print_error(build_object),
-           "fatal": _exit_fatal(build_object)}
-
+def transform_locales(obj_dir, logger=MinimalLogger()):
     chrome_path = os.path.join(obj_dir, "dist", "bin", "chrome")
     if not os.path.exists(chrome_path):
-        fns["fatal"]("'%s' does not exist" % obj_dir)
+        logger.fatal("'%s' does not exist" % obj_dir)
 
     locales = []
     for p in next(os.walk(chrome_path))[1]:
         if _LOCALE_RE.match(p):
             locales.append(p)
     locales.sort()
 
-    fns["info"]("Found %d locales" % len(locales))
+    logger.info("Found %d locales" % len(locales))
 
     for locale in locales:
         locale_path = os.path.join(chrome_path, locale, "locale", locale)
         if os.path.exists(locale_path):
-            _transform_locale(locale, locale_path, fns)
+            _transform_locale(locale, locale_path, logger)
         else:
-            fns["error"]("Missing 'locale' folder for '%s'" % locale)
+            logger.error("Missing 'locale' folder for '%s'" % locale)