Cache Xcode version at the module level

pylib/gyp/xcode_emulation.py

 # Copyright (c) 2012 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """
 This module contains classes that help to emulate xcodebuild behavior on top of
 other build systems, such as make and ninja.
 """
 
 import copy
 import gyp.common
 import os
 import os.path
 import re
 import shlex
 import subprocess
 import sys
 import tempfile
 from gyp.common import GypError
 
+# Populated lazily by XcodeVersion, for efficiency, and to fix an issue when
+# "xcodebuild" is called too quickly (it has been found to return incorrect
+# version number).
+XCODE_VERSION_CACHE = []
+
 class XcodeSettings(object):
   """A class that understands the gyp 'xcode_settings' object."""
 
   # Populated lazily by _SdkPath(). Shared by all XcodeSettings, so cached
   # at class-level for efficiency.
   _sdk_path_cache = {}
   _sdk_root_cache = {}
 
   # Populated lazily by GetExtraPlistItems(). Shared by all XcodeSettings, so
   # cached at class-level for efficiency.
   _plist_cache = {}
 
   # Populated lazily by GetIOSPostbuilds.  Shared by all XcodeSettings, so
   # cached at class-level for efficiency.
   _codesigning_key_cache = {}
 
-  # Populated lazily by _XcodeVersion.  Shared by all XcodeSettings, so cached
-  # at class-level for efficiency.
-  _xcode_version_cache = ()
-
   def __init__(self, spec):
     self.spec = spec
 
     self.isIOS = False
 
     # Per-target 'xcode_settings' are pushed down into configs earlier by gyp.
     # This means self.xcode_settings[config] always contains all settings
     # for that config -- the per-target settings as well. Settings that are
     # the same for all configs are implicitly per-target settings.
     self.xcode_settings = {}
@@ skipping 810 matching lines @@
     """Transforms entries like 'Cocoa.framework' in libraries into entries like
     '-framework Cocoa', 'libcrypto.dylib' into '-lcrypto', etc.
     """
     libraries = [self._AdjustLibrary(library, config_name)
                  for library in libraries]
     return libraries
 
   def _BuildMachineOSBuild(self):
     return GetStdout(['sw_vers', '-buildVersion'])
 
-  def _XcodeVersion(self):
-    if len(XcodeSettings._xcode_version_cache) == 0:
-      XcodeSettings._xcode_version_cache = XcodeVersion()
-    return XcodeSettings._xcode_version_cache
-
   def _XcodeIOSDeviceFamily(self, configname):
     family = self.xcode_settings[configname].get('TARGETED_DEVICE_FAMILY', '1')
     return [int(x) for x in family.split(',')]
 
   def GetExtraPlistItems(self, configname=None):
     """Returns a dictionary with extra items to insert into Info.plist."""
     if configname not in XcodeSettings._plist_cache:
       cache = {}
       cache['BuildMachineOSBuild'] = self._BuildMachineOSBuild()
 
-      xcode, xcode_build = self._XcodeVersion()
+      xcode, xcode_build = XcodeVersion()
       cache['DTXcode'] = xcode
       cache['DTXcodeBuild'] = xcode_build
 
       sdk_root = self._SdkRoot(configname)
       if not sdk_root:
         sdk_root = self._DefaultSdkRoot()
       cache['DTSDKName'] = sdk_root
       if xcode >= '0430':
         cache['DTSDKBuild'] = self._GetSdkVersionInfoItem(
             sdk_root, 'ProductBuildVersion')
@@ skipping 17 matching lines @@
       items['UIDeviceFamily'] = self._XcodeIOSDeviceFamily(configname)
     return items
 
   def _DefaultSdkRoot(self):
     """Returns the default SDKROOT to use.
 
     Prior to version 5.0.0, if SDKROOT was not explicitly set in the Xcode
     project, then the environment variable was empty. Starting with this
     version, Xcode uses the name of the newest SDK installed.
     """
-    xcode_version, xcode_build = self._XcodeVersion()
+    xcode_version, xcode_build = XcodeVersion()
     if xcode_version < '0500':
       return ''
     default_sdk_path = self._XcodeSdkPath('')
     default_sdk_root = XcodeSettings._sdk_root_cache.get(default_sdk_path)
     if default_sdk_root:
       return default_sdk_root
     try:
       all_sdks = GetStdout(['xcodebuild', '-showsdks'])
     except:
       # If xcodebuild fails, there will be no valid SDKs
@@ skipping 18 matching lines @@
     # For new projects, ARCHS is set to $(ARCHS_STANDARD_INCLUDING_64_BIT),
     # which correspond to "armv7 armv7s arm64", and when building the simulator
     # the architecture is either "i386" or "x86_64" depending on the simulated
     # device (respectively 32-bit or 64-bit device).
     #
     # Since the value returned by this function is only used when ARCHS is not
     # set, then on iOS we return "i386", as the default xcode project generator
     # does not set ARCHS if it is not set in the .gyp file.
     if self.isIOS:
       return 'i386'
-    version, build = self._XcodeVersion()
+    version, build = XcodeVersion()
     if version >= '0500':
       return 'x86_64'
     return 'i386'
 
 class MacPrefixHeader(object):
   """A class that helps with emulating Xcode's GCC_PREFIX_HEADER feature.
 
   This feature consists of several pieces:
   * If GCC_PREFIX_HEADER is present, all compilations in that project get an
     additional |-include path_to_prefix_header| cflag.
