gn: Add 'clean' command.

tools/gn/command_clean.cc

Index: tools/gn/command_clean.cc
diff --git a/tools/gn/command_clean.cc b/tools/gn/command_clean.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1f1b481483a139eb8203d87ae6ebb2ba737b3e1f
--- /dev/null
+++ b/tools/gn/command_clean.cc
@@ -0,0 +1,149 @@
+// Copyright 2015 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/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/files/scoped_file.h"
+#include "base/strings/string_split.h"
+#include "base/strings/stringprintf.h"
+#include "tools/gn/commands.h"
+#include "tools/gn/err.h"
+#include "tools/gn/setup.h"
+
+namespace {
+
+// Extracts from a build.ninja the commands to run GN.
+//
+// The commands to run GN are the gn rule and build.ninja build step at the top
+// of the build.ninja file. We want to keep these when deleting GN builds since
+// we want to preserve the command-line flags to GN.
+//
+// On error, returns the empty string.
+std::string ExtractGNBuildCommands(const base::FilePath& build_ninja_file) {
+  std::string file_contents;
+  if (!base::ReadFileToString(build_ninja_file, &file_contents)) {
+    return std::string();
+  }
+
+  std::vector<std::string> lines;
+  base::SplitString(file_contents, '\n', &lines);
+
+  std::string result;
+  int num_blank_lines = 0;
+  for (size_t i = 0; i < lines.size(); ++i) {
+    result += lines[i];
+    result += "\n";
+    if (lines[i].empty()) {
+      ++num_blank_lines;
+    }
+    if (num_blank_lines == 2)
+      break;
+  }
+
+  return result;
+}
+
+const char kDefaultNinjaFile[] =
+    "rule gn\n"
+    "  command = gn -q gen //out/%s/\n"
+    "  description = Regenerating ninja files\n"
+    "\n"
+    "build build.ninja: gn\n"
+    "  generator = 1\n"
+    "  depfile = build.ninja.d\n";
+
+}  // namespace
+
+namespace commands {
+
+const char kClean[] = "clean";
+const char kClean_HelpShort[] =
+    "clean: Cleans the output directory.";
+const char kClean_Help[] =
+    "gn clean <out_dir>\n"
+    "\n"
+    "  Deletes the contents of the output directory except for args.gn and\n"
+    "  creates a Ninja build environment sufficient to regenerate the build.\n";
+
+int RunClean(const std::vector<std::string>& args) {
+  if (args.size() != 1) {
+    Err(Location(), "You're holding it wrong.",
+        "Usage: \"gn clean <out_dir>\"").PrintToStdout();
+    return 1;
+  }
+
+  Setup* setup = new Setup;
+  if (!setup->DoSetup(args[0], false))
+    return 1;
+
+  base::FilePath build_dir(setup->build_settings().GetFullPath(
+      SourceDir(setup->build_settings().build_dir().value())));
+
+  // NOTE: Not all GN builds have args.gn file hence we check here
+  // if a build.ninja.d files exists instead.
+  base::FilePath build_ninja_d_file = build_dir.AppendASCII("build.ninja.d");
+
+  if (!base::PathExists(build_ninja_d_file)) {
+    base::DeleteFile(build_dir, true);

[brettw, 2015/02/17 17:41:56]

I don't think we want to do this. I think if we don't find a .d file (and
therefore know it's not a GN build directory) we should print an error that it
doesn't look like a build directory and return 1 without deleting anything.

[tfarina, 2015/02/17 18:49:19]

Done.

+    return 1;
+  }
+
+  // Erase everything but the args file, and write a dummy build.ninja file that
+  // will automatically rerun GN the next time Ninja is run.
+  base::FilePath build_ninja_file = build_dir.AppendASCII("build.ninja");
+  std::string build_commands = ExtractGNBuildCommands(build_ninja_file);
+
+  // Read the args.gn file, if any. Not all GN builds have one.
+  base::FilePath gn_args_file = build_dir.AppendASCII("args.gn");
+  std::string args_contents;
+  base::ReadFileToString(gn_args_file, &args_contents);
+
+  base::DeleteFile(build_dir, true);
+
+  // Put back the args.gn file (if any).
+  base::CreateDirectory(build_dir);
+  if (!args_contents.empty()) {
+    if (base::WriteFile(gn_args_file, args_contents.data(),
+                        static_cast<int>(args_contents.size())) == -1) {
+      Err(Location(), std::string("Failed to write args.gn.")).PrintToStdout();
+      return 1;
+    }
+  }
+
+  // Write the build.ninja file sufficiently to regenerate itself.
+  if (!build_commands.empty()) {
+    if (base::WriteFile(build_ninja_file, build_commands.data(),
+                        static_cast<int>(build_commands.size())) == -1) {
+      Err(Location(), std::string("Failed to write build.ninja."))
+          .PrintToStdout();
+      return 1;
+    }
+  } else {
+    // Couldn't parse the build.ninja file, write a default thing.
+    std::vector<base::FilePath::StringType> components;
+    build_ninja_file.GetComponents(&components);
+    std::string default_build_file = base::StringPrintf(
+        kDefaultNinjaFile, components[components.size() - 2].c_str());
+    if (base::WriteFile(build_ninja_file, default_build_file.data(),
+                        static_cast<int>(default_build_file.size())) == -1) {
+      Err(Location(), std::string("Failed to write build.ninja."))
+          .PrintToStdout();
+      return 1;
+    }
+  }
+
+  // Write a .d file for the build which references a nonexistant file.
+  // This will make Ninja always mark the build as dirty.
+  std::string dummy_content("build.ninja: nonexistant_file.gn\n");
+  if (base::WriteFile(build_ninja_d_file, dummy_content.data(),
+                      static_cast<int>(dummy_content.size())) == -1) {
+    Err(Location(), std::string("Failed to write build.ninja.d."))
+        .PrintToStdout();
+    return 1;
+  }
+
+  return 0;
+}
+
+}  // namespace commands