Prepared buildtools for Safari

packagerChrome.py

 # coding: utf-8
 
 # This file is part of the Adblock Plus build tools,
 # Copyright (C) 2006-2013 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 sys, os, re, json, struct
 from StringIO import StringIO
 
-import PIL.Image
-import PIL.ImageMath
-
 import packager
 from packager import readMetadata, getMetadataPath, getDefaultFileName, getBuildVersion, getTemplate, Files
 
 defaultLocale = 'en_US'
 
 def getIgnoredFiles(params):
   result = set(('store.description',))
 
   # Hack: ignore all lib subdirectories
   libDir = os.path.join(params['baseDir'], 'lib')
   for file in os.listdir(libDir):
     if os.path.isdir(os.path.join(libDir, file)):
       result.add(file)
   return result
 
 def getPackageFiles(params):
-  result = set(('_locales', 'icons', 'jquery-ui', 'lib', 'skin', 'ui',))
+  result = set(('_locales', 'icons', 'jquery-ui', 'lib', 'skin', 'ui', 'ext'))
 
   if params['devenv']:
     result.add('qunit')
 
   baseDir = params['baseDir']
   for file in os.listdir(baseDir):
     if file.endswith('.js') or file.endswith('.html') or file.endswith('.xml'):
       result.add(file)
   return result
 
@@ skipping 224 matching lines @@
       'pt': 'pt_PT',
     }
     for chromeLocale, operaLocale in operaMapping.iteritems():
       chromeFile = '_locales/%s/messages.json' % chromeLocale
       operaFile = '_locales/%s/messages.json' % operaLocale if operaLocale != None else None
       if chromeFile in files:
         if operaFile != None:
           files[operaFile] = files[chromeFile]
         del files[chromeFile]
 
-  if params['type'] in ('opera', 'safari'):
-    # Hack: Replace "Chrome" by "Opera" or "Safari" in the locales
-    for path, data in files.iteritems():
-      if path.startswith("_locales/") and path.endswith("/messages.json"):
-        files[path] = re.sub(r"\bChrome\b", params['type'].capitalize(), data)
-
 def signBinary(zipdata, keyFile):
   import M2Crypto
   if not os.path.exists(keyFile):
     M2Crypto.RSA.gen_key(1024, 65537, callback=lambda x: None).save_key(keyFile, cipher=None)
   key = M2Crypto.EVP.load_key(keyFile)
   key.sign_init()
   key.sign_update(zipdata)
   return key.final()
 
 def getPublicKey(keyFile):
   import M2Crypto
   return M2Crypto.EVP.load_key(keyFile).as_der()
 
 def writePackage(outputFile, pubkey, signature, zipdata):
   if isinstance(outputFile, basestring):
     file = open(outputFile, 'wb')
   else:
     file = outputFile
   if pubkey != None and signature != None:
     file.write(struct.pack('<4sIII', 'Cr24', 2, len(pubkey), len(signature)))
     file.write(pubkey)
     file.write(signature)
   file.write(zipdata)
 
