Noissue - Adapt quotes for compliance with our coding style in sitescripts

sitescripts/extensions/bin/createNightlies.py

 # This file is part of the Adblock Plus web scripts,
 # Copyright (C) 2006-2016 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
@@ skipping 79 matching lines @@
         """
           retrieve changes between the current and previous ("first") revision
         """
 
         command = ['hg', 'log', '-R', self.config.repository, '-r', 'tip:0',
                    '-b', 'default', '-l', '50', '--encoding', 'utf-8',
                    '--template', '{date|isodate}\\0{author|person}\\0{rev}\\0{desc}\\0\\0',
                    '--config', 'defaults.log=']
         result = subprocess.check_output(command).decode('utf-8')
 
-        for change in result.split('\0\0'):
+        for change in result.split('\x00\x00'):
             if change:
-                date, author, revision, description = change.split('\0')
+                date, author, revision, description = change.split('\x00')
                 yield {'date': date, 'author': author, 'revision': revision, 'description': description}
 
     def copyRepository(self):
-        '''
+        """
           Create a repository copy in a temporary directory
-        '''
+        """
         # We cannot use hg archive here due to
         # http://bz.selenic.com/show_bug.cgi?id=3747, have to clone properly :-(
         self.tempdir = tempfile.mkdtemp(prefix=self.config.repositoryName)
         command = ['hg', 'clone', '-q', self.config.repository, '-u', 'default', self.tempdir]
         subprocess.check_call(command)
 
         # Make sure to process the dependencies file if it is present
         import logging
         logging.disable(logging.WARNING)
         try:
             from buildtools.ensure_dependencies import resolve_deps
             resolve_deps(self.tempdir, self_update=False,
-                         overrideroots={"hg": os.path.abspath(
+                         overrideroots={'hg': os.path.abspath(
                              os.path.join(self.config.repository, os.pardir)
                          )},
-                         skipdependencies={"buildtools"})
+                         skipdependencies={'buildtools'})
         finally:
             logging.disable(logging.NOTSET)
 
     def writeChangelog(self, changes):
         """
           write the changelog file into the cloned repository
         """
         baseDir = os.path.join(self.config.nightliesDirectory, self.basename)
         if not os.path.exists(baseDir):
             os.makedirs(baseDir)
-        changelogFile = "%s-%s.changelog.xhtml" % (self.basename, self.version)
+        changelogFile = '%s-%s.changelog.xhtml' % (self.basename, self.version)
         changelogPath = os.path.join(baseDir, changelogFile)
         self.changelogURL = urlparse.urljoin(self.config.nightliesURL, self.basename + '/' + changelogFile)
 
         template = get_template(get_config().get('extensions', 'changelogTemplate'))
         template.stream({'changes': changes}).dump(changelogPath, encoding='utf-8')
 
         linkPath = os.path.join(baseDir, '00latest.changelog.xhtml')
         if hasattr(os, 'symlink'):
             if os.path.exists(linkPath):
                 os.remove(linkPath)
             os.symlink(os.path.basename(changelogPath), linkPath)
         else:
             shutil.copyfile(changelogPath, linkPath)
 
     def readGeckoMetadata(self):
         """
           read Gecko-specific metadata file from a cloned repository
           and parse id, version, basename and the compat section
           out of the file
         """
         import buildtools.packagerGecko as packager
         metadata = packager.readMetadata(self.tempdir, self.config.type)
-        self.extensionID = metadata.get("general", "id")
+        self.extensionID = metadata.get('general', 'id')
         self.version = packager.getBuildVersion(self.tempdir, metadata, False, self.revision)
-        self.basename = metadata.get("general", "basename")
+        self.basename = metadata.get('general', 'basename')
         self.compat = []
         for key, value in packager.KNOWN_APPS.iteritems():
             if metadata.has_option('compat', key):
                 minVersion, maxVersion = metadata.get('compat', key).split('/')
                 self.compat.append({'id': value, 'minVersion': minVersion, 'maxVersion': maxVersion})
 
     def readAndroidMetadata(self):
         """
           Read Android-specific metadata from AndroidManifest.xml file.
         """
         manifestFile = open(os.path.join(self.tempdir, 'AndroidManifest.xml'), 'r')
         manifest = parseXml(manifestFile)
         manifestFile.close()
 
         root = manifest.documentElement
-        self.version = root.attributes["android:versionName"].value
+        self.version = root.attributes['android:versionName'].value
         while self.version.count('.') < 2:
             self.version += '.0'
         self.version = '%s.%s' % (self.version, self.revision)
 
         usesSdk = manifest.getElementsByTagName('uses-sdk')[0]
-        self.minSdkVersion = usesSdk.attributes["android:minSdkVersion"].value
+        self.minSdkVersion = usesSdk.attributes['android:minSdkVersion'].value
         self.basename = os.path.basename(self.config.repository)
 
     def readChromeMetadata(self):
         """
           Read Chrome-specific metadata from metadata file. This will also
           calculate extension ID from the private key.
         """
 
         # Calculate extension ID from public key
         # (see http://supercollider.dk/2010/01/calculating-chrome-extension-id-from-your-private-key-233)
         import buildtools.packagerChrome as packager
         publicKey = packager.getPublicKey(self.config.keyFile)
         hash = hashlib.sha256()
         hash.update(publicKey)
         self.extensionID = hash.hexdigest()[0:32]
         self.extensionID = ''.join(map(lambda c: chr(97 + int(c, 16)), self.extensionID))
 
         # Now read metadata file
         metadata = packager.readMetadata(self.tempdir, self.config.type)
         self.version = packager.getBuildVersion(self.tempdir, metadata, False, self.revision)
-        self.basename = metadata.get("general", "basename")
+        self.basename = metadata.get('general', 'basename')
 
         self.compat = []
         if metadata.has_section('compat') and metadata.has_option('compat', 'chrome'):
             self.compat.append({'id': 'chrome', 'minVersion': metadata.get('compat', 'chrome')})
 
     def readSafariMetadata(self):
         import buildtools.packagerSafari as packager
         metadata = packager.readMetadata(self.tempdir, self.config.type)
         certs = packager.get_certificates_and_key(self.config.keyFile)[0]
 
         self.certificateID = packager.get_developer_identifier(certs)
         self.version = packager.getBuildVersion(self.tempdir, metadata, False, self.revision)
-        self.shortVersion = metadata.get("general", "version")
-        self.basename = metadata.get("general", "basename")
+        self.shortVersion = metadata.get('general', 'version')
+        self.basename = metadata.get('general', 'basename')
         self.updatedFromGallery = False
 
     def writeUpdateManifest(self):
         """
           Writes update.rdf file for the current build
         """
         baseDir = os.path.join(self.config.nightliesDirectory, self.basename)
         if self.config.type == 'safari':
-            manifestPath = os.path.join(baseDir, "updates.plist")
+            manifestPath = os.path.join(baseDir, 'updates.plist')
             templateName = 'safariUpdateManifest'
         elif self.config.type == 'android':
-            manifestPath = os.path.join(baseDir, "updates.xml")
+            manifestPath = os.path.join(baseDir, 'updates.xml')
             templateName = 'androidUpdateManifest'
         else:
             return
 
         if not os.path.exists(baseDir):
             os.makedirs(baseDir)
 
         # ABP for Android used to have its own update manifest format. We need to
         # generate both that and the new one in the libadblockplus format as long
         # as a significant amount of users is on an old version.
         if self.config.type == 'android':
-            newManifestPath = os.path.join(baseDir, "update.json")
+            newManifestPath = os.path.join(baseDir, 'update.json')
             writeAndroidUpdateManifest(newManifestPath, [{
                 'basename': self.basename,
                 'version': self.version,
                 'updateURL': self.updateURL
             }])
 
         template = get_template(get_config().get('extensions', templateName))
         template.stream({'extensions': [self]}).dump(manifestPath)
 
     def writeIEUpdateManifest(self, versions):
         """
           Writes update.json file for the latest IE build
         """
         if len(versions) == 0:
             return
 
         version = versions[0]
         packageName = self.basename + '-' + version + self.config.packageSuffix
         updateURL = urlparse.urljoin(self.config.nightliesURL, self.basename + '/' + packageName + '?update')
         baseDir = os.path.join(self.config.nightliesDirectory, self.basename)
         manifestPath = os.path.join(baseDir, 'update.json')
 
         from sitescripts.extensions.utils import writeIEUpdateManifest as doWrite
         doWrite(manifestPath, [{
             'basename': self.basename,
             'version': version,
             'updateURL': updateURL
         }])
 
-        for suffix in ["-x86.msi", "-x64.msi", "-gpo-x86.msi", "-gpo-x64.msi"]:
+        for suffix in ['-x86.msi', '-x64.msi', '-gpo-x86.msi', '-gpo-x64.msi']:
             linkPath = os.path.join(baseDir, '00latest%s' % suffix)
             outputPath = os.path.join(baseDir, self.basename + '-' + version + suffix)
             if hasattr(os, 'symlink'):
                 if os.path.exists(linkPath):
                     os.remove(linkPath)
                 os.symlink(os.path.basename(outputPath), linkPath)
             else:
                 shutil.copyfile(outputPath, linkPath)
 
     def build(self):
         """
           run the build command in the tempdir
         """
         baseDir = os.path.join(self.config.nightliesDirectory, self.basename)
         if not os.path.exists(baseDir):
             os.makedirs(baseDir)
-        outputFile = "%s-%s%s" % (self.basename, self.version, self.config.packageSuffix)
+        outputFile = '%s-%s%s' % (self.basename, self.version, self.config.packageSuffix)
         self.path = os.path.join(baseDir, outputFile)
         self.updateURL = urlparse.urljoin(self.config.nightliesURL, self.basename + '/' + outputFile + '?update')
 
         if self.config.type == 'android':
             apkFile = open(self.path, 'wb')
 
             try:
                 try:
                     port = get_config().get('extensions', 'androidBuildPort')
                 except ConfigParser.NoOptionError:
@@ skipping 48 matching lines @@
                 os.remove(changelogPath)
         return versions
 
     def updateIndex(self, versions):
         """
           Updates index page listing all existing versions
         """
         baseDir = os.path.join(self.config.nightliesDirectory, self.basename)
         if not os.path.exists(baseDir):
             os.makedirs(baseDir)
-        outputFile = "index.html"
+        outputFile = 'index.html'
         outputPath = os.path.join(baseDir, outputFile)
 
         links = []
         for version in versions:
             packageFile = self.basename + '-' + version + self.config.packageSuffix
             changelogFile = self.basename + '-' + version + '.changelog.xhtml'
             if not os.path.exists(os.path.join(baseDir, packageFile)):
                 # Oops
                 continue
 
@@ skipping 242 matching lines @@
     # build all extensions specified in the configuration file
     # and generate changelogs and documentations for each:
     data = None
     for repo in Configuration.getRepositoryConfigurations(nightlyConfig):
         build = None
         try:
             build = NightlyBuild(repo)
             if build.hasChanges():
                 build.run()
         except Exception, ex:
-            logging.error("The build for %s failed:", repo)
+            logging.error('The build for %s failed:', repo)
             logging.exception(ex)
 
     file = open(nightlyConfigFile, 'wb')
     nightlyConfig.write(file)
 
 
 if __name__ == '__main__':
     main()