Add the ability to pass long lists of inputs to 'gn refs'.

tools/gn/command_refs.cc

 // Copyright (c) 2013 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 <map>
 #include <set>
 
 #include "base/command_line.h"
+#include "base/files/file_util.h"
+#include "base/strings/string_split.h"
 #include "tools/gn/commands.h"
 #include "tools/gn/deps_iterator.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/input_file.h"
 #include "tools/gn/item.h"
 #include "tools/gn/setup.h"
 #include "tools/gn/standard_out.h"
 #include "tools/gn/target.h"
 
 namespace commands {
@@ skipping 240 matching lines @@
   FilterAndPrintTargetSet(false, results);
   return results.size();
 }
 
 }  // namespace
 
 const char kRefs[] = "refs";
 const char kRefs_HelpShort[] =
     "refs: Find stuff referencing a target or file.";
 const char kRefs_Help[] =
-    "gn refs <out_dir> (<label_pattern>|<label>|<file>)* [--all]\n"
+    "gn refs <out_dir> (<label_pattern>|<label>|<file>|<response_file>)* "

[brettw, 2015/04/17 02:44:27]

Can you make this ...|@...

[Dirk Pranke, 2015/04/17 02:58:12]

Will do.

+    "[--all]\n"
     "        [--all-toolchains] [--as=...] [--testonly=...] [--type=...]\n"
     "\n"
     "  Finds reverse dependencies (which targets reference something). The\n"
     "  input is a list containing:\n"
     "\n"
     "   - Target label: The result will be which targets depend on it.\n"
     "\n"
     "   - Config label: The result will be which targets list the given\n"
     "     config in its \"configs\" or \"public_configs\" list.\n"
     "\n"
     "   - Label pattern: The result will be which targets depend on any\n"
     "     target matching the given pattern. Patterns will not match\n"
     "     configs. These are not general regular expressions, see\n"
     "     \"gn help label_pattern\" for details.\n"
     "\n"
     "   - File name: The result will be which targets list the given file in\n"
     "     its \"inputs\", \"sources\", \"public\", or \"data\". Any input\n"
     "     that does not contain wildcards and does not match a target or a\n"
     "     config will be treated as a file.\n"
     "\n"
+    "   - Response file: If the input starts with an \"@\", it will be\n"
+    "     interpreted as a path to a file containing a list of labels or\n"
+    "     file names, one per line. This allows us to handle long lists\n"
+    "     of inputs without worrying about command line limits.\n"
+    "\n"
     "Options\n"
     "\n"
     "  --all\n"
     "      When used without --tree, will recurse and display all unique\n"
     "      dependencies of the given targets. For example, if the input is\n"
     "      a target, this will output all targets that depend directly or\n"
     "      indirectly on the input. If the input is a file, this will output\n"
     "      all targets that depend directly or indirectly on that file.\n"
     "\n"
     "      When used with --tree, turns off eliding to show a complete tree.\n"
@@ skipping 81 matching lines @@
   bool tree = cmdline->HasSwitch("tree");
   bool all = cmdline->HasSwitch("all");
   bool all_toolchains = cmdline->HasSwitch("all-toolchains");
 
   Setup* setup = new Setup;
   setup->set_check_for_bad_items(false);
   if (!setup->DoSetup(args[0], false) || !setup->Run())
     return 1;
 
   // The inputs are everything but the first arg (which is the build dir).
-  std::vector<std::string> inputs(args.begin() + 1, args.end());
+  std::vector<std::string> inputs;
+  for (auto it = args.begin() + 1; it != args.end(); it++) {
+    auto arg = *it;
+
+    if (arg[0] == '@') {
+      // The argument is as a path to a response file.
+      std::string contents;
+      bool ret = base::ReadFileToString(base::FilePath(arg.substr(1)),
+                                        &contents);
+      if (!ret) {
+        Err(Location(), "Response file " + arg.substr(1) + " not found.")
+            .PrintToStdout();
+        return 1;
+      }
+      base::SplitStringAlongWhitespace(contents, &inputs);

[Dirk Pranke, 2015/04/17 01:27:41]

I'm not sure if this is the best base routine to use here ... suggestions?

[brettw, 2015/04/17 02:44:27]

Yeah, this will fall over for command-lines that include spaces.

On Windows there is a nice function to call to do this parsing properly, but
there's not on Linux, and we would need to implement a bunch of annoying
unescaping.

I wonder if we could just have our own response file format be file-per-line,
since the input is always our own tools? Then you can split it on newlines, and
it's also easier to write from Python without worrying about weird issues.

[Dirk Pranke, 2015/04/17 02:58:12]

That works for me (the layout tests actually support such a format for long
lists of files). 

I didn't think of embedded spaces in the filenames :(.

Is there a base routine that will correctly handle CR, LF, and CRLF (i.e., split
on lines portably)? Or should I not worry about it and just split on LF (\n)?

+    } else {
+      // The argument is a label or a path.
+      inputs.push_back(*it);
+    }
+  }
 
   // Get the matches for the command-line input.
   UniqueVector<const Target*> target_matches;
   UniqueVector<const Config*> config_matches;
   UniqueVector<const Toolchain*> toolchain_matches;
   UniqueVector<SourceFile> file_matches;
   if (!ResolveFromCommandLineInput(setup, inputs, all_toolchains,
                                    &target_matches, &config_matches,
                                    &toolchain_matches, &file_matches))
     return 1;
@@ skipping 42 matching lines @@
 
   // If you ask for the references of a valid target, but that target has
   // nothing referencing it, we'll get here without having printed anything.
   if (!quiet && cnt == 0)
     OutputString("Nothing references this.\n", DECORATION_YELLOW);
 
   return 0;
 }
 
 }  // namespace commands