java/com/google/gerrit/plugins/codeowners/backend/CodeOwnerSet.java - plugins/code-owners - Git at Google

 // Copyright (C) 2020 The Android Open Source Project
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package com.google.gerrit.plugins.codeowners.backend;

 import static com.google.common.base.Preconditions.checkState;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static java.util.Objects.requireNonNull;

 import com.google.auto.value.AutoValue;
 import com.google.common.collect.ImmutableMultimap;
 import com.google.common.collect.ImmutableSet;
 import java.util.Arrays;
 import java.util.Set;

 /**
  * A code owner set defines a set of code owners for a set of path expressions.
  *
  * <p>The code owners own the files that match any of the path expressions.
  *
  * <p>Code owner sets are stored in {@link CodeOwnerConfig}s which define code owners for the folder
  * in which they are stored.
  *
  * <p>The path expressions are relative to the folder of the {@link CodeOwnerConfig} that contains
  * the owner set.
  *
  * <p>If the set of path expressions is empty the code owners apply for all files in the folder of
  * the {@link CodeOwnerConfig} (including files in sub folders).
  */
 @AutoValue
 public abstract class CodeOwnerSet {
   /**
    * Gets whether global code owners (code owners from code owner sets without path expression in
    * the same code owner config) and code owners from parent code owner configs (code owner configs
    * in parent folders) should be ignored.
    *
    * <p>Code owner configs are organized hierarchically, e.g. the code owner config at "/" is the
    * parent config of the code owner config at "/foo" which in turn is the parent config of the code
    * owner config at "/foo/bar". Code owners from the parent config can be ignored by setting {@link
    * CodeOwnerConfig#ignoreParentCodeOwners()} on code owner config level.
    *
    * <p>In addition there are 2 hierarchy levels within each code owner config. 1. global code
    * owners applying to all files in the folder (represented by code owner sets without path
    * expressions), 2. per file code owners (represented by code owner sets with path expressions).
    * On per file level it is possible to ignore the global code owners (code owner sets without path
    * expressions) by setting {@link #ignoreGlobalAndParentCodeOwners()} on the code owner set. If
    * {@link #ignoreGlobalAndParentCodeOwners()} is set, implicitly for matching files also all code
    * owners inherited from parent code owner configs are ignored.
    *
    * <p>If a matching code owner set ignores global and parent code owners, matching sibling code
    * owner sets (other code owner sets with matching path expressions in the same code owner config)
    * are still honored.
    */
   public abstract boolean ignoreGlobalAndParentCodeOwners();

   /** Path expressions that match the files that are owned by the {@link #codeOwners()}. */
   public abstract ImmutableSet<String> pathExpressions();

   /** Gets references to the code owner configs that should be imported. */
   public abstract ImmutableSet<CodeOwnerConfigReference> imports();

   /** Gets the code owners of this code owner set. */
   public abstract ImmutableSet<CodeOwnerReference> codeOwners();

   /** Gets the annotations of the {@link #codeOwners()}. */
   public abstract ImmutableMultimap<CodeOwnerReference, CodeOwnerAnnotation> annotations();

   /**
    * Creates a builder from this code owner set.
    *
    * @return builder that was created from this code owner set
    */
   public abstract Builder toBuilder();

   /** Creates a builder for a {@link CodeOwnerSet}. */
   public static CodeOwnerSet.Builder builder() {
     return new AutoValue_CodeOwnerSet.Builder()
         .setIgnoreGlobalAndParentCodeOwners(false)
         .setPathExpressions(ImmutableSet.of());
   }

   /**
    * Creates a {@link CodeOwnerSet} instance without path expressions.
    *
    * @param codeOwners the code owners of the code owner set
    */
   public static CodeOwnerSet createWithoutPathExpressions(
       ImmutableSet<CodeOwnerReference> codeOwners) {
     return builder().setCodeOwners(codeOwners).build();
   }

   /**
    * Creates a {@link CodeOwnerSet} instance without path expressions.
    *
    * @param emails the emails of the code owners
    */
   public static CodeOwnerSet createWithoutPathExpressions(String... emails) {
     return createWithoutPathExpressions(
         Arrays.stream(emails).map(CodeOwnerReference::create).collect(toImmutableSet()));
   }

   @AutoValue.Builder
   public abstract static class Builder {
     /**
      * Sets whether global code owners (code owners from code owner sets without path expression in
      * the same code owner config) and code owners from parent code owner configs (code owner
      * configs in parent folders) should be ignored.
      *
      * @param ignoreGlobalAndParentCodeOwners whether global code owners and code owners from parent
      *     code owner configs should be ignored
      * @return the Builder instance for chaining calls
      * @see CodeOwnerSet#ignoreGlobalAndParentCodeOwners()
      */
     public abstract Builder setIgnoreGlobalAndParentCodeOwners(
         boolean ignoreGlobalAndParentCodeOwners);

     /**
      * Sets that global code owners (code owners from code owner sets without path expression in the
      * same code owner config) and code owners from parent code owner configs (code owner configs in
      * parent folders) should be ignored.
      *
      * @return the Builder instance for chaining calls
      * @see CodeOwnerSet#ignoreGlobalAndParentCodeOwners()
      */
     public Builder setIgnoreGlobalAndParentCodeOwners() {
       return setIgnoreGlobalAndParentCodeOwners(true);
     }

     /**
      * Sets the path expressions that match the files that are owned by the code owners.
      *
      * @param pathExpressions the path expressions
      * @return the Builder instance for chaining calls
      */
     public abstract Builder setPathExpressions(ImmutableSet<String> pathExpressions);

     /** Gets a builder to add path expressions. */
     abstract ImmutableSet.Builder<String> pathExpressionsBuilder();

     /**
      * Adds a path expression.
      *
      * @param pathExpression path expression that should be added
      * @return the Builder instance for chaining calls
      */
     public Builder addPathExpression(String pathExpression) {
       pathExpressionsBuilder().add(requireNonNull(pathExpression, "pathExpression"));
       return this;
     }

     /**
      * Sets the imports of this code owner set.
      *
      * @param codeOwnerConfigReferences references to the code owner configs that should be imported
      * @return the Builder instance for chaining calls
      */
     public abstract Builder setImports(
         ImmutableSet<CodeOwnerConfigReference> codeOwnerConfigReferences);

     /** Gets a builder to add imports. */
     abstract ImmutableSet.Builder<CodeOwnerConfigReference> importsBuilder();

     /**
      * Adds an import.
      *
      * @param codeOwnerConfigReference reference to the code owner config that should be imported
      * @return the Builder instance for chaining calls
      */
     public Builder addImport(CodeOwnerConfigReference codeOwnerConfigReference) {
       importsBuilder().add(requireNonNull(codeOwnerConfigReference, "codeOwnerConfigReference"));
       return this;
     }

     /**
      * Sets the code owners of this code owner set.
      *
      * @param codeOwners the code owners of this code owner set
      * @return the Builder instance for chaining calls
      */
     public abstract Builder setCodeOwners(ImmutableSet<CodeOwnerReference> codeOwners);

     /** Gets a builder to add code owner references. */
     abstract ImmutableSet.Builder<CodeOwnerReference> codeOwnersBuilder();

     /**
      * Adds a code owner.
      *
      * @param codeOwnerReference reference to the code owner
      * @return the Builder instance for chaining calls
      */
     public Builder addCodeOwner(CodeOwnerReference codeOwnerReference) {
       codeOwnersBuilder().add(requireNonNull(codeOwnerReference, "codeOwnerReference"));
       return this;
     }

     /** Gets a builder to add code owner annotations. */
     abstract ImmutableMultimap.Builder<CodeOwnerReference, CodeOwnerAnnotation>
         annotationsBuilder();

     /**
      * Adds an annotation for a code owner.
      *
      * @param email email of the code owner for which the annotation should be added
      * @param annotation annotation that should be added
      * @return the Builder instance for chaining calls
      */
     public Builder addAnnotation(String email, CodeOwnerAnnotation annotation) {
       return addAnnotations(CodeOwnerReference.create(email), ImmutableSet.of(annotation));
     }

     /**
      * Adds annotations for a code owner.
      *
      * @param codeOwnerReference reference to the code owner for which the annotations should be
      *     added
      * @param annotations annotations that should be added
      * @return the Builder instance for chaining calls
      */
     public Builder addAnnotations(
         CodeOwnerReference codeOwnerReference, Set<CodeOwnerAnnotation> annotations) {
       requireNonNull(codeOwnerReference, "codeOwnerReference");
       requireNonNull(annotations, "annotations");
       annotationsBuilder().putAll(codeOwnerReference, annotations);
       return this;
     }

     /**
      * Adds a code owner for the given email.
      *
      * @param email email of the code owner
      * @return the Builder instance for chaining calls
      */
     public Builder addCodeOwnerEmail(String email) {
       return addCodeOwner(CodeOwnerReference.create(requireNonNull(email, "codeOwnerEmail")));
     }

     /** Builds the {@link CodeOwnerSet} instance. */
     public CodeOwnerSet build() {
       CodeOwnerSet codeOwnerSet = autoBuild();
       checkState(
           !(codeOwnerSet.ignoreGlobalAndParentCodeOwners()
               && codeOwnerSet.pathExpressions().isEmpty()),
           "ignoreGlobalAndParentCodeOwners = true is not allowed for code owner set without path"
               + " expressions");
       checkState(
           !(!codeOwnerSet.imports().isEmpty() && codeOwnerSet.pathExpressions().isEmpty()),
           "imports are not allowed for code owner set without path expressions");
       checkState(
           codeOwnerSet.imports().stream()
               .allMatch(
                   codeOwnerConfigReference ->
                       CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY.equals(
                           codeOwnerConfigReference.importMode())),
           "imports in code owner set must have have import mode %s",
           CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY.name());
       return codeOwnerSet;
     }

     abstract CodeOwnerSet autoBuild();
   }
 }
	// Copyright (C) 2020 The Android Open Source Project
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package com.google.gerrit.plugins.codeowners.backend;

	import static com.google.common.base.Preconditions.checkState;
	import static com.google.common.collect.ImmutableSet.toImmutableSet;
	import static java.util.Objects.requireNonNull;

	import com.google.auto.value.AutoValue;
	import com.google.common.collect.ImmutableMultimap;
	import com.google.common.collect.ImmutableSet;
	import java.util.Arrays;
	import java.util.Set;

	/**
	* A code owner set defines a set of code owners for a set of path expressions.
	*
	* <p>The code owners own the files that match any of the path expressions.
	*
	* <p>Code owner sets are stored in {@link CodeOwnerConfig}s which define code owners for the folder
	* in which they are stored.
	*
	* <p>The path expressions are relative to the folder of the {@link CodeOwnerConfig} that contains
	* the owner set.
	*
	* <p>If the set of path expressions is empty the code owners apply for all files in the folder of
	* the {@link CodeOwnerConfig} (including files in sub folders).
	*/
	@AutoValue
	public abstract class CodeOwnerSet {
	/**
	* Gets whether global code owners (code owners from code owner sets without path expression in
	* the same code owner config) and code owners from parent code owner configs (code owner configs
	* in parent folders) should be ignored.
	*
	* <p>Code owner configs are organized hierarchically, e.g. the code owner config at "/" is the
	* parent config of the code owner config at "/foo" which in turn is the parent config of the code
	* owner config at "/foo/bar". Code owners from the parent config can be ignored by setting {@link
	* CodeOwnerConfig#ignoreParentCodeOwners()} on code owner config level.
	*
	* <p>In addition there are 2 hierarchy levels within each code owner config. 1. global code
	* owners applying to all files in the folder (represented by code owner sets without path
	* expressions), 2. per file code owners (represented by code owner sets with path expressions).
	* On per file level it is possible to ignore the global code owners (code owner sets without path
	* expressions) by setting {@link #ignoreGlobalAndParentCodeOwners()} on the code owner set. If
	* {@link #ignoreGlobalAndParentCodeOwners()} is set, implicitly for matching files also all code
	* owners inherited from parent code owner configs are ignored.
	*
	* <p>If a matching code owner set ignores global and parent code owners, matching sibling code
	* owner sets (other code owner sets with matching path expressions in the same code owner config)
	* are still honored.
	*/
	public abstract boolean ignoreGlobalAndParentCodeOwners();

	/** Path expressions that match the files that are owned by the {@link #codeOwners()}. */
	public abstract ImmutableSet<String> pathExpressions();

	/** Gets references to the code owner configs that should be imported. */
	public abstract ImmutableSet<CodeOwnerConfigReference> imports();

	/** Gets the code owners of this code owner set. */
	public abstract ImmutableSet<CodeOwnerReference> codeOwners();

	/** Gets the annotations of the {@link #codeOwners()}. */
	public abstract ImmutableMultimap<CodeOwnerReference, CodeOwnerAnnotation> annotations();

	/**
	* Creates a builder from this code owner set.
	*
	* @return builder that was created from this code owner set
	*/
	public abstract Builder toBuilder();

	/** Creates a builder for a {@link CodeOwnerSet}. */
	public static CodeOwnerSet.Builder builder() {
	return new AutoValue_CodeOwnerSet.Builder()
	.setIgnoreGlobalAndParentCodeOwners(false)
	.setPathExpressions(ImmutableSet.of());
	}

	/**
	* Creates a {@link CodeOwnerSet} instance without path expressions.
	*
	* @param codeOwners the code owners of the code owner set
	*/
	public static CodeOwnerSet createWithoutPathExpressions(
	ImmutableSet<CodeOwnerReference> codeOwners) {
	return builder().setCodeOwners(codeOwners).build();
	}

	/**
	* Creates a {@link CodeOwnerSet} instance without path expressions.
	*
	* @param emails the emails of the code owners
	*/
	public static CodeOwnerSet createWithoutPathExpressions(String... emails) {
	return createWithoutPathExpressions(
	Arrays.stream(emails).map(CodeOwnerReference::create).collect(toImmutableSet()));
	}

	@AutoValue.Builder
	public abstract static class Builder {
	/**
	* Sets whether global code owners (code owners from code owner sets without path expression in
	* the same code owner config) and code owners from parent code owner configs (code owner
	* configs in parent folders) should be ignored.
	*
	* @param ignoreGlobalAndParentCodeOwners whether global code owners and code owners from parent
	* code owner configs should be ignored
	* @return the Builder instance for chaining calls
	* @see CodeOwnerSet#ignoreGlobalAndParentCodeOwners()
	*/
	public abstract Builder setIgnoreGlobalAndParentCodeOwners(
	boolean ignoreGlobalAndParentCodeOwners);

	/**
	* Sets that global code owners (code owners from code owner sets without path expression in the
	* same code owner config) and code owners from parent code owner configs (code owner configs in
	* parent folders) should be ignored.
	*
	* @return the Builder instance for chaining calls
	* @see CodeOwnerSet#ignoreGlobalAndParentCodeOwners()
	*/
	public Builder setIgnoreGlobalAndParentCodeOwners() {
	return setIgnoreGlobalAndParentCodeOwners(true);
	}

	/**
	* Sets the path expressions that match the files that are owned by the code owners.
	*
	* @param pathExpressions the path expressions
	* @return the Builder instance for chaining calls
	*/
	public abstract Builder setPathExpressions(ImmutableSet<String> pathExpressions);

	/** Gets a builder to add path expressions. */
	abstract ImmutableSet.Builder<String> pathExpressionsBuilder();

	/**
	* Adds a path expression.
	*
	* @param pathExpression path expression that should be added
	* @return the Builder instance for chaining calls
	*/
	public Builder addPathExpression(String pathExpression) {
	pathExpressionsBuilder().add(requireNonNull(pathExpression, "pathExpression"));
	return this;
	}

	/**
	* Sets the imports of this code owner set.
	*
	* @param codeOwnerConfigReferences references to the code owner configs that should be imported
	* @return the Builder instance for chaining calls
	*/
	public abstract Builder setImports(
	ImmutableSet<CodeOwnerConfigReference> codeOwnerConfigReferences);

	/** Gets a builder to add imports. */
	abstract ImmutableSet.Builder<CodeOwnerConfigReference> importsBuilder();

	/**
	* Adds an import.
	*
	* @param codeOwnerConfigReference reference to the code owner config that should be imported
	* @return the Builder instance for chaining calls
	*/
	public Builder addImport(CodeOwnerConfigReference codeOwnerConfigReference) {
	importsBuilder().add(requireNonNull(codeOwnerConfigReference, "codeOwnerConfigReference"));
	return this;
	}

	/**
	* Sets the code owners of this code owner set.
	*
	* @param codeOwners the code owners of this code owner set
	* @return the Builder instance for chaining calls
	*/
	public abstract Builder setCodeOwners(ImmutableSet<CodeOwnerReference> codeOwners);

	/** Gets a builder to add code owner references. */
	abstract ImmutableSet.Builder<CodeOwnerReference> codeOwnersBuilder();

	/**
	* Adds a code owner.
	*
	* @param codeOwnerReference reference to the code owner
	* @return the Builder instance for chaining calls
	*/
	public Builder addCodeOwner(CodeOwnerReference codeOwnerReference) {
	codeOwnersBuilder().add(requireNonNull(codeOwnerReference, "codeOwnerReference"));
	return this;
	}

	/** Gets a builder to add code owner annotations. */
	abstract ImmutableMultimap.Builder<CodeOwnerReference, CodeOwnerAnnotation>
	annotationsBuilder();

	/**
	* Adds an annotation for a code owner.
	*
	* @param email email of the code owner for which the annotation should be added
	* @param annotation annotation that should be added
	* @return the Builder instance for chaining calls
	*/
	public Builder addAnnotation(String email, CodeOwnerAnnotation annotation) {
	return addAnnotations(CodeOwnerReference.create(email), ImmutableSet.of(annotation));
	}

	/**
	* Adds annotations for a code owner.
	*
	* @param codeOwnerReference reference to the code owner for which the annotations should be
	* added
	* @param annotations annotations that should be added
	* @return the Builder instance for chaining calls
	*/
	public Builder addAnnotations(
	CodeOwnerReference codeOwnerReference, Set<CodeOwnerAnnotation> annotations) {
	requireNonNull(codeOwnerReference, "codeOwnerReference");
	requireNonNull(annotations, "annotations");
	annotationsBuilder().putAll(codeOwnerReference, annotations);
	return this;
	}

	/**
	* Adds a code owner for the given email.
	*
	* @param email email of the code owner
	* @return the Builder instance for chaining calls
	*/
	public Builder addCodeOwnerEmail(String email) {
	return addCodeOwner(CodeOwnerReference.create(requireNonNull(email, "codeOwnerEmail")));
	}

	/** Builds the {@link CodeOwnerSet} instance. */
	public CodeOwnerSet build() {
	CodeOwnerSet codeOwnerSet = autoBuild();
	checkState(
	!(codeOwnerSet.ignoreGlobalAndParentCodeOwners()
	&& codeOwnerSet.pathExpressions().isEmpty()),
	"ignoreGlobalAndParentCodeOwners = true is not allowed for code owner set without path"
	+ " expressions");
	checkState(
	!(!codeOwnerSet.imports().isEmpty() && codeOwnerSet.pathExpressions().isEmpty()),
	"imports are not allowed for code owner set without path expressions");
	checkState(
	codeOwnerSet.imports().stream()
	.allMatch(
	codeOwnerConfigReference ->
	CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY.equals(
	codeOwnerConfigReference.importMode())),
	"imports in code owner set must have have import mode %s",
	CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY.name());
	return codeOwnerSet;
	}

	abstract CodeOwnerSet autoBuild();
	}
	}