grim.asserts.RuleSet Maven / Gradle / Ivy

Go to download
package grim.asserts;

import java.nio.file.Path;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

/**
 * A collection of Rules.
 */
public final class RuleSet
{
  /**
   * Rules for symbols to omit.
   */
  @Nonnull
  private final Collection _omitRules;
  /**
   * Rules for symbols to keep.
   */
  @Nonnull
  private final Collection _keepRules;

  RuleSet( @Nonnull final Collection rules )
  {
    _omitRules = rules.stream().filter( Rule::isOmitRule ).collect( Collectors.toList() );
    _keepRules = rules.stream().filter( Rule::isKeepRule ).collect( Collectors.toList() );
  }

  @Nonnull
  Collection getOmitRules()
  {
    return _omitRules;
  }

  @Nonnull
  Collection getKeepRules()
  {
    return _keepRules;
  }

  /**
   * Combine multiple RuleSets into one RuleSet.
   *
   * @param ruleSets the rule sets to merge.
   * @return the merged RuleSet.
   */
  @Nonnull
  public static RuleSet combine( @Nonnull final RuleSet... ruleSets )
  {
    final List rules = Arrays.stream( ruleSets )
      .flatMap( ruleSet -> Stream.concat( ruleSet.getOmitRules().stream(), ruleSet.getKeepRules().stream() ) )
      .collect( Collectors.toList() );
    return new RuleSet( rules );
  }

  /**
   * Load all grim rules from the specified classloader.
   * The rules are stored files with the suffix ".grim.json" in the standard path "META-INF/grim/*".
   *
   * @param classLoader the classloader.
   * @return the collection of rules loaded from the Classloader.
   * @see #loadFromClassLoader(ClassLoader, Predicate)
   */
  @Nonnull
  public static RuleSet loadFromClassLoader( @Nonnull final ClassLoader classLoader )
  {
    return loadFromClassLoader( classLoader, null );
  }

  /**
   * Load all grim rules from the specified classloader that have classnames that match the specified filter.
   * The rules are stored files with the suffix ".grim.json" in the standard path "META-INF/grim/*".
   *
   * @param classLoader the classloader.
   * @param filter      the filter if any.
   * @return the collection of rules loaded from the Classloader.
   * @see #loadFromClassLoader(ClassLoader)
   */
  @Nonnull
  public static RuleSet loadFromClassLoader( @Nonnull final ClassLoader classLoader,
                                             @Nullable final Predicate filter )
  {
    return new RuleSet( RuleLoader.loadFromClassLoader( classLoader, filter ) );
  }

  /**
   * Load all grim rules from the archive specified.
   * The rules are stored files with the suffix ".grim.json" in the standard path "META-INF/grim/*".
   * The archive is expected to be a jar file.
   *
   * @param archivePath the path to the archive.
   * @return the collection of rules loaded from the Archive.
   * @see #loadFromArchive(Path, Predicate)
   */
  @Nonnull
  public static RuleSet loadFromArchive( @Nonnull final Path archivePath )
  {
    return loadFromArchive( archivePath, null );
  }

  /**
   * Load all grim rules from the archive specified that have classnames that match the specified filter.
   * The rules are stored files with the suffix ".grim.json" in the standard path "META-INF/grim/*".
   * The archive is expected to be a jar file.
   *
   * @param archivePath the path to the archive.
   * @param filter      the filter if any.
   * @return the collection of rules loaded from the Archive.
   * @see #loadFromArchive(Path)
   */
  @Nonnull
  public static RuleSet loadFromArchive( @Nonnull final Path archivePath, @Nullable final Predicate filter )
  {
    return new RuleSet( RuleLoader.loadFromArchive( archivePath, filter ) );
  }

  /**
   * Return true if the specified type+member combination should have been omitted given the context of the compileTimeProperties.
   *
   * @param compileTimeProperties the static compile time properties.
   * @param type                  the name of the java type.
   * @param member                the name of the member if any else the empty string.
   * @return true if the symbol should be omitted.
   */
  public boolean shouldOmitSymbol( @Nonnull final Map compileTimeProperties,
                                   @Nonnull final String type,
                                   @Nonnull final String member )
  {
    return _omitRules.stream().anyMatch( r1 -> r1.matches( compileTimeProperties, type, member ) ) &&
           _keepRules.stream().noneMatch( r -> r.matches( compileTimeProperties, type, member ) );
  }
}