java.lang.Object
- org.projectnessie.model.Validation

public final class Validation
extends java.lang.Object

Collection of validation rules.

Field Summary

Fields
Modifier and Type	Field	Description
`static java.lang.String`	`DEFAULT_CUT_OFF_POLICY_MESSAGE`
`static java.util.regex.Pattern`	`DEFAULT_CUT_OFF_POLICY_PATTERN`
`static java.lang.String`	`DEFAULT_CUT_OFF_POLICY_REGEX`
`static java.lang.String`	`FORBIDDEN_REF_NAME_MESSAGE`
`static java.util.Set<java.lang.String>`	`FORBIDDEN_REF_NAMES`
`static java.lang.String`	`HASH_MESSAGE`
`static java.lang.String`	`HASH_OR_RELATIVE_COMMIT_SPEC_MESSAGE`
`static java.util.regex.Pattern`	`HASH_OR_RELATIVE_COMMIT_SPEC_PATTERN`
`static java.lang.String`	`HASH_OR_RELATIVE_COMMIT_SPEC_RAW_REGEX`	Regex with an optional hash and a sequence of relative lookups, which can be by-timestamp, by-n-th-predecessor or by-n-th-parent.
`static java.lang.String`	`HASH_OR_RELATIVE_COMMIT_SPEC_REGEX`
`static java.lang.String`	`HASH_OR_RELATIVE_COMMIT_SPEC_RULE`
`static java.util.regex.Pattern`	`HASH_PATTERN`
`static java.lang.String`	`HASH_RAW_REGEX`
`static java.lang.String`	`HASH_REGEX`
`static java.lang.String`	`HASH_RULE`
`static java.lang.String`	`REF_NAME_MESSAGE`
`static java.lang.String`	`REF_NAME_OR_HASH_MESSAGE`
`static java.util.regex.Pattern`	`REF_NAME_OR_HASH_PATTERN`
`static java.lang.String`	`REF_NAME_OR_HASH_REGEX`
`static java.util.regex.Pattern`	`REF_NAME_PATH_ELEMENT_PATTERN`
`static java.lang.String`	`REF_NAME_PATH_ELEMENT_REGEX`
`static java.lang.String`	`REF_NAME_PATH_MESSAGE`
`static java.util.regex.Pattern`	`REF_NAME_PATH_PATTERN`
`static java.lang.String`	`REF_NAME_PATH_REGEX`
`static java.util.regex.Pattern`	`REF_NAME_PATTERN`
`static java.lang.String`	`REF_NAME_RAW_REGEX`
`static java.lang.String`	`REF_NAME_REGEX`
`static java.lang.String`	`REF_TYPE_MESSAGE`
`static java.lang.String`	`REF_TYPE_RAW_REGEX`
`static java.lang.String`	`REF_TYPE_REGEX`
`static java.lang.String`	`REF_TYPE_RULE`
`static java.util.regex.Pattern`	`RELATIVE_COMMIT_SPEC_PART_PATTERN`
`static java.lang.String`	`RELATIVE_COMMIT_SPEC_RAW_REGEX`
`static java.lang.String`	`RELATIVE_COMMIT_SPEC_RULE`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static boolean`	`isForbiddenReferenceName(java.lang.String ref)`	Checks whether `ref` represents a forbidden reference name (`HEAD` or `DETACHED`) or could represent a commit-ID.
`static boolean`	`isValidHash(java.lang.String hash)`	Just checks whether a string is a valid hash, but doesn't throw an exception.
`static boolean`	`isValidHashOrRelativeSpec(java.lang.String hash)`	Just checks whether a string is a valid hash and/or a relative spec, but doesn't throw an exception.
`static boolean`	`isValidReferenceName(java.lang.String referenceName)`	Just checks whether a string is a valid reference-name, but doesn't throw an exception.
`static boolean`	`isValidReferenceNameOrHash(java.lang.String ref)`	Just checks whether a string is a valid reference-name (as per `isValidReferenceName(String)`) or a valid hash (as per `isValidHash(String)`).
`static void`	`validateDefaultCutOffPolicy(java.lang.String value)`	Validate default cutoff policy.Policies can be one of: - number of commits as an integer value, - a duration (see java.time.Duration), - an ISO instant, - 'NONE,' means everything's considered as live
`static java.lang.String`	`validateForbiddenReferenceName(java.lang.String ref)`	Throws an `IllegalArgumentException` if `ref` represents a forbidden reference name, see `isForbiddenReferenceName(String)`.
`static java.lang.String`	`validateHash(java.lang.String referenceName)`	Validates whether a string is a valid hash.
`static java.lang.String`	`validateHashOrRelativeSpec(java.lang.String referenceName)`	Validates whether a string is a valid hash with optional relative specs.
`static java.lang.String`	`validateReferenceName(java.lang.String referenceName)`	Validates whether a string is a valid reference-name.
`static java.lang.String`	`validateReferenceNameOrHash(java.lang.String ref)`	Validates whether a string is a valid reference name or hash.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - HASH_RAW_REGEX
```
public static final java.lang.String HASH_RAW_REGEX
```
    See Also:
    
    Constant Field Values
  - HASH_REGEX
```
public static final java.lang.String HASH_REGEX
```
    See Also:
    
    Constant Field Values
  - RELATIVE_COMMIT_SPEC_RAW_REGEX
```
public static final java.lang.String RELATIVE_COMMIT_SPEC_RAW_REGEX
```
    See Also:
    
    Constant Field Values
  - HASH_OR_RELATIVE_COMMIT_SPEC_RAW_REGEX
```
public static final java.lang.String HASH_OR_RELATIVE_COMMIT_SPEC_RAW_REGEX
```
    Regex with an optional hash and a sequence of relative lookups, which can be by-timestamp, by-n-th-predecessor or by-n-th-parent.
    
    Lookup by timestamp starts with * followed by the numeric value of the timestamp in milliseconds since epoch.
    Lookup by n-th predecessor starts with ~ followed by the value for the n-th commit in the commit log.
    Lookup by n-th parent starts with ^ followed by either 1, referencing the direct parent, or 2, referencing the merge parent.
    
    Valid values are:
    
    11223344~10 -> the 10th parent of the commit 11223344
    11223344^2 -> the merge parent of the commit 11223344
    11223344~10^2 -> the merge parent of the 10th parent of the commit 11223344
    11223344~10^1 -> the direct parent of the 10th parent of the commit 11223344 - functionally equal to 11223344~11
    11223344*10000000000 -> the commit in the commit log starting at 11223344 with a commit-created timestamp of 10000000000 or less.
    11223344*2021-04-07T14:42:25.534748Z -> the commit in the commit log starting at 11223344 with a commit-created timestamp of 2021-04-07T14:42:25.534748Z or less.
    See Also:
    
    Constant Field Values
  - HASH_OR_RELATIVE_COMMIT_SPEC_REGEX
```
public static final java.lang.String HASH_OR_RELATIVE_COMMIT_SPEC_REGEX
```
    See Also:
    
    Constant Field Values
  - REF_NAME_RAW_REGEX
```
public static final java.lang.String REF_NAME_RAW_REGEX
```
    See Also:
    
    Constant Field Values
  - REF_NAME_REGEX
```
public static final java.lang.String REF_NAME_REGEX
```
    See Also:
    
    Constant Field Values
  - REF_TYPE_RAW_REGEX
```
public static final java.lang.String REF_TYPE_RAW_REGEX
```
    See Also:
    
    Constant Field Values
  - REF_TYPE_REGEX
```
public static final java.lang.String REF_TYPE_REGEX
```
    See Also:
    
    Constant Field Values
  - REF_NAME_OR_HASH_REGEX
```
public static final java.lang.String REF_NAME_OR_HASH_REGEX
```
    See Also:
    
    Constant Field Values
  - REF_NAME_PATH_REGEX
```
public static final java.lang.String REF_NAME_PATH_REGEX
```
    See Also:
    
    Constant Field Values
  - REF_NAME_PATH_ELEMENT_REGEX
```
public static final java.lang.String REF_NAME_PATH_ELEMENT_REGEX
```
    See Also:
    
    Constant Field Values
  - HASH_PATTERN
```
public static final java.util.regex.Pattern HASH_PATTERN
```
  - REF_NAME_PATTERN
```
public static final java.util.regex.Pattern REF_NAME_PATTERN
```
  - RELATIVE_COMMIT_SPEC_PART_PATTERN
```
public static final java.util.regex.Pattern RELATIVE_COMMIT_SPEC_PART_PATTERN
```
  - HASH_OR_RELATIVE_COMMIT_SPEC_PATTERN
```
public static final java.util.regex.Pattern HASH_OR_RELATIVE_COMMIT_SPEC_PATTERN
```
  - REF_NAME_OR_HASH_PATTERN
```
public static final java.util.regex.Pattern REF_NAME_OR_HASH_PATTERN
```
  - REF_NAME_PATH_PATTERN
```
public static final java.util.regex.Pattern REF_NAME_PATH_PATTERN
```
  - REF_NAME_PATH_ELEMENT_PATTERN
```
public static final java.util.regex.Pattern REF_NAME_PATH_ELEMENT_PATTERN
```
  - DEFAULT_CUT_OFF_POLICY_REGEX
```
public static final java.lang.String DEFAULT_CUT_OFF_POLICY_REGEX
```
    See Also:
    
    Constant Field Values
  - DEFAULT_CUT_OFF_POLICY_MESSAGE
```
public static final java.lang.String DEFAULT_CUT_OFF_POLICY_MESSAGE
```
    See Also:
    
    Constant Field Values
  - DEFAULT_CUT_OFF_POLICY_PATTERN
```
public static final java.util.regex.Pattern DEFAULT_CUT_OFF_POLICY_PATTERN
```
  - HASH_RULE
```
public static final java.lang.String HASH_RULE
```
    See Also:
    
    Constant Field Values
  - HASH_MESSAGE
```
public static final java.lang.String HASH_MESSAGE
```
    See Also:
    
    Constant Field Values
  - RELATIVE_COMMIT_SPEC_RULE
```
public static final java.lang.String RELATIVE_COMMIT_SPEC_RULE
```
    See Also:
    
    Constant Field Values
  - HASH_OR_RELATIVE_COMMIT_SPEC_RULE
```
public static final java.lang.String HASH_OR_RELATIVE_COMMIT_SPEC_RULE
```
    See Also:
    
    Constant Field Values
  - HASH_OR_RELATIVE_COMMIT_SPEC_MESSAGE
```
public static final java.lang.String HASH_OR_RELATIVE_COMMIT_SPEC_MESSAGE
```
    See Also:
    
    Constant Field Values
  - REF_NAME_PATH_MESSAGE
```
public static final java.lang.String REF_NAME_PATH_MESSAGE
```
    See Also:
    
    Constant Field Values
  - REF_NAME_MESSAGE
```
public static final java.lang.String REF_NAME_MESSAGE
```
    See Also:
    
    Constant Field Values
  - REF_TYPE_RULE
```
public static final java.lang.String REF_TYPE_RULE
```
    See Also:
    
    Constant Field Values
  - REF_TYPE_MESSAGE
```
public static final java.lang.String REF_TYPE_MESSAGE
```
    See Also:
    
    Constant Field Values
  - REF_NAME_OR_HASH_MESSAGE
```
public static final java.lang.String REF_NAME_OR_HASH_MESSAGE
```
    See Also:
    
    Constant Field Values
  - FORBIDDEN_REF_NAME_MESSAGE
```
public static final java.lang.String FORBIDDEN_REF_NAME_MESSAGE
```
    See Also:
    
    Constant Field Values
  - FORBIDDEN_REF_NAMES
```
public static final java.util.Set<java.lang.String> FORBIDDEN_REF_NAMES
```
- Method Detail
  - isValidReferenceName
```
public static boolean isValidReferenceName(java.lang.String referenceName)
```
    Just checks whether a string is a valid reference-name, but doesn't throw an exception.
    
    See Also:
    
    validateReferenceName(String)
  - isValidHash
```
public static boolean isValidHash(java.lang.String hash)
```
    Just checks whether a string is a valid hash, but doesn't throw an exception.
    
    See Also:
    
    validateHash(String)
  - isValidHashOrRelativeSpec
```
public static boolean isValidHashOrRelativeSpec(java.lang.String hash)
```
    Just checks whether a string is a valid hash and/or a relative spec, but doesn't throw an exception.
    
    See Also:
    
    validateHashOrRelativeSpec(String)
  - isValidReferenceNameOrHash
```
public static boolean isValidReferenceNameOrHash(java.lang.String ref)
```
    Just checks whether a string is a valid reference-name (as per isValidReferenceName(String)) or a valid hash (as per isValidHash(String)).
  - validateReferenceName
```
public static java.lang.String validateReferenceName(java.lang.String referenceName)
                                              throws java.lang.IllegalArgumentException
