/
DefaultScriptHandler.java
141 lines (124 loc) · 5.35 KB
/
DefaultScriptHandler.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
/*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.gradle.api.internal.initialization;
import groovy.lang.Closure;
import org.gradle.api.artifacts.Configuration;
import org.gradle.api.artifacts.ConfigurationContainer;
import org.gradle.api.artifacts.dsl.DependencyHandler;
import org.gradle.api.artifacts.dsl.RepositoryHandler;
import org.gradle.api.attributes.Usage;
import org.gradle.api.initialization.dsl.ScriptHandler;
import org.gradle.api.internal.DynamicObjectAware;
import org.gradle.api.internal.artifacts.DependencyResolutionServices;
import org.gradle.api.internal.model.NamedObjectInstantiator;
import org.gradle.api.logging.Logger;
import org.gradle.api.logging.Logging;
import org.gradle.groovy.scripts.ScriptSource;
import org.gradle.internal.classpath.ClassPath;
import org.gradle.internal.metaobject.BeanDynamicObject;
import org.gradle.internal.metaobject.DynamicObject;
import org.gradle.internal.resource.ResourceLocation;
import org.gradle.util.ConfigureUtil;
import java.io.File;
import java.net.URI;
public class DefaultScriptHandler implements ScriptHandler, ScriptHandlerInternal, DynamicObjectAware {
private static final Logger LOGGER = Logging.getLogger(DefaultScriptHandler.class);
private final ResourceLocation scriptResource;
private final ClassLoaderScope classLoaderScope;
private final ScriptClassPathResolver scriptClassPathResolver;
private final DependencyResolutionServices dependencyResolutionServices;
// The following values are relatively expensive to create, so defer creation until required
private RepositoryHandler repositoryHandler;
private DependencyHandler dependencyHandler;
private ConfigurationContainer configContainer;
private Configuration classpathConfiguration;
private DynamicObject dynamicObject;
public DefaultScriptHandler(ScriptSource scriptSource, DependencyResolutionServices dependencyResolutionServices, ClassLoaderScope classLoaderScope,
ScriptClassPathResolver scriptClassPathResolver) {
this.dependencyResolutionServices = dependencyResolutionServices;
this.scriptResource = scriptSource.getResource().getLocation();
this.classLoaderScope = classLoaderScope;
this.scriptClassPathResolver = scriptClassPathResolver;
}
@Override
public void dependencies(Closure configureClosure) {
ConfigureUtil.configure(configureClosure, getDependencies());
}
@Override
public void addScriptClassPathDependency(Object notation) {
getDependencies().add(ScriptHandler.CLASSPATH_CONFIGURATION, notation);
}
@Override
public ClassPath getScriptClassPath() {
return scriptClassPathResolver.resolveClassPath(classpathConfiguration);
}
@Override
public DependencyHandler getDependencies() {
defineConfiguration();
if (dependencyHandler == null) {
dependencyHandler = dependencyResolutionServices.getDependencyHandler();
}
return dependencyHandler;
}
@Override
public RepositoryHandler getRepositories() {
if (repositoryHandler == null) {
repositoryHandler = dependencyResolutionServices.getResolveRepositoryHandler();
}
return repositoryHandler;
}
@Override
public void repositories(Closure configureClosure) {
ConfigureUtil.configure(configureClosure, getRepositories());
}
@Override
public ConfigurationContainer getConfigurations() {
defineConfiguration();
return configContainer;
}
private void defineConfiguration() {
// Defer creation and resolution of configuration until required. Short-circuit when script does not require classpath
if (configContainer == null) {
configContainer = dependencyResolutionServices.getConfigurationContainer();
}
if (classpathConfiguration == null) {
classpathConfiguration = configContainer.create(CLASSPATH_CONFIGURATION);
classpathConfiguration.getAttributes().attribute(Usage.USAGE_ATTRIBUTE, NamedObjectInstantiator.INSTANCE.named(Usage.class, Usage.JAVA_RUNTIME));
}
}
@Override
public File getSourceFile() {
return scriptResource.getFile();
}
@Override
public URI getSourceURI() {
return scriptResource.getURI();
}
@Override
public ClassLoader getClassLoader() {
if (!classLoaderScope.isLocked()) {
LOGGER.debug("Eager creation of script class loader for {}. This may result in performance issues.", scriptResource.getDisplayName());
}
return classLoaderScope.getLocalClassLoader();
}
@Override
public DynamicObject getAsDynamicObject() {
if (dynamicObject == null) {
dynamicObject = new BeanDynamicObject(this);
}
return dynamicObject;
}
}