Fix msvs-ninja OutputDirectory path.

pylib/gyp/generator/msvs.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.
 
 import copy
 import ntpath
 import os
 import posixpath
 import re
 import subprocess
 import sys
 
 import gyp.common
 import gyp.easy_xml as easy_xml
+import gyp.generator.ninja as ninja_generator
 import gyp.MSVSNew as MSVSNew
 import gyp.MSVSProject as MSVSProject
 import gyp.MSVSSettings as MSVSSettings
 import gyp.MSVSToolFile as MSVSToolFile
 import gyp.MSVSUserFile as MSVSUserFile
 import gyp.MSVSUtil as MSVSUtil
 import gyp.MSVSVersion as MSVSVersion
 from gyp.common import GypError
 from gyp.common import OrderedSet
 
@@ skipping 1755 matching lines @@
   # Set all the dependencies, but not if we are using an external builder like
   # ninja
   for project in projects.values():
     if not project.spec.get('msvs_external_builder'):
       deps = project.spec.get('dependencies', [])
       deps = [projects[d] for d in deps]
       project.set_dependencies(deps)
   return projects
 
 
-def _InitNinjaFlavor(options, target_list, target_dicts):
+def _InitNinjaFlavor(params, target_list, target_dicts):
   """Initialize targets for the ninja flavor.
 
   This sets up the necessary variables in the targets to generate msvs projects
   that use ninja as an external builder. The variables in the spec are only set
   if they have not been set. This allows individual specs to override the
   default values initialized here.
   Arguments:
-    options: Options provided to the generator.
+    params: Params provided to the generator.
     target_list: List of target pairs: 'base/base.gyp:base'.
     target_dicts: Dict of target properties keyed on target pair.
   """
   for qualified_target in target_list:
     spec = target_dicts[qualified_target]
     if spec.get('msvs_external_builder'):
       # The spec explicitly defined an external builder, so don't change it.
       continue
 
     path_to_ninja = spec.get('msvs_path_to_ninja', 'ninja.exe')
 
     spec['msvs_external_builder'] = 'ninja'
     if not spec.get('msvs_external_builder_out_dir'):
       spec['msvs_external_builder_out_dir'] = \
