org.gradle.model.internal.registry.ModelRegistry Java Examples

private <R, S extends BinarySpec> void doRegister(MethodRuleDefinition<R> ruleDefinition, ModelRegistry modelRegistry, RuleSourceDependencies dependencies) {
    try {
        RuleMethodDataCollector dataCollector = new RuleMethodDataCollector();
        visitAndVerifyMethodSignature(dataCollector, ruleDefinition);

        final Class<S> binaryType = dataCollector.getParameterType(BinarySpec.class);
        final Class<? extends ComponentSpec> componentType = dataCollector.getParameterType(ComponentSpec.class);
        dependencies.add(ComponentModelBasePlugin.class);
        final ModelReference<BinaryContainer> subject = ModelReference.of(ModelPath.path("binaries"), new ModelType<BinaryContainer>() {
        });

        configureMutationRule(modelRegistry, subject, componentType, binaryType, ruleDefinition);
    } catch (InvalidComponentModelException e) {
        invalidModelRule(ruleDefinition, e);
    }
}
 

public <T> void register(MethodRuleDefinition<T> ruleDefinition, ModelRegistry modelRegistry, RuleSourceDependencies dependencies) {

        // TODO validate model name
        String modelName = determineModelName(ruleDefinition);

        try {
            ModelPath.validatePath(modelName);
        } catch (Exception e) {
            throw new InvalidModelRuleDeclarationException(String.format("Path of declared model element created by rule %s is invalid.", ruleDefinition.getDescriptor()), e);
        }

        // TODO validate the return type (generics?)
        ModelType<T> returnType = ruleDefinition.getReturnType();
        ModelPath path = ModelPath.path(modelName);
        List<ModelReference<?>> references = ruleDefinition.getReferences();
        ModelRuleDescriptor descriptor = ruleDefinition.getDescriptor();

        Transformer<T, Inputs> transformer = new ModelRuleInvokerBackedTransformer<T>(ruleDefinition.getRuleInvoker(), descriptor, references);
        modelRegistry.create(
                ModelCreators.of(ModelReference.of(path, returnType), transformer)
                        .descriptor(descriptor)
                        .inputs(references)
                        .build()
        );
    }
 

private <R, S extends BinarySpec> void doRegister(MethodRuleDefinition<R> ruleDefinition, ModelRegistry modelRegistry, RuleSourceDependencies dependencies) {
    try {
        RuleMethodDataCollector dataCollector = new RuleMethodDataCollector();
        verifyMethodSignature(dataCollector, ruleDefinition);

        Class<S> binaryType =  dataCollector.getParameterType(BinarySpec.class);
        dependencies.add(ComponentModelBasePlugin.class);

        final ModelReference<TaskContainer> tasks = ModelReference.of(ModelPath.path("tasks"), new ModelType<TaskContainer>() {
        });

        modelRegistry.mutate(new BinaryTaskRule<R, S>(tasks, binaryType, ruleDefinition, modelRegistry));

    } catch (InvalidComponentModelException e) {
        invalidModelRule(ruleDefinition, e);
    }
}
 

public <T> void inspect(Class<T> source, ModelRegistry modelRegistry, RuleSourceDependencies dependencies) {
    validate(source);
    final Method[] methods = source.getDeclaredMethods();

    // sort for determinism
    Arrays.sort(methods, new Comparator<Method>() {
        public int compare(Method o1, Method o2) {
            return o1.toString().compareTo(o2.toString());
        }
    });

    for (Method method : methods) {
        validate(method);
        MethodRuleDefinition<?> ruleDefinition = DefaultMethodRuleDefinition.create(source, method);
        MethodRuleDefinitionHandler handler = getMethodHandler(ruleDefinition);
        if (handler != null) {
            // TODO catch “strange” exceptions thrown here and wrap with some context on the rule being registered
            // If the thrown exception doesn't provide any “model rule” context, it will be more or less impossible for a user
            // to work out what happened because the stack trace won't reveal any info about which rule was being registered.
            // However, a “wrap everything” strategy doesn't quite work because the thrown exception may already have enough context
            // and do a better job of explaining what went wrong than what we can do at this level.
            handler.register(ruleDefinition, modelRegistry, dependencies);
        }
    }
}
 

