Limit the set of Visual Studio projects generated by GN

tools/gn/visual_studio_writer.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "tools/gn/visual_studio_writer.h"
 
 #include <algorithm>
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "tools/gn/builder.h"
 #include "tools/gn/config.h"
 #include "tools/gn/config_values_extractors.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/path_output.h"
 #include "tools/gn/source_file_type.h"
 #include "tools/gn/standard_out.h"
@@ skipping 183 matching lines @@
 
 VisualStudioWriter::~VisualStudioWriter() {
   STLDeleteContainerPointers(projects_.begin(), projects_.end());
   STLDeleteContainerPointers(folders_.begin(), folders_.end());
 }
 
 // static
 bool VisualStudioWriter::RunAndWriteFiles(const BuildSettings* build_settings,
                                           Builder* builder,
                                           Version version,
+                                          const std::string& sln_name,
+                                          const std::string& dir_filters,
                                           Err* err) {
   std::vector<const Target*> targets = builder->GetAllResolvedTargets();
 
   VisualStudioWriter writer(build_settings, version);
   writer.projects_.reserve(targets.size());
   writer.folders_.reserve(targets.size());
 
+  std::vector<std::string> filters;
+  if (!dir_filters.empty()) {
+    filters = base::SplitString(dir_filters, ";", base::TRIM_WHITESPACE,
+                                base::SPLIT_WANT_NONEMPTY);
+
+    // Git Bash and other MSYS shells convert POSIX paths before passing them to
+    // native Windows programs. Leading slash is trimmed in paths like
+    // "//chrome" or "/c:/foo" making them "/chrome" and "c:/foo". Convert such
+    // paths back to GN format so filters can be compared to other GN paths.
+    // See: http://www.mingw.org/wiki/Posix_path_conversion
+    for (std::string& filter : filters) {
+      if (filter.size() > 1 &&
+          (filter[0] == '/' &&

[brettw, 2016/02/24 22:11:26]

This seems complicated and isn't something we do anywhere else. My idea is to do
this the same way we handle the build dirs (which allow you to specify
"//foo/bar" GN paths if you want): it will also resolve paths relative to the
current directory. You can see in Setup::FillBuildDir how this works.

Also, GN has this "LabelPattern" concept that is used on various places. I think
it would be advantageous to use this rather than rolling custom prefix matching
for this case, just for consistency. You can see in
ResolveTargetsFromCommandLinePattern in commands.cc an example.

Putting this together, I think your command line would look like
  --filters="//base/*;chrome/*"
(you can see you can omit the leading slashes assuming the current directory is
"src", which should solve the MSVS problem).

[Tomasz Moniuszko, 2016/02/25 13:28:20]

Many thanks for this hint. I was thinking about using string pattern from base
before. I missed label pattern and it seems it's exactly what we want. It works
perfectly.

+               !(filter[1] == '/' ||
+                 filter.size() > 2 && base::IsAsciiAlpha(filter[1]) &&
+                     filter[2] == ':') ||
+           base::IsAsciiAlpha(filter[0]) && filter[1] == ':'))
+        filter = '/' + filter;
+    }
+  }
+
   for (const Target* target : targets) {
     // Skip actions and groups.
     if (target->output_type() == Target::GROUP ||
         target->output_type() == Target::COPY_FILES ||
         target->output_type() == Target::ACTION ||
         target->output_type() == Target::ACTION_FOREACH) {
       continue;
     }
 
+    if (!filters.empty()) {
+      bool exclude = true;
+      for (const std::string& filter : filters) {
+        if (base::StartsWith(target->label().dir().value(), filter,
+                             base::CompareCase::SENSITIVE)) {
+          exclude = false;
+          break;
+        }
+      }
+      if (exclude)
+        continue;
+    }
+
     if (!writer.WriteProjectFiles(target, err))
       return false;
   }
 
   if (writer.projects_.empty()) {
     *err = Err(Location(), "No Visual Studio projects generated.");
     return false;
   }
 
   // Sort projects so they appear always in the same order in solution file.
   // Otherwise solution file is rewritten and reloaded by Visual Studio.
   std::sort(writer.projects_.begin(), writer.projects_.end(),
             [](const SolutionEntry* a, const SolutionEntry* b) {
               return a->path < b->path;
             });
 
   writer.ResolveSolutionFolders();
-  return writer.WriteSolutionFile(err);
+  return writer.WriteSolutionFile(sln_name, err);
 }
 
 bool VisualStudioWriter::WriteProjectFiles(const Target* target, Err* err) {
   std::string project_name = target->label().name();
   std::string project_config_platform = config_platform_;
   if (!target->settings()->is_default()) {
     project_name += "_" + target->toolchain()->label().name();
     project_config_platform = target->toolchain()
                                   ->settings()
                                   ->build_settings()
@@ skipping 311 matching lines @@
           }
           cl_item->SubElement("Filter")->Text(filter_path);
         }
       }
     }
   }
 
   project.Text(files_out.str());
 }
 
-bool VisualStudioWriter::WriteSolutionFile(Err* err) {
+bool VisualStudioWriter::WriteSolutionFile(const std::string& sln_name,
+                                           Err* err) {
+  std::string name = sln_name.empty() ? "all" : sln_name;
   SourceFile sln_file = build_settings_->build_dir().ResolveRelativeFile(
-      Value(nullptr, "all.sln"), err);
+      Value(nullptr, name + ".sln"), err);
   if (sln_file.is_null())
     return false;
 
   base::FilePath sln_path = build_settings_->GetFullPath(sln_file);
 
   std::stringstream string_out;
   WriteSolutionFileContents(string_out, sln_path.DirName());
 
   // Only write the content to the file if it's different. That is
   // both a performance optimization and more importantly, prevents
@@ skipping 92 matching lines @@
         size_t common_prefix_len = 0;
         size_t max_common_length =
             std::min(root_folder_path_.size(), folder_path.size());
         size_t i;
         for (i = common_prefix_len; i < max_common_length; ++i) {
           if (IsSlash(root_folder_path_[i]) && IsSlash(folder_path[i]))
             common_prefix_len = i + 1;
           else if (root_folder_path_[i] != folder_path[i])
             break;
         }
-        if (i == max_common_length)
+        if (i == max_common_length &&
+            (i == folder_path.size() || IsSlash(folder_path[i])))
           common_prefix_len = max_common_length;
         if (common_prefix_len < root_folder_path_.size()) {
           if (IsSlash(root_folder_path_[common_prefix_len - 1]))
             --common_prefix_len;
           root_folder_path_ = root_folder_path_.substr(0, common_prefix_len);
         }
       }
     }
   }
 
@@ skipping 36 matching lines @@
                            base::CompareCase::SENSITIVE)) {
         folder->parent_folder = parents.back();
         break;
       } else {
         parents.pop_back();
       }
     }
     parents.push_back(folder);
   }
 }