```
    Validates whether a string is a valid reference-name.
    The rules are: "start with a letter, followed by letters, digits, one of the ./_- characters, not end with a slash or dot, not contain \'..\'"
    
    Parameters:
    
    referenceName - the reference name string to test.
    
    Throws:
    
    java.lang.IllegalArgumentException
  - validateHash
```
public static java.lang.String validateHash(java.lang.String referenceName)
                                     throws java.lang.IllegalArgumentException
```
    Validates whether a string is a valid hash.
    The rules are: "consist of the hex representation of 4-32 bytes"
    
    Parameters:
    
    referenceName - the reference name string to test.
    
    Throws:
    
    java.lang.IllegalArgumentException
  - validateHashOrRelativeSpec
```
public static java.lang.String validateHashOrRelativeSpec(java.lang.String referenceName)
                                                   throws java.lang.IllegalArgumentException
```
    Validates whether a string is a valid hash with optional relative specs.
    The rules are: "consist of either a valid commit hash (which in turn must consist of the hex representation of 4-32 bytes), or a valid relative part (which must be either \'~\' + a number representing the n-th predecessor of a commit, \'^\' + a number representing the n-th parent within a commit, or \'*\' + a number representing the created timestamp of a commit, in milliseconds since epoch or in ISO-8601 format), or both."
    
    Parameters:
    
    referenceName - the reference name string to test.
    
    Throws:
    
    java.lang.IllegalArgumentException
  - validateDefaultCutOffPolicy
```
public static void validateDefaultCutOffPolicy(java.lang.String value)
```
    Validate default cutoff policy.Policies can be one of: - number of commits as an integer value, - a duration (see java.time.Duration), - an ISO instant, - 'NONE,' means everything's considered as live
  - validateReferenceNameOrHash
```
public static java.lang.String validateReferenceNameOrHash(java.lang.String ref)
                                                    throws java.lang.IllegalArgumentException
