/**
 * Represents a tuple containing a Spec and a RuleAction
 */
public class SpecRuleAction<T> {
    final RuleAction<? super T> action;
    final Spec<? super T> spec;

    public SpecRuleAction(RuleAction<? super T> action, Spec<? super T> spec) {
        this.action = action;
        this.spec = spec;
    }

    public RuleAction<? super T> getAction() {
        return action;
    }

        when:
        substitutions.ruleAction.execute(details)

        then:
        0 * details._
    }

    def "all() matches modules and projects"() {
        given:
        def action = Mock(Action)
        substitutions.all(action)

        def moduleDetails = Mock(DependencySubstitutionInternal)

        when:
        substitutions.ruleAction.execute(moduleDetails)

        then:

        closureCalled == "string"

        when:
        ruleAction = ruleActionAdapter.createFromClosure(String, { s -> closureCalled = s })
        ruleAction.execute("object", [])

        then:
        ruleAction.inputTypes == []
        closureCalled == "object"

        when:
        ruleAction = ruleActionAdapter.createFromClosure(String, { -> closureCalled = delegate })
        ruleAction.execute("zero", [])

class ActionBasedMetadataRuleWrapper implements MetadataRuleWrapper {
    private final SpecRuleAction<? super ComponentMetadataDetails> ruleAction;

    ActionBasedMetadataRuleWrapper(SpecRuleAction<? super ComponentMetadataDetails> ruleAction) {
        this.ruleAction = ruleAction;
    }

    @Override
    public DisplayName getDisplayName() {
        return Describables.of("opaque inline rule");
    }

    }

    void addClassRule(SpecConfigurableRule ruleAction) {
        if (lastAdded != null && lastAdded.isClassBased()) {
            lastAdded.addClassRule(ruleAction);
        } else {
            lastAdded = new ClassBasedMetadataRuleWrapper(ruleAction);
            addRule();
        }
        rulesHash = 31 * rulesHash + ruleAction.getConfigurableRule().hashCode();
    }

 * limitations under the License.
 */

package org.gradle.internal.rules;

public interface RuleActionValidator {
    <T> RuleAction<? super T> validate(RuleAction<? super T> ruleAction);

        delegate.addRule(rule)

    override fun addRule(description: String, ruleAction: Closure<Any>): Rule =
        delegate.addRule(description, ruleAction)

    override fun addRule(description: String, ruleAction: Action<String>): Rule =
        delegate.addRule(description, ruleAction)

    override fun configure(configureClosure: Closure<Any>): NamedDomainObjectContainer<T> =

            MethodBackedModelAction<S> ruleAction = new MethodBackedModelAction<S>(ruleDefinition.getDescriptor(), ruleDefinition.getSubjectReference(), ruleDefinition.getTailReferences());
            RuleExtractorUtils.configureRuleAction(context, ruleApplicationScope, mutationType, ruleAction);
        }

        @Override
        public List<? extends Class<?>> getRuleDependencies() {

        delegate.addRule(rule)

    override fun addRule(description: String, ruleAction: Closure<Any>): Rule =
        delegate.addRule(description, ruleAction)

    override fun addRule(description: String, ruleAction: Action<String>): Rule =
        delegate.addRule(description, ruleAction)

    override fun configure(configureClosure: Closure<Any>): NamedDomainObjectContainer<Task> =

    public DefaultRuleActionAdapter(RuleActionValidator ruleActionValidator, String context) {
        this.ruleActionValidator = ruleActionValidator;
        this.context = context;
    }

    @Override
    public <T> RuleAction<? super T> createFromClosure(Class<T> subjectType, Closure<?> closure) {
        try {
            return ruleActionValidator.validate(new ClosureBackedRuleAction<>(subjectType, closure));