[Findit] Initial code of findit for crash. Add scorers to apply heuristic rules.

appengine/findit/crash/crash_util.py

Index: appengine/findit/crash/crash_util.py
diff --git a/appengine/findit/crash/crash_util.py b/appengine/findit/crash/crash_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..8cff9bf3e9518530dd6c8a5a4d52c6d4d0caac55
--- /dev/null
+++ b/appengine/findit/crash/crash_util.py
@@ -0,0 +1,27 @@
+# Copyright 2016 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.
+
+
+def IsSameFilePath(path1, path2):
+  """Determines if two paths represent same path.
+
+  Compares the name of the folders in the path (by split('/')), and checks
+  if they match either more than 3 or min of path lengths.

[Martin Barbella, 2016/04/18 21:01:18]

I'm not fully convinced that this is right, but it may be fine for now. Is there
any more reliable way we could deal with file moves?

[Sharu Jiang, 2016/04/19 20:38:37]

Not a reliable way either but an alternative is to compute the difference
instead of similarity, for example if there are more than 2 parts different, we
think it's not the same path.

If we want to be very sure whether 2 paths are the same file, we may have to
track down all the file path change in very revision(implement a link list
maybe). That may be a big change. 

Add a TODO here to improve later.

[stgao, 2016/04/20 17:41:26]

Have you explored the different change types Gitiles provides?
There should be a better way to detect file move.
https://chromium.googlesource.com/infra/infra/+/master/appengine/findit/commo...

It seems that getting more familiar with the Gitiles APIs will make the
implementation easier.

[Sharu Jiang, 2016/04/21 02:06:01]

Yes, the copy/rename change type can help me detect the file move, but still, we
cannot avoid tracking all the revisions from crashed revision to the beginning
of regression range revision. (maybe use a set to group all the same file paths)

We can do this in a separate cl. 

[stgao, 2016/04/21 17:31:53]

If we plan to make this change, a bug should be created and a TODO be added
here.

+
+  Args:
+    path1 (str): First path.
+    path2 (str): Second path to compare.
+
+  Returns:
+    Boolean, True if it they are thought to be a same path, False otherwise.
+  """
+  path_parts_1 = path1.lower().split('/')
+  path_parts_2 = path2.lower().split('/')
+
+  if path_parts_1[-1] != path_parts_2[-1]:
+    return False
+
+  intersection = set(path_parts_1).intersection(set(path_parts_2))

[Martin Barbella, 2016/04/18 21:01:18]

Set intersection might not be ideal here. I didn't dig into it, but I don't
think we have any guarantee that two directories in a path won't have the same
name.

[Sharu Jiang, 2016/04/19 20:38:37]

Done.

+  return len(intersection) >= (min(3, min(len(path_parts_1),
+                                          len(path_parts_2))))