* 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))

    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"() {

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'.";