com.mycila.maven.plugin.license.header.HeaderDefinition Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of license-maven-plugin Show documentation
Maven 2 plugin to check and update license headers in source files
The newest version!
/*
 * Copyright (C) 2008-2024 Mycila ([email protected])
 *
 * 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
 *
 *         https://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.mycila.maven.plugin.license.header;

import java.util.regex.Pattern;

/**
 * The HeaderDefinition class defines what is needed to output a header text into the of the given file
 * type and what is needed to match the first line as well as the last line of a previous header of the given file
 * type. Optionally you can define the lines you want to skip before outputting the header.
 */
public final class HeaderDefinition {
  private final String type;
  private String firstLine = "";
  private String beforeEachLine = "";
  private String endLine = "";
  private String afterEachLine = "";
  private Boolean allowBlankLines;

  private Pattern skipLinePattern;
  private Pattern firstLineDetectionPattern;
  private Pattern lastLineDetectionPattern;
  private Boolean multiLine;

  private boolean padLines;

  /**
   * Constructs a new HeaderDefinition object with every header definition properties.
   *
   * @param type                      The type name for this header definition.
   * @param firstLine                 The string to output before the content of the first line of this header.
   * @param beforeEachLine            The string to output before the content of each line of this header (except
   *                                  firstLine and endLine).
   * @param endLine                   The string to output before the content of the last line of this header.
   * @param afterEachLine             The string to output after the content of each line of this header (except
   *                                  firstLine and endLine).
   * @param skipLinePattern           The pattern of lines to skip before being allowed to output this header or null
   *                                  if it can be outputted from the line of the file.
   * @param firstLineDetectionPattern The pattern to detect the first line of a previous header.
   * @param lastLineDetectionPattern  The pattern to detect the last line of a previous header.
   * @param allowBlankLines           The allow blank lines flag.
   * @param multiLine                 The multi line flag.
   * @param padLines                  The pad lines flag.
   * @throws IllegalArgumentException If the type name is null.
   */
  public HeaderDefinition(String type,
                          String firstLine, String beforeEachLine,
                          String endLine, String afterEachLine,
                          String skipLinePattern,
                          String firstLineDetectionPattern, String lastLineDetectionPattern,
                          boolean allowBlankLines, boolean multiLine, boolean padLines) {
    this(type);
    this.firstLine = firstLine;
    this.beforeEachLine = beforeEachLine;
    this.endLine = endLine;
    this.afterEachLine = afterEachLine;
    this.skipLinePattern = compile(skipLinePattern);
    this.firstLineDetectionPattern = compile(firstLineDetectionPattern);
    this.lastLineDetectionPattern = compile(lastLineDetectionPattern);
    this.allowBlankLines = allowBlankLines;
    this.multiLine = multiLine;
    this.padLines = padLines;
    if (!"unknown".equals(type)) {
      validate();
    }
    if (allowBlankLines && !multiLine) {
      throw new IllegalArgumentException("Header style " + type + " is configured to allow blank lines, so it should be set as a multi-line header style");
    }
  }

  /**
   * Constructs a new HeaderDefinition with only initializing the header type. You must then set all the
   * other definitions properties manually in order to have a coherent object.
   *
   * @param type The type name for this header definition.
   * @throws IllegalArgumentException If the type name is null.
   * @see #check(String, String)
   * @see #setPropertyFromString(String, String)
   */
  public HeaderDefinition(String type) {
    if (type == null) {
      throw new IllegalArgumentException("The type of a header definition cannot be null");
    }
    this.type = type.toLowerCase();
  }

  private Pattern compile(String regexp) {
    return regexp == null ? null : Pattern.compile(regexp);
  }

  public String getFirstLine() {
    return firstLine;
  }

  public String getBeforeEachLine() {
    return beforeEachLine;
  }

  public String getEndLine() {
    return endLine;
  }

  public String getAfterEachLine() {
    return afterEachLine;
  }

  public String getType() {
    return type;
  }

  public boolean allowBlankLines() {
    return allowBlankLines;
  }

  public boolean isPadLines() {
    return padLines;
  }