-class ImageConverter(object):
-  def convert(self, params, files):
-    for filename, chain in params['metadata'].items('convert_img'):
-      steps = re.split(r'\s*->\s*', chain)
-      image = PIL.Image.open(steps.pop(0))
-
-      for step in steps:
-        filter, args = re.match(r'([^(]+)(?:\((.*)\))?', step).groups()
-        args = tuple(re.split(r'\s*,\s*', args)) if args else ()
-        image = getattr(self, 'filter_' + filter)(image, *args)
-
-      f = StringIO()
-      f.name = filename
-      image.save(f)
-      files[filename] = f.getvalue()
-
-  def filter_blend(self, image, *args):
-    if len(args) == 2:    # args = (filename, opacity)
-      overlay = PIL.Image.open(args[0])
-
-      if image.mode != overlay.mode or image.mode == 'P':
-        overlay = overlay.convert('RGBA')
-        image   =   image.convert('RGBA')
-    elif len(args) == 4:  # args = (red, green, blue, opacity)
-      overlay = PIL.Image.new('RGB', image.size, tuple(map(int, args[:3])))
-
-      if image.mode == 'P':
-        image = image.convert('RGBA')
-
-      if image.mode in ('RGBA', 'LA'):
-        overlay = PIL.Image.merge('RGBA', overlay.split() + image.split()[-1:])
-
-      if image.mode != overlay.mode:
-        image = image.convert(overlay.mode)
-    else:
-      raise TypeError
-
-    return PIL.Image.blend(image, overlay, float(args[-1]))
-
-  def filter_grayscale(self, image):
-    if image.mode == 'P':
-      image = image.convert('RGBA')
-
-    bands = list(image.split())
-    alpha = bands.pop(-1) if image.mode in ('RGBA', 'LA') else None
-
-    if len(bands) == 1:
-      return image
-
-    new_image = PIL.ImageMath.eval(
-      "convert((%s) / %d, 'L')" % (
-        ' + '.join('image%d' % i for i in xrange(len(bands))),
-        len(bands)
-      ),
-      **dict(('image%d' % i, band) for i, band in enumerate(bands))
-    )
-
-    if alpha:
-      new_image = PIL.Image.merge('LA', [new_image, alpha])
-
-    return new_image
-
-  def filter_colorToAlpha(self, image, *color):
-    bands = [band.convert('F') for band in image.convert('RGBA').split()]
-    color = map(float, color)
-
-    # Find the maximum difference rate between source and color. I had to use two
-    # difference functions because ImageMath.eval only evaluates the expression
-    # once.
-    alpha = PIL.ImageMath.eval('''\
-      float(
-        max(
-          max(
-            max(
-              difference1(red_band, cred_band),
-              difference1(green_band, cgreen_band)
-            ),
-            difference1(blue_band, cblue_band)
-          ),
-          max(
-            max(
-              difference2(red_band, cred_band),
-              difference2(green_band, cgreen_band)
-            ),
-            difference2(blue_band, cblue_band)
-          )
-        )
-      )''',
-      difference1=lambda source, col: (source - col) / (255.0 - col),
-      difference2=lambda source, col: (col - source) / col,
-
-      red_band  = bands[0],
-      green_band= bands[1],
-      blue_band = bands[2],
-
-      cred_band  = color[0],
-      cgreen_band= color[1],
-      cblue_band = color[2],
-    )
-
-    # Calculate the new image colors after the removal of the selected color
-    new_bands = [
-      PIL.ImageMath.eval(
-        "convert((image - color) / alpha + color, 'L')",
-        image=band,
-        color=col,
-        alpha=alpha
-      )
-      for band, col in zip(bands, color)
-    ]
-
-    # Add the new alpha band
-    new_bands.append(PIL.ImageMath.eval(
-      "convert(alpha_band * alpha, 'L')",
-      alpha = alpha,
-      alpha_band = bands[3]
-    ))
-
-    return PIL.Image.merge('RGBA', new_bands)
-
 def createBuild(baseDir, type='chrome', outFile=None, buildNum=None, releaseBuild=False, keyFile=None, experimentalAPI=False, devenv=False):
   metadata = readMetadata(baseDir, type)
   version = getBuildVersion(baseDir, metadata, releaseBuild, buildNum)
 
   if outFile == None:
     outFile = getDefaultFileName(baseDir, metadata, version, 'crx' if keyFile else 'zip')
 
   params = {
     'type': type,
     'baseDir': baseDir,
     'releaseBuild': releaseBuild,
     'version': version,
     'experimentalAPI': experimentalAPI,
     'devenv': devenv,
     'metadata': metadata,
   }
 
   files = Files(getPackageFiles(params), getIgnoredFiles(params),
                 process=lambda path, data: processFile(path, data, params))
   files['manifest.json'] = createManifest(params)
   if metadata.has_section('mapping'):
     files.readMappedFiles(metadata.items('mapping'))
   files.read(baseDir)
 
   if metadata.has_section('convert_js'):
     convertJS(params, files)
 
   if metadata.has_section('convert_img'):
-    ImageConverter().convert(params, files)
+    from imageConversion import convertImages
+    convertImages(params, files)
+
+  if metadata.has_section('preprocess'):
+    files.preprocess(
+      [f for f, _ in metadata.items('preprocess')],
+      {'needsExt': True}
+    )
 
   if metadata.has_section('import_locales'):
     importGeckoLocales(params, files)
 
   if devenv:
     files['devenvPoller__.js'] = createPoller(params)
 
   if (metadata.has_option('general', 'backgroundScripts') and
       'lib/info.js' in re.split(r'\s+', metadata.get('general', 'backgroundScripts')) and
       'lib/info.js' not in files):
@@ skipping 32 matching lines @@
   def shutdown_server(server):
     time.sleep(10)
     server.shutdown()
   thread.start_new_thread(shutdown_server, (server,))
   server.serve_forever()
 
   if connections[0] == 0:
     print 'Warning: No incoming connections, extension probably not active in the browser yet'
   else:
     print 'Handled %i connection(s)' % connections[0]