@@ skipping 90 matching lines @@
     if not self.header or not self.compile_headers:
       return []
     return [
       (self._Gch('c', arch), '-x c-header', 'c', self.header),
       (self._Gch('cc', arch), '-x c++-header', 'cc', self.header),
       (self._Gch('m', arch), '-x objective-c-header', 'm', self.header),
       (self._Gch('mm', arch), '-x objective-c++-header', 'mm', self.header),
     ]
 
 
 def XcodeVersion():

[Nico, 2014/02/18 17:11:57]

Huh, is this new? I don't remember there being a global function for this.

[sdefresne, 2014/02/18 17:28:33]

I extracted the function out of the XcodeSettings object and made it a global in
change 1849 (https://code.google.com/p/gyp/source/detail?r=1849) so that I can
call it (indirectly) from CloneConfigurationForDeviceAndEmulator in change 1850
(https://code.google.com/p/gyp/source/detail?r=1850).

This new code path didn't use the cache (since the cache was only enabled when
called through an XCodeSettings object), and this CL move the cache at the
module level so that all calls to XCodeVersion benefits from the cache.

   """Returns a tuple of version and build version of installed Xcode."""
   # `xcodebuild -version` output looks like
   #    Xcode 4.6.3
   #    Build version 4H1503
   # or like
   #    Xcode 3.2.6
   #    Component versions: DevToolsCore-1809.0; DevToolsSupport-1806.0
   #    BuildVersion: 10M2518
   # Convert that to '0463', '4H1503'.
+  if XCODE_VERSION_CACHE:
+    assert len(XCODE_VERSION_CACHE) >= 2
+    return tuple(XCODE_VERSION_CACHE[:2])
   try:
     version_list = GetStdout(['xcodebuild', '-version']).splitlines()
     # In some circumstances xcodebuild exits 0 but doesn't return
     # the right results; for example, a user on 10.7 or 10.8 with
     # a bogus path set via xcode-select
     # In that case this may be a CLT-only install so fall back to
     # checking that version.
     if len(version_list) < 2:
       raise GypError, "xcodebuild returned unexpected results"
   except:
     version = CLTVersion()
     if version:
       version = re.match('(\d\.\d\.?\d*)', version).groups()[0]
     else:
       raise GypError, "No Xcode or CLT version detected!"
     # The CLT has no build information, so we return an empty string.
     version_list = [version, '']
   version = version_list[0]
   build = version_list[-1]
   # Be careful to convert "4.2" to "0420":
   version = version.split()[-1].replace('.', '')
   version = (version + '0' * (3 - len(version))).zfill(4)
   if build:
     build = build.split()[-1]
+  XCODE_VERSION_CACHE.extend((version, build))
   return version, build
 
 
 # This function ported from the logic in Homebrew's CLT version check
 def CLTVersion():
   """Returns the version of command-line tools from pkgutil."""
   # pkgutil output looks like
   #   package-id: com.apple.pkg.CLTools_Executables
   #   version: 5.0.1.0.1.1382131676
   #   volume: /
@@ skipping 372 matching lines @@
       _FilterIOSArchitectureForSDKROOT(iphoneos_config_dict['xcode_settings'])
       _FilterIOSArchitectureForSDKROOT(config_dict['xcode_settings'])
   return targets
 
 def CloneConfigurationForDeviceAndEmulator(target_dicts):
   """If |target_dicts| contains any iOS targets, automatically create -iphoneos
   targets for iOS device builds."""
   if _HasIOSTarget(target_dicts):
     return _AddIOSDeviceConfigurations(target_dicts)
   return target_dicts