# RuleSource

@Incubating
open class RuleSource(source)

A marker type for a class that is a collection of rules.

A rule source is not used like a regular Java object. It is a stateless container of methods and possibly constants.

Please consult the “Rule based model configuration” chapter of the Gradle User Manual for general information about “rules”.

## Rule methods

Each method that is annotated with one of the following is considered a rule:

- Model
- Defaults
- Mutate
- Finalize
- Validate
- Rules
- org.gradle.platform.base.ComponentType
- org.gradle.platform.base.ComponentBinaries
- org.gradle.platform.base.BinaryTasks

Each annotation specifies the type of the rule, which affects when it will be executed.

The following constraints apply to all rule methods:

- A method may only be annotated by at most one of the above annotations.
- A rule method may be `static` or not; it makes no difference.
- A rule method cannot be generic (i.e. cannot have type parameters).
- With the exception of Model methods, all methods must have at least one parameter.
- With the exception of Model methods, all methods must have a `void` return type.

See Model for information on the significance of the return type of a Model method.

### Subjects and inputs

Method rules declare the subject and any inputs as parameters to the method. With the exception of Model methods, the subject of the rule is the, required, first parameter and all subsequent parameters are inputs. For a non-void Model method, the subject (i.e. model element being created) is the return object. For a void Model method, the subject is the first method parameter.

The Path annotation can be placed on any parameter (except the subject of Model rules) to indicate the model element to bind to. If there is no Path annotation, a “by-type” binding will be attempted. The binding scope is determined by how the rule source is applied.

## General class constraints

Along with the constraints on individual rule methods by their associated annotation, the following are general constraints of rule source implementations:

- Constructors are not allowed.
- Inheritance hierarchies are not allowed (i.e. all rules sources must directly extend RuleSource).
- Instance variables are not allowed.
- Non-final static variables are not allowed (i.e. constants are allowed).
- Methods cannot be overloaded.
- Implementations cannot be generic (i.e. cannot use type parameters).

## Constructors

RuleSource
Link copied to clipboard
constructor()