  /**
   * Tells if the given content line must be skipped according to this header definition. The header is outputted
   * after any skipped line if any pattern defined on this point or on the first line if not pattern defined.
   *
   * @param line The line to test.
   * @return true if this line must be skipped or false.
   */
  public boolean isSkipLine(String line) {
    return skipLinePattern != null && line != null && skipLinePattern.matcher(line).matches();
  }

  /**
   * Tells if the given content line is the first line of a possible header of this definition kind.
   *
   * @param line The line to test.
   * @return true if the first line of a header have been recognized or false.
   */
  public boolean isFirstHeaderLine(String line) {
    return firstLineDetectionPattern != null && line != null && firstLineDetectionPattern.matcher(line).matches();
  }

  /**
   * Tells if the given content line is the last line of a possible header of this definition kind.
   *
   * @param line The line to test.
   * @return true if the last line of a header have been recognized or false.
   */
  public boolean isLastHeaderLine(String line) {
    return lastLineDetectionPattern != null && line != null && lastLineDetectionPattern.matcher(line).matches();
  }

  protected Pattern getSkipLinePattern() {
    return skipLinePattern;
  }

  /**
   * Sets header definition properties using its property name and its string value.
 If you want to set a property
   * to null you must not call this function. This function is mainly used while parsing properties from the XML
   * configuration file.
   *
   * @param property The property name.
   * @param value    The property value.
   * @throws IllegalArgumentException If the property value is null.
   */
  public void setPropertyFromString(String property, String value) {
    if (isEmpty(value)) {
      throw new IllegalArgumentException("The value cannot be empty for XML tag " + property + " for type " + type);
    }
    if ("firstLine".equalsIgnoreCase(property)) {
      firstLine = value;
    } else if ("allowBlankLines".equalsIgnoreCase(property)) {
      allowBlankLines = Boolean.valueOf(value);
    } else if ("multiLine".equalsIgnoreCase(property) || "isMultiline".equalsIgnoreCase(property)) {
      multiLine = Boolean.valueOf(value);
    } else if ("beforeEachLine".equalsIgnoreCase(property)) {
      beforeEachLine = value;
    } else if ("endLine".equalsIgnoreCase(property)) {
      endLine = value;
    } else if ("afterEachLine".equalsIgnoreCase(property)) {
      afterEachLine = value;
    } else if ("skipLine".equalsIgnoreCase(property)) {
      skipLinePattern = compile(value);
    } else if ("padLines".equalsIgnoreCase(property)) {
      padLines = Boolean.parseBoolean(value);
    } else if ("firstLineDetectionPattern".equalsIgnoreCase(property)) {
      firstLineDetectionPattern = compile(value);
    } else if ("lastLineDetectionPattern".equalsIgnoreCase(property)) {
      lastLineDetectionPattern = compile(value);
    }
  }

  /**
   * Checks this header definition consistency, in other words if all the mandatory properties of the definition have
   * been set.
   *
   * @throws IllegalStateException If a mandatory property has not been set.
   */
  public void validate() {
    check("firstLine", this.firstLine);
    check("beforeEachLine", this.beforeEachLine);
    check("endLine", this.endLine);
    check("afterEachLine", this.afterEachLine);
    check("firstLineDetectionPattern", this.firstLineDetectionPattern);
    check("lastLineDetectionPattern", this.lastLineDetectionPattern);
    check("multiLine", this.multiLine);
    check("allowBlankLines", this.allowBlankLines);
    // skip line can be null
  }

  private void check(String name, Boolean value) {
    if (value == null) {
      throw new IllegalStateException(String.format("The property '%s' is missing for header definition '%s'", name, type));
    }
  }

  private void check(String name, String value) {
    if (value == null) {
      throw new IllegalStateException(String.format("The property '%s' is missing for header definition '%s'", name, type));
    }
  }

  private void check(String name, Pattern value) {
    if (isEmpty(value.pattern())) {
      throw new IllegalStateException(String.format("The property '%s' is missing for header definition '%s'", name, type));
    }
  }

  private boolean isEmpty(String s) {
    return s == null || "".equals(s);
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }
    HeaderDefinition that = (HeaderDefinition) o;
    return !(type != null ? !type.equals(that.type) : that.type != null);
  }

  @Override
  public int hashCode() {
    return type != null ? type.hashCode() : 0;
  }

  @Override
  public String toString() {
    return type;
  }

  public boolean isMultiLine() {
    return multiLine;
  }
}