Sort "deps" and "public_deps" when running the "gn format" command.

tools/gn/parse_tree.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 "tools/gn/parse_tree.h"
 
 #include <string>
 #include <tuple>
 
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/operators.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/string_utils.h"
 
 namespace {
 
+enum DepsCategory {
+  kDepsCategoryLocal = 0,

[tfarina, 2015/12/02 20:19:32]

my understanding from the style-guide is that this should be ALL_CAPS. Do you
mind changing?

[scottmg, 2015/12/02 22:12:12]

nit; Drop the " = N" since it's just for ordering purposes and they're all
default values anyway.

[sdefresne, 2015/12/03 09:30:00]

Done both (dropped = N, used ALL_CAPS).

+  kDepsCategoryRelative = 1,
+  kDepsCategoryAbsolute = 2,
+  kDepsCategoryOther = 3,
+};
+
+DepsCategory GetDepsCategory(base::StringPiece deps) {

[tfarina, 2015/12/02 20:19:32]

is it more recommended to pass it by value rather than ref-to-const?

[sdefresne, 2015/12/03 09:30:00]

base/strings/string_piece.h recommends passing by value:
// Prefer passing StringPieces by value:
//   void MyFunction(StringPiece arg);

https://code.google.com/p/chromium/codesearch#chromium/src/base/strings/strin...

+  if (deps.length() < 2 || deps[0] != '"' || deps[deps.size() - 1] != '"')
+    return kDepsCategoryOther;
+
+  if (deps[1] == ':')
+    return kDepsCategoryLocal;
+
+  if (deps[1] == '/')
+    return kDepsCategoryAbsolute;
+
+  return kDepsCategoryRelative;
+}
+
 std::tuple<base::StringPiece, base::StringPiece> SplitAtFirst(
     base::StringPiece str,
     char c) {
   if (!str.starts_with("\"") || !str.ends_with("\""))
     return std::make_tuple(str, base::StringPiece());
 
   str = str.substr(1, str.length() - 2);
   size_t index_of_first = str.find(c);
   return std::make_tuple(str.substr(0, index_of_first),
                          index_of_first != base::StringPiece::npos
@@ skipping 554 matching lines @@
     return astr < bstr;
   });
 }
 
 void ListNode::SortAsDepsList() {
   // Sorts first relative targets, then absolute, each group is sorted
   // alphabetically.
   SortList([](const ParseNode* a, const ParseNode* b) {
     base::StringPiece astr = GetStringRepresentation(a);
     base::StringPiece bstr = GetStringRepresentation(b);
-    return SplitAtFirst(astr, ':') < SplitAtFirst(bstr, ':');
+    return std::make_pair(GetDepsCategory(astr), SplitAtFirst(astr, ':')) <
+           std::make_pair(GetDepsCategory(bstr), SplitAtFirst(bstr, ':'));
   });
 }
 
 // Breaks the ParseNodes of |contents| up by ranges that should be separately
 // sorted. In particular, we break at a block comment, or an item that has an
 // attached "before" comment and is separated by a blank line from the item
 // before it. The assumption is that both of these indicate a separate 'section'
 // of a sources block across which items should not be inter-sorted.
 std::vector<ListNode::SortRange> ListNode::GetSortRanges() const {
   std::vector<SortRange> ranges;
@@ skipping 203 matching lines @@
 
 Err EndNode::MakeErrorDescribing(const std::string& msg,
                                         const std::string& help) const {
   return Err(value_, msg, help);
 }
 
 void EndNode::Print(std::ostream& out, int indent) const {
   out << IndentFor(indent) << "END(" << value_.value() << ")\n";
   PrintComments(out, indent);
 }