private <R, S extends BinarySpec> void doRegister(MethodRuleDefinition<R> ruleDefinition, ModelRegistry modelRegistry, RuleSourceDependencies dependencies) {
    try {
        RuleMethodDataCollector dataCollector = new RuleMethodDataCollector();
        verifyMethodSignature(dataCollector, ruleDefinition);

        Class<S> binaryType =  dataCollector.getParameterType(BinarySpec.class);
        dependencies.add(ComponentModelBasePlugin.class);

        final ModelReference<TaskContainer> tasks = ModelReference.of(ModelPath.path("tasks"), new ModelType<TaskContainer>() {
        });

        modelRegistry.mutate(new BinaryTaskRule<R, S>(tasks, binaryType, ruleDefinition, modelRegistry));

    } catch (InvalidComponentModelException e) {
        invalidModelRule(ruleDefinition, e);
    }
}
 

private <R, S extends BinarySpec> void doRegister(MethodRuleDefinition<R> ruleDefinition, ModelRegistry modelRegistry, RuleSourceDependencies dependencies) {
    try {
        RuleMethodDataCollector dataCollector = new RuleMethodDataCollector();
        visitAndVerifyMethodSignature(dataCollector, ruleDefinition);

        final Class<S> binaryType = dataCollector.getParameterType(BinarySpec.class);
        final Class<? extends ComponentSpec> componentType = dataCollector.getParameterType(ComponentSpec.class);
        dependencies.add(ComponentModelBasePlugin.class);
        final ModelReference<BinaryContainer> subject = ModelReference.of(ModelPath.path("binaries"), new ModelType<BinaryContainer>() {
        });

        configureMutationRule(modelRegistry, subject, componentType, binaryType, ruleDefinition);
    } catch (InvalidComponentModelException e) {
        invalidModelRule(ruleDefinition, e);
    }
}
 

public <T> void inspect(Class<T> source, ModelRegistry modelRegistry, RuleSourceDependencies dependencies) {
    validate(source);
    final Method[] methods = source.getDeclaredMethods();

    // sort for determinism
    Arrays.sort(methods, new Comparator<Method>() {
        public int compare(Method o1, Method o2) {
            return o1.toString().compareTo(o2.toString());
        }
    });

    for (Method method : methods) {
        validate(method);
        MethodRuleDefinition<?> ruleDefinition = DefaultMethodRuleDefinition.create(source, method);
        MethodRuleDefinitionHandler handler = getMethodHandler(ruleDefinition);
        if (handler != null) {
            // TODO catch “strange” exceptions thrown here and wrap with some context on the rule being registered
            // If the thrown exception doesn't provide any “model rule” context, it will be more or less impossible for a user
            // to work out what happened because the stack trace won't reveal any info about which rule was being registered.
            // However, a “wrap everything” strategy doesn't quite work because the thrown exception may already have enough context
            // and do a better job of explaining what went wrong than what we can do at this level.
            handler.register(ruleDefinition, modelRegistry, dependencies);
        }
    }
}
 

public <T> void register(MethodRuleDefinition<T> ruleDefinition, ModelRegistry modelRegistry, RuleSourceDependencies dependencies) {

        // TODO validate model name
        String modelName = determineModelName(ruleDefinition);

        try {
            ModelPath.validatePath(modelName);
        } catch (Exception e) {
            throw new InvalidModelRuleDeclarationException(String.format("Path of declared model element created by rule %s is invalid.", ruleDefinition.getDescriptor()), e);
        }

        // TODO validate the return type (generics?)
        ModelType<T> returnType = ruleDefinition.getReturnType();
        ModelPath path = ModelPath.path(modelName);
        List<ModelReference<?>> references = ruleDefinition.getReferences();
        ModelRuleDescriptor descriptor = ruleDefinition.getDescriptor();

        Transformer<T, Inputs> transformer = new ModelRuleInvokerBackedTransformer<T>(ruleDefinition.getRuleInvoker(), descriptor, references);
        modelRegistry.create(
                ModelCreators.of(ModelReference.of(path, returnType), transformer)
                        .descriptor(descriptor)
                        .inputs(references)
                        .build()
        );
    }
 

@Inject
public JavaBasePlugin(Instantiator instantiator, JavaToolChain javaToolChain, ITaskFactory taskFactory, ModelRegistry modelRegistry) {
    this.instantiator = instantiator;
    this.javaToolChain = javaToolChain;
    this.taskFactory = taskFactory;
    this.modelRegistry = modelRegistry;
}
 