```
    Validates whether a string is a valid reference name or hash.
    See validateReferenceName(String) and validateHash(String) for the rules.
    
    Parameters:
    
    ref - the reference name string to test.
    
    Throws:
    
    java.lang.IllegalArgumentException
  - isForbiddenReferenceName
```
public static boolean isForbiddenReferenceName(java.lang.String ref)
```
    Checks whether ref represents a forbidden reference name (HEAD or DETACHED) or could represent a commit-ID.
    
    Parameters:
    
    ref - reference name to check
    
    Returns:
    
    true, if forbidden
  - validateForbiddenReferenceName
```
public static java.lang.String validateForbiddenReferenceName(java.lang.String ref)
                                                       throws java.lang.IllegalArgumentException
```
    Throws an IllegalArgumentException if ref represents a forbidden reference name, see isForbiddenReferenceName(String).
    
    Parameters:
    
    ref - reference name to check
    
    Returns:
    
    ref
    
    Throws:
    
    java.lang.IllegalArgumentException

Class Validation

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

HASH_RAW_REGEX

HASH_REGEX

RELATIVE_COMMIT_SPEC_RAW_REGEX

HASH_OR_RELATIVE_COMMIT_SPEC_RAW_REGEX

HASH_OR_RELATIVE_COMMIT_SPEC_REGEX

REF_NAME_RAW_REGEX

REF_NAME_REGEX

REF_TYPE_RAW_REGEX

REF_TYPE_REGEX

REF_NAME_OR_HASH_REGEX

REF_NAME_PATH_REGEX

REF_NAME_PATH_ELEMENT_REGEX

HASH_PATTERN

REF_NAME_PATTERN

RELATIVE_COMMIT_SPEC_PART_PATTERN

HASH_OR_RELATIVE_COMMIT_SPEC_PATTERN

REF_NAME_OR_HASH_PATTERN

REF_NAME_PATH_PATTERN

REF_NAME_PATH_ELEMENT_PATTERN

DEFAULT_CUT_OFF_POLICY_REGEX

DEFAULT_CUT_OFF_POLICY_MESSAGE

DEFAULT_CUT_OFF_POLICY_PATTERN

HASH_RULE

HASH_MESSAGE

RELATIVE_COMMIT_SPEC_RULE

HASH_OR_RELATIVE_COMMIT_SPEC_RULE

HASH_OR_RELATIVE_COMMIT_SPEC_MESSAGE

REF_NAME_PATH_MESSAGE

REF_NAME_MESSAGE

REF_TYPE_RULE

REF_TYPE_MESSAGE

REF_NAME_OR_HASH_MESSAGE

FORBIDDEN_REF_NAME_MESSAGE

FORBIDDEN_REF_NAMES

Method Detail

isValidReferenceName

isValidHash

isValidHashOrRelativeSpec

isValidReferenceNameOrHash

validateReferenceName

validateHash

validateHashOrRelativeSpec

validateDefaultCutOffPolicy

validateReferenceNameOrHash

isForbiddenReferenceName

validateForbiddenReferenceName