gn: Add 'clean' command.

tools/gn/command_clean.cc

+// 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.\n";

[brettw, 2015/02/16 23:35:21]

add "and creates a Ninja build environment sufficient to regenerate the build."

[tfarina, 2015/02/17 02:31:41]

Done.

+
+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();

[brettw, 2015/02/13 20:53:14]

No space after <out_dir>

[tfarina, 2015/02/17 02:31:41]

Done.

+    return 1;
+  }
+
+  Setup* setup = new Setup;
+  if (!setup->DoSetup(args[0], false) || !setup->Run())

[brettw, 2015/02/13 20:53:14]

We don't want to do this since this will read the build files. "gn clean" should
be able to do its work without actually reading any build files.

[tfarina, 2015/02/16 20:33:33]

I need the DoSetup() call because it calls FillBuildDir(), and I need it to call
FillBuildDir(), so I can get the path to build_dir.

I will remove the Run() call though, it should not be necessary for what we want
to do here.

[tfarina, 2015/02/17 02:31:41]

Done.

+    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/13 20:53:14]

We don't want this. GN clean should only delete GN build directories and it
should give errors and do nothing for other directories.

[tfarina, 2015/02/14 01:46:39]

Brett, what you mean by GN build directories? Do you want me to remove this line
or do something like traversing the output directory removing the ninja files?

+    return 1;
+  }
+
+  // GN builds aren't automatically regenerated when you sync. To avoid

[brettw, 2015/02/16 23:35:21]

This comment doesn't make sense in this context. Just start it from "Erase
everything..."

[tfarina, 2015/02/17 02:31:41]

Done.

+  // messing with the GN workflow, 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);
+
+  base::FilePath gn_args_file = build_dir.AppendASCII("args.gn");
+  std::string args_contents;
+  if (!base::ReadFileToString(gn_args_file, &args_contents)) {
+    // Not all GN builds have a args.gn file.

[brettw, 2015/02/16 23:35:21]

I'd just delete the conditional and put a comment above this block of code like:
"Read the args.gn file, if any. Not all GN builds have one."

[tfarina, 2015/02/17 02:31:41]

Done.

+  }
+
+  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