tree 41ecd7ff440f9477b55fb4e040ab763b6e058343
parent 8ec3632e62bc519dd5842e2c86925d27538b751b
author Chih-Hung Hsieh <chh@google.com> 1551124513 -0800
committer Chih-Hung Hsieh <chh@google.com> 1551379691 -0800

Add per-file set noparent and more tests

* Implement new "per-file <globs> = set noparent" statement.
  * Update syntax.md with better explanations and examples.
  * Remove duplicated syntax comment in Parser.java.
  * Semantics of "per-file <globs> = <owner-email-list>" is changed.
    Files matching the <globs> now inherit global non-per-file owners
    unless "per-file <globs> = set noparent" is used.
  * For example, to assign only jj@g.com as the owner of *.java files:
      per-file *.java = jj@g.com
      per-file *.java = set noparent
* Fix error in Parser.Result.append; add test case.
* Add more tests in ParserTest, FindOwnersIT, OwnersValidatorTest.

Change-Id: I43a306bc9af85badc40b44507d4b2d021888ecd4