public void execute(PluginApplication pluginApplication) {
    Class<? extends Plugin> pluginClass = pluginApplication.getPlugin().getClass();
    Set<Class<?>> sources = inspector.getDeclaredSources(pluginClass);
    if (!sources.isEmpty()) {
        PluginAware target = pluginApplication.getTarget();
        if (!(target instanceof ModelRegistryScope)) {
            throw new UnsupportedOperationException(String.format("Cannot apply model rules of plugin '%s' as the target '%s' is not model rule aware", pluginClass.getName(), target));
        }

        ModelRegistry modelRegistry = ((ModelRegistryScope) target).getModelRegistry();
        for (Class<?> source : sources) {
            inspector.inspect(source, modelRegistry, new PluginRuleSourceDependencies(target));
        }
    }
}
 

TransformedModelDslBacking(ModelRegistry modelRegistry, Object thisObject, Object owner, Transformer<? extends List<ModelReference<?>>, ? super Closure<?>> inputPathsExtractor,
                           Transformer<SourceLocation, ? super Closure<?>> ruleLocationExtractor) {
    this.modelRegistry = modelRegistry;
    this.thisObject = thisObject;
    this.owner = owner;
    this.inputPathsExtractor = inputPathsExtractor;
    this.ruleLocationExtractor = ruleLocationExtractor;
}
 

public <R> void register(MethodRuleDefinition<R> ruleDefinition, ModelRegistry modelRegistry, RuleSourceDependencies dependencies) {
    List<ModelReference<?>> bindings = ruleDefinition.getReferences();

    ModelReference<?> subject = bindings.get(0);
    List<ModelReference<?>> inputs = bindings.subList(1, bindings.size());
    MethodModelMutator<?> mutator = toMutator(ruleDefinition, subject, inputs);

    if (isFinalize()) {
        modelRegistry.finalize(mutator);
    } else {
        modelRegistry.mutate(mutator);
    }
}
 

public <R> void register(MethodRuleDefinition<R> ruleDefinition, ModelRegistry modelRegistry, RuleSourceDependencies dependencies) {
    try {
        ModelType<? extends T> type = readType(ruleDefinition);
        ModelType<? extends U> implementation = determineImplementationType(ruleDefinition, type);

        dependencies.add(ComponentModelBasePlugin.class);
        if (implementation != null) {
            ModelMutator<?> mutator = new RegisterTypeRule<T, U>(type, implementation, ruleDefinition.getDescriptor(), registerer);
            modelRegistry.mutate(mutator);
        }
    } catch (InvalidComponentModelException e) {
        invalidModelRule(ruleDefinition, e);
    }
}
 

public void execute(PluginApplication pluginApplication) {
    Class<? extends Plugin> pluginClass = pluginApplication.getPlugin().getClass();
    Set<Class<?>> sources = inspector.getDeclaredSources(pluginClass);
    if (!sources.isEmpty()) {
        PluginAware target = pluginApplication.getTarget();
        if (!(target instanceof ModelRegistryScope)) {
            throw new UnsupportedOperationException(String.format("Cannot apply model rules of plugin '%s' as the target '%s' is not model rule aware", pluginClass.getName(), target));
        }

        ModelRegistry modelRegistry = ((ModelRegistryScope) target).getModelRegistry();
        for (Class<?> source : sources) {
            inspector.inspect(source, modelRegistry, new PluginRuleSourceDependencies(target));
        }
    }
}
 

TransformedModelDslBacking(ModelRegistry modelRegistry, Object thisObject, Object owner, Transformer<? extends List<ModelReference<?>>, ? super Closure<?>> inputPathsExtractor,
                           Transformer<SourceLocation, ? super Closure<?>> ruleLocationExtractor) {
    this.modelRegistry = modelRegistry;
    this.thisObject = thisObject;
    this.owner = owner;
    this.inputPathsExtractor = inputPathsExtractor;
    this.ruleLocationExtractor = ruleLocationExtractor;
}
 

