Extract XcodeVersion to be a standalone module function

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
@@ skipping 253 matching lines @@
       return self._GetBundleBinaryPath()
     else:
       return self._GetStandaloneBinaryPath()
 
   def GetActiveArchs(self, configname):
     """Returns the architectures this target should be built for."""
     # TODO: Look at VALID_ARCHS, ONLY_ACTIVE_ARCH; possibly set
     # CURRENT_ARCH / NATIVE_ARCH env vars?
     return self.xcode_settings[configname].get('ARCHS', [self._DefaultArch()])
 
-  def _GetStdout(self, cmdlist):
-    job = subprocess.Popen(cmdlist, stdout=subprocess.PIPE)
-    out = job.communicate()[0]
-    if job.returncode != 0:
-      sys.stderr.write(out + '\n')
-      raise GypError('Error %d running %s' % (job.returncode, cmdlist[0]))
-    return out.rstrip('\n')
-
   def _GetSdkVersionInfoItem(self, sdk, infoitem):
     # xcodebuild requires Xcode and can't run on Command Line Tools-only
     # systems from 10.7 onward.
     # Since the CLT has no SDK paths anyway, returning None is the
     # most sensible route and should still do the right thing.
     try:
-      return self._GetStdout(['xcodebuild', '-version', '-sdk', sdk, infoitem])
+      return GetStdout(['xcodebuild', '-version', '-sdk', sdk, infoitem])
     except:
       pass
 
   def _SdkRoot(self, configname):
     if configname is None:
       configname = self.configname
     return self.GetPerConfigSetting('SDKROOT', configname, default='')
 
   def _SdkPath(self, configname=None):
     sdk_root = self._SdkRoot(configname)
@@ skipping 568 matching lines @@
 
   def AdjustLibraries(self, libraries, config_name=None):
     """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 self._GetStdout(['sw_vers', '-buildVersion'])
-
-  # This method ported from the logic in Homebrew's CLT version check
-  def _CLTVersion(self):
-    # pkgutil output looks like
-    #   package-id: com.apple.pkg.CLTools_Executables
-    #   version: 5.0.1.0.1.1382131676
-    #   volume: /
-    #   location: /
-    #   install-time: 1382544035
-    #   groups: com.apple.FindSystemFiles.pkg-group com.apple.DevToolsBoth.pkg-group com.apple.DevToolsNonRelocatableShared.pkg-group
-    STANDALONE_PKG_ID = "com.apple.pkg.DeveloperToolsCLILeo"
-    FROM_XCODE_PKG_ID = "com.apple.pkg.DeveloperToolsCLI"
-    MAVERICKS_PKG_ID = "com.apple.pkg.CLTools_Executables"
-
-    regex = re.compile('version: (?P<version>.+)')
-    for key in [MAVERICKS_PKG_ID, STANDALONE_PKG_ID, FROM_XCODE_PKG_ID]:
-      try:
-        output = self._GetStdout(['/usr/sbin/pkgutil', '--pkg-info', key])
-        return re.search(regex, output).groupdict()['version']
-      except:
-        continue
+    return GetStdout(['sw_vers', '-buildVersion'])
 
   def _XcodeVersion(self):
-    # `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 len(XcodeSettings._xcode_version_cache) == 0:
-      try:
-        version_list = self._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 = self._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]
-      XcodeSettings._xcode_version_cache = (version, build)
+      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 = {}
@@ skipping 37 matching lines @@
     project, then the environment variable was empty. Starting with this
     version, Xcode uses the name of the newest SDK installed.
     """
     if self._XcodeVersion() < '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 = self._GetStdout(['xcodebuild', '-showsdks'])
+      all_sdks = GetStdout(['xcodebuild', '-showsdks'])
     except:
       # If xcodebuild fails, there will be no valid SDKs
       return ''
     for line in all_sdks.splitlines():
       items = line.split()
       if len(items) >= 3 and items[-2] == '-sdk':
         sdk_root = items[-1]
         sdk_path = self._XcodeSdkPath(sdk_root)
         if sdk_path == default_sdk_path:
           return sdk_root
@@ skipping 121 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():
+  """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'.
+  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]
+  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: /
+  #   location: /
+  #   install-time: 1382544035
+  #   groups: com.apple.FindSystemFiles.pkg-group com.apple.DevToolsBoth.pkg-group com.apple.DevToolsNonRelocatableShared.pkg-group
+  STANDALONE_PKG_ID = "com.apple.pkg.DeveloperToolsCLILeo"
+  FROM_XCODE_PKG_ID = "com.apple.pkg.DeveloperToolsCLI"
+  MAVERICKS_PKG_ID = "com.apple.pkg.CLTools_Executables"
+
+  regex = re.compile('version: (?P<version>.+)')
+  for key in [MAVERICKS_PKG_ID, STANDALONE_PKG_ID, FROM_XCODE_PKG_ID]:
+    try:
+      output = GetStdout(['/usr/sbin/pkgutil', '--pkg-info', key])
+      return re.search(regex, output).groupdict()['version']
+    except:
+      continue
+
+
+def GetStdout(cmdlist):
+  """Returns the content of standard output returned by invoking |cmdlist|.
+  Raises |GypError| if the command return with a non-zero return code."""
+  job = subprocess.Popen(cmdlist, stdout=subprocess.PIPE)
+  out = job.communicate()[0]
+  if job.returncode != 0:
+    sys.stderr.write(out + '\n')
+    raise GypError('Error %d running %s' % (job.returncode, cmdlist[0]))
+  return out.rstrip('\n')
+
+
 def MergeGlobalXcodeSettingsToSpec(global_dict, spec):
   """Merges the global xcode_settings dictionary into each configuration of the
   target represented by spec. For keys that are both in the global and the local
   xcode_settings dict, the local key gets precendence.
   """
   # The xcode generator special-cases global xcode_settings and does something
   # that amounts to merging in the global xcode_settings into each local
   # xcode_settings dict.
   global_xcode_settings = global_dict.get('xcode_settings', {})
   for config in spec['configurations'].values():
@@ skipping 287 matching lines @@
         new_config_dict['xcode_settings']['SDKROOT'] = 'iphoneos'
       target_dict['configurations'][new_config_name] = new_config_dict
   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