-        options.depth + '/out/$(Configuration)'
+          ninja_generator.ComputeOutputDir(params) + '\\$(Configuration)'
     if not spec.get('msvs_external_builder_build_cmd'):
       spec['msvs_external_builder_build_cmd'] = [
         path_to_ninja,
         '-C',
         '$(OutDir)',
         '$(ProjectName)',
       ]
     if not spec.get('msvs_external_builder_clean_cmd'):
       spec['msvs_external_builder_clean_cmd'] = [
         path_to_ninja,
@@ skipping 74 matching lines @@
   # Optionally shard targets marked with 'msvs_shard': SHARD_COUNT.
   (target_list, target_dicts) = MSVSUtil.ShardTargets(target_list, target_dicts)
 
   # Optionally use the large PDB workaround for targets marked with
   # 'msvs_large_pdb': 1.
   (target_list, target_dicts) = MSVSUtil.InsertLargePdbShims(
         target_list, target_dicts, generator_default_variables)
 
   # Optionally configure each spec to use ninja as the external builder.
   if params.get('flavor') == 'ninja':
-    _InitNinjaFlavor(options, target_list, target_dicts)
+    _InitNinjaFlavor(params, target_list, target_dicts)
 
   # Prepare the set of configurations.
   configs = set()
   for qualified_target in target_list:
     spec = target_dicts[qualified_target]
     for config_name, config in spec['configurations'].iteritems():
       configs.add(_ConfigFullName(config_name, config))
   configs = list(configs)
 
   # Figure out all the projects that will be generated and their guids
@@ skipping 634 matching lines @@
   return [
       ['PropertyGroup', {'Label': 'Globals'},
        ['ProjectGuid', guid],
        ['Keyword', 'Win32Proj'],
        ['RootNamespace', namespace],
        ['IgnoreWarnCompileDuplicatedFilename', 'true'],
       ]
   ]
 
 
-def _GetMSBuildConfigurationDetails(spec, build_file):
+def _GetMSBuildConfigurationDetails(spec, build_file, project_path):
   properties = {}
   for name, settings in spec['configurations'].iteritems():
-    msbuild_attributes = _GetMSBuildAttributes(spec, settings, build_file)
+    msbuild_attributes = _GetMSBuildAttributes(spec, settings,
+                                               build_file, project_path)
     condition = _GetConfigurationCondition(name, settings)
     character_set = msbuild_attributes.get('CharacterSet')
     _AddConditionalProperty(properties, condition, 'ConfigurationType',
                             msbuild_attributes['ConfigurationType'])
     if character_set:
       _AddConditionalProperty(properties, condition, 'CharacterSet',
                               character_set)
   return _GetMSBuildPropertyGroup(spec, 'Configuration', properties)
 
 
@@ skipping 86 matching lines @@
   if config_type.isdigit():
     config_type = {
         '1': 'Application',
         '2': 'DynamicLibrary',
         '4': 'StaticLibrary',
         '10': 'Utility'
     }[config_type]
   return config_type
 
 
-def _GetMSBuildAttributes(spec, config, build_file):
+def _GetMSBuildAttributes(spec, config, build_file, project_path):
   if 'msbuild_configuration_attributes' not in config:
     msbuild_attributes = _ConvertMSVSBuildAttributes(spec, config, build_file)
 
   else:
     config_type = _GetMSVSConfigurationType(spec, build_file)
     config_type = _ConvertMSVSConfigurationType(config_type)
     msbuild_attributes = config.get('msbuild_configuration_attributes', {})
     msbuild_attributes.setdefault('ConfigurationType', config_type)
     output_dir = msbuild_attributes.get('OutputDirectory',
                                       '$(SolutionDir)$(Configuration)')
     msbuild_attributes['OutputDirectory'] = _FixPath(output_dir) + '\\'
     if 'IntermediateDirectory' not in msbuild_attributes:
       intermediate = _FixPath('$(Configuration)') + '\\'
       msbuild_attributes['IntermediateDirectory'] = intermediate
     if 'CharacterSet' in msbuild_attributes:
       msbuild_attributes['CharacterSet'] = _ConvertMSVSCharacterSet(
           msbuild_attributes['CharacterSet'])
   if 'TargetName' not in msbuild_attributes:
     prefix = spec.get('product_prefix', '')
     product_name = spec.get('product_name', '$(ProjectName)')
     target_name = prefix + product_name
     msbuild_attributes['TargetName'] = target_name
 
   if spec.get('msvs_external_builder'):
     external_out_dir = spec.get('msvs_external_builder_out_dir', '.')
-    msbuild_attributes['OutputDirectory'] = _FixPath(external_out_dir) + '\\'
+    project_dir = os.path.dirname(project_path)
+    msbuild_attributes['OutputDirectory'] = \
+        gyp.common.RelativePath(external_out_dir, project_dir) + '\\'
 
   # Make sure that 'TargetPath' matches 'Lib.OutputFile' or 'Link.OutputFile'
   # (depending on the tool used) to avoid MSB8012 warning.
   msbuild_tool_map = {
       'executable': 'Link',
       'shared_library': 'Link',
       'loadable_module': 'Link',
       'static_library': 'Lib',
   }
   msbuild_tool = msbuild_tool_map.get(spec['type'])
   if msbuild_tool:
     msbuild_settings = config['finalized_msbuild_settings']
     out_file = msbuild_settings[msbuild_tool].get('OutputFile')
     if out_file:
       msbuild_attributes['TargetPath'] = _FixPath(out_file)
     target_ext = msbuild_settings[msbuild_tool].get('TargetExt')
     if target_ext:
       msbuild_attributes['TargetExt'] = target_ext
 
   return msbuild_attributes
 
 
-def _GetMSBuildConfigurationGlobalProperties(spec, configurations, build_file):
+def _GetMSBuildConfigurationGlobalProperties(spec, configurations,
+                                             build_file, project_path):
   # TODO(jeanluc) We could optimize out the following and do it only if
   # there are actions.
   # TODO(jeanluc) Handle the equivalent of setting 'CYGWIN=nontsec'.
   new_paths = []
   cygwin_dirs = spec.get('msvs_cygwin_dirs', ['.'])[0]
   if cygwin_dirs:
     cyg_path = '$(MSBuildProjectDirectory)\\%s\\bin\\' % _FixPath(cygwin_dirs)
     new_paths.append(cyg_path)
     # TODO(jeanluc) Change the convention to have both a cygwin_dir and a
     # python_dir.
     python_path = cyg_path.replace('cygwin\\bin', 'python_26')
     new_paths.append(python_path)
     if new_paths:
       new_paths = '$(ExecutablePath);' + ';'.join(new_paths)
 
   properties = {}
   for (name, configuration) in sorted(configurations.iteritems()):
     condition = _GetConfigurationCondition(name, configuration)
-    attributes = _GetMSBuildAttributes(spec, configuration, build_file)
+    attributes = _GetMSBuildAttributes(spec, configuration,
+                                       build_file, project_path)
     msbuild_settings = configuration['finalized_msbuild_settings']
     _AddConditionalProperty(properties, condition, 'IntDir',
                             attributes['IntermediateDirectory'])
     _AddConditionalProperty(properties, condition, 'OutDir',
                             attributes['OutputDirectory'])
     _AddConditionalProperty(properties, condition, 'TargetName',
                             attributes['TargetName'])
 
     if attributes.get('TargetPath'):
       _AddConditionalProperty(properties, condition, 'TargetPath',
@@ skipping 409 matching lines @@
   content = [
       'Project',
       {'xmlns': 'http://schemas.microsoft.com/developer/msbuild/2003',
        'ToolsVersion': version.ProjectVersion(),
        'DefaultTargets': 'Build'
       }]
 
   content += _GetMSBuildProjectConfigurations(configurations)
   content += _GetMSBuildGlobalProperties(spec, project.guid, project_file_name)
   content += import_default_section
-  content += _GetMSBuildConfigurationDetails(spec, project.build_file)
+  content += _GetMSBuildConfigurationDetails(spec,
+                                             project.build_file, project.path)
   content += _GetMSBuildLocalProperties(project.msbuild_toolset)
   content += import_cpp_props_section
   content += _GetMSBuildExtensions(props_files_of_rules)
   content += _GetMSBuildPropertySheets(configurations)
   content += macro_section
   content += _GetMSBuildConfigurationGlobalProperties(spec, configurations,
-                                                      project.build_file)
+                                                      project.build_file,
+                                                      project.path)
   content += _GetMSBuildToolSettingsSections(spec, configurations)
   content += _GetMSBuildSources(
       spec, sources, exclusions, extension_to_rule_name, actions_spec,
       sources_handled_by_action, list_excluded)
   content += _GetMSBuildProjectReferences(project)
   content += import_cpp_targets_section
   content += _GetMSBuildExtensionTargets(targets_files_of_rules)
 
   if spec.get('msvs_external_builder'):
     content += _GetMSBuildExternalBuilderTargets(spec)
@@ skipping 121 matching lines @@
   action_spec.extend(
       # TODO(jeanluc) 'Document' for all or just if as_sources?
       [['FileType', 'Document'],
        ['Command', command],
        ['Message', description],
        ['Outputs', outputs]
       ])
   if additional_inputs:
     action_spec.append(['AdditionalInputs', additional_inputs])
   actions_spec.append(action_spec)