public <R> void register(MethodRuleDefinition<R> ruleDefinition, ModelRegistry modelRegistry, RuleSourceDependencies dependencies) {
    List<ModelReference<?>> bindings = ruleDefinition.getReferences();

    ModelReference<?> subject = bindings.get(0);
    List<ModelReference<?>> inputs = bindings.subList(1, bindings.size());
    MethodModelMutator<?> mutator = toMutator(ruleDefinition, subject, inputs);

    if (isFinalize()) {
        modelRegistry.finalize(mutator);
    } else {
        modelRegistry.mutate(mutator);
    }
}
 

public <R> void register(MethodRuleDefinition<R> ruleDefinition, ModelRegistry modelRegistry, RuleSourceDependencies dependencies) {
    try {
        ModelType<? extends T> type = readType(ruleDefinition);
        ModelType<? extends U> implementation = determineImplementationType(ruleDefinition, type);

        dependencies.add(ComponentModelBasePlugin.class);
        if (implementation != null) {
            ModelMutator<?> mutator = new RegisterTypeRule<T, U>(type, implementation, ruleDefinition.getDescriptor(), registerer);
            modelRegistry.mutate(mutator);
        }
    } catch (InvalidComponentModelException e) {
        invalidModelRule(ruleDefinition, e);
    }
}
 

@Inject
public ComponentModelBasePlugin(Instantiator instantiator, ModelRegistry modelRegistry) {
    this.instantiator = instantiator;
    this.modelRegistry = modelRegistry;
}
 

protected ModelRegistry createModelRegistry() {
    return new DefaultModelRegistry();
}
 

private <S extends BinarySpec, R> void configureMutationRule(ModelRegistry modelRegistry, ModelReference<BinaryContainer> subject, Class<? extends ComponentSpec> componentType, Class<S> binaryType, MethodRuleDefinition<R> ruleDefinition) {
    modelRegistry.mutate(new ComponentBinariesRule<R, S>(subject, componentType, binaryType, ruleDefinition, modelRegistry));
}
 

@Inject
public ModelRegistry getModelRegistry() {
    // Decoration takes care of the implementation
    throw new UnsupportedOperationException();
}
 

@Inject
protected ModelRegistry getModelRegistry() {
    throw new UnsupportedOperationException();
}
 

public ComponentBinariesRule(ModelReference<BinaryContainer> subject, final Class<? extends ComponentSpec> componentType, final Class<S> binaryType, MethodRuleDefinition<R> ruleDefinition, ModelRegistry modelRegistry) {
    super(subject, componentType, ruleDefinition, ModelReference.of("componentSpecs", ComponentSpecContainer.class));
    this.componentType = componentType;
    this.binaryType = binaryType;
    this.modelRegistry = modelRegistry;
}
 

public TransformedModelDslBacking(ModelRegistry modelRegistry, Object thisObject, Object owner) {
    this(modelRegistry, thisObject, owner, INPUT_PATHS_EXTRACTOR, RULE_LOCATION_EXTRACTOR);
}
 

private NonTransformedModelDslBacking(AtomicBoolean executingDsl, ModelPath modelPath, ModelRegistry modelRegistry) {
    this.executingDsl = executingDsl;
    this.modelPath = modelPath;
    this.modelRegistry = modelRegistry;
}
 

public NonTransformedModelDslBacking(ModelRegistry modelRegistry) {
    this(new AtomicBoolean(), null, modelRegistry);
}
 

public BinaryTaskRule(ModelReference<TaskContainer> subject, final Class<T> binaryType, MethodRuleDefinition<R> ruleDefinition, ModelRegistry modelRegistry) {
    super(subject, binaryType, ruleDefinition, ModelReference.of("binaries", BinaryContainer.class));
    this.binaryType = binaryType;
    this.modelRegistry = modelRegistry;
}
 

@Inject
public LanguageBasePlugin(Instantiator instantiator, ModelRegistry modelRegistry) {
    this.instantiator = instantiator;
    this.modelRegistry = modelRegistry;
}
 

@Inject
public ComponentModelBasePlugin(Instantiator instantiator, ModelRegistry modelRegistry) {
    this.instantiator = instantiator;
    this.modelRegistry = modelRegistry;
}
 

private NonTransformedModelDslBacking(AtomicBoolean executingDsl, ModelPath modelPath, ModelRegistry modelRegistry) {
    this.executingDsl = executingDsl;
    this.modelPath = modelPath;
    this.modelRegistry = modelRegistry;
}