GN: Add the ability to trim whitespace from script results.

tools/gn/function_exec_script.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 "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 218 matching lines @@
   return false;
 }
 #endif
 
 }  // namespace
 
 const char kExecScript[] = "exec_script";
 const char kExecScript_Help[] =
     "exec_script: Synchronously run a script and return the output.\n"
     "\n"
-    "  exec_script(filename, arguments, input_conversion,\n"
-    "              [file_dependencies])\n"
+    "  exec_script(filename [, arguments [, input_conversion [,\n"

[bbudge, 2014/01/08 23:22:32]

I can't grok these brackets.

[brettw, 2014/01/09 23:48:53]

I changed this to use a more C++ style of annotating default arguments.

[bbudge, 2014/01/10 00:37:54]

Sorry, I somehow didn't think the left/right brackets matched up. I see now what
this means. Feel free to use this style if you like.

+    "              file_dependencies]]])\n"
     "\n"
     "  Runs the given script, returning the stdout of the script. The build\n"
     "  generation will fail if the script does not exist or returns a nonzero\n"
     "  exit code.\n"
     "\n"
     "  The current directory when executing the script will be the root\n"
     "  build directory. If you are passing file names, you will want to use\n"
     "  the rebase_path() function to make file names relative to this\n"
     "  path (see \"gn help rebase_path\").\n"
     "\n"
     "Arguments:\n"
     "\n"
     "  filename:\n"
     "      File name of python script to execute. Non-absolute names will\n"
     "      be treated as relative to the current build file.\n"
     "\n"
     "  arguments:\n"
     "      A list of strings to be passed to the script as arguments.\n"
+    "      May be unspecified or the empty list which means no arguments.\n"
     "\n"
     "  input_conversion:\n"
     "      Controls how the file is read and parsed.\n"
     "      See \"gn help input_conversion\".\n"
     "\n"
+    "      If unspecified, defaults to the empty string which causes the\n"
+    "      script result to be discarded. exec script will return None.\n"
+    "\n"
     "  dependencies:\n"
     "      (Optional) A list of files that this script reads or otherwise\n"
     "      depends on. These dependencies will be added to the build result\n"
     "      such that if any of them change, the build will be regenerated and\n"
     "      the script will be re-run.\n"
     "\n"
     "      The script itself will be an implicit dependency so you do not\n"
     "      need to list it.\n"
     "\n"
     "Example:\n"
     "\n"
     "  all_lines = exec_script(\"myscript.py\", [some_input], \"list lines\",\n"
     "                          [ rebase_path(\"data_file.txt\", \".\","
-    "                                        root_build_dir) ])\n";
+    "                                        root_build_dir) ])\n"
+    "\n"
+    "  # This example just calls the script with no arguments and discards\n"
+    "  # the result.\n"
+    "  exec_script(\"//foo/bar/myscript.py\")\n";
 
 Value RunExecScript(Scope* scope,
                     const FunctionCallNode* function,
                     const std::vector<Value>& args,
                     Err* err) {
-  if (args.size() != 3 && args.size() != 4) {
+  if (args.size() < 1 || args.size() > 4) {
     *err = Err(function->function(), "Wrong number of arguments to exec_script",
-               "I expected three or four arguments.");
+               "I expected between one and four arguments.");
     return Value();
   }
 
   const Settings* settings = scope->settings();
   const BuildSettings* build_settings = settings->build_settings();
   const SourceDir& cur_dir = scope->GetSourceDir();
 
   // Find the python script to run.
   if (!args[0].VerifyTypeIs(Value::STRING, err))
     return Value();
@@ skipping 24 matching lines @@
           build_settings->GetFullPath(cur_dir.ResolveRelativeFile(
               deps_value.list_value()[0].string_value())));
     }
   }
 
   // Make the command line.
   const base::FilePath& python_path = build_settings->python_path();
   CommandLine cmdline(python_path);
   cmdline.AppendArgPath(script_path);
 
-  const Value& script_args = args[1];
-  if (!script_args.VerifyTypeIs(Value::LIST, err))
-    return Value();
-  for (size_t i = 0; i < script_args.list_value().size(); i++) {
-    if (!script_args.list_value()[i].VerifyTypeIs(Value::STRING, err))
+  if (args.size() >= 2) {
+    // Optional command-line arguments to the script.
+    const Value& script_args = args[1];
+    if (!script_args.VerifyTypeIs(Value::LIST, err))
       return Value();
-    cmdline.AppendArg(script_args.list_value()[i].string_value());
+    for (size_t i = 0; i < script_args.list_value().size(); i++) {
+      if (!script_args.list_value()[i].VerifyTypeIs(Value::STRING, err))
+        return Value();
+      cmdline.AppendArg(script_args.list_value()[i].string_value());
+    }
   }
 
   // Log command line for debugging help.
   trace.SetCommandLine(cmdline);
   base::TimeTicks begin_exec;
   if (g_scheduler->verbose_logging()) {
 #if defined(OS_WIN)
     g_scheduler->Log("Pythoning",
                      base::UTF16ToUTF8(cmdline.GetCommandLineString()));
 #else
@@ skipping 40 matching lines @@
         "\nReturned " + base::IntToString(exit_code);
     if (!output.empty())
       msg += " and printed out:\n\n" + output;
     else
       msg += ".";
     *err = Err(function->function(), "Script returned non-zero exit code.",
                msg);
     return Value();
   }
 
-  return ConvertInputToValue(output, function, args[2], err);
+  // Default to None value for the input conversion if unspecified.
+  return ConvertInputToValue(output, function,
+                             args.size() >= 3 ? args[2] : Value(), err);
 }
 
 }  // namespace functions