* limitations under the License.
 */

package org.gradle.internal.rules;

import groovy.lang.Closure;
import org.gradle.api.Action;

public interface RuleActionAdapter {
    <T> RuleAction<? super T> createFromClosure(Class<T> subjectType, Closure<?> closure);

    <T> RuleAction<? super T> createFromAction(Action<? super T> action);

class DefaultRuleActionAdapterTest extends Specification {
    def RuleActionValidator noopValidator
    def ruleActionAdapter

    def setup() {
        noopValidator = Stub(RuleActionValidator) {
            validate(_) >> { RuleAction ruleAction -> ruleAction }
        }
    }

    def "can adapt from closure" () {
        ruleActionAdapter = new DefaultRuleActionAdapter(noopValidator, "context")
        def closureCalled = ""

    }

    protected DefaultComponentSelectionRules(ImmutableModuleIdentifierFactory moduleIdentifierFactory, RuleActionAdapter ruleActionAdapter) {
        this.ruleActionAdapter = ruleActionAdapter;
        this.moduleIdentifierNotationParser = NotationParserBuilder
            .toType(ModuleIdentifier.class)
            .fromCharSequence(new ModuleIdentifierNotationConverter(moduleIdentifierFactory))

    private final Instantiator instantiator;
    private final ComponentMetadataRuleContainer metadataRuleContainer;
    private final RuleActionAdapter ruleActionAdapter;
    private final NotationParser<Object, ModuleIdentifier> moduleIdentifierNotationParser;
    private final NotationParser<Object, DirectDependencyMetadataImpl> dependencyMetadataNotationParser;

    static final GROUP = "group"
    static final MODULE = "module"

    RuleActionAdapter adapter = Mock(RuleActionAdapter)
    DefaultComponentSelectionRules rules = new DefaultComponentSelectionRules(new DefaultImmutableModuleIdentifierFactory(), adapter)
    def ruleAction = Mock(RuleAction)
    def ruleSource = new Object()

    def "add closure rule that applies to all components"() {

    private static final String GROUP = "group"
    private static final String MODULE = "module"
    static def ruleActionAdapter = new DefaultRuleActionAdapter(new DefaultRuleActionValidator(), "context")
    private static SpecRuleAction<ComponentMetadataDetails> rule1 = new SpecRuleAction(ruleActionAdapter.createFromAction(new Action<ComponentMetadataDetails>() {
        @Override
        void execute(ComponentMetadataDetails t) {

    RuleActionAdapter adapter = Mock(RuleActionAdapter)

import groovy.lang.Closure;
import org.gradle.api.Action;
import org.gradle.api.InvalidUserCodeException;
import org.gradle.model.internal.type.ModelType;

public class DefaultRuleActionAdapter implements RuleActionAdapter {
    private static final String INVALID_CLOSURE_ERROR = "The closure provided is not valid as a rule for '%s'.";
    private static final String INVALID_ACTION_ERROR = "The action provided is not valid as a rule for '%s'.";

Class <org.gradle.internal.rules.RuleAction> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (RuleAction.java:0)
Class <org.gradle.internal.rules.RuleActionAdapter> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (RuleActionAdapter.java:0)