Search in sources :

Example 11 with GradleVersion

use of org.gradle.util.GradleVersion in project gradle by gradle.

the class GradleVersionSpec method toSpec.

public static Spec<GradleVersion> toSpec(String constraint) {
    String trimmed = constraint.trim();
    if (trimmed.equals("current")) {
        return new Spec<GradleVersion>() {

            @Override
            public boolean isSatisfiedBy(GradleVersion element) {
                return element.equals(GradleVersion.current());
            }
        };
    }
    if (trimmed.equals("!current")) {
        return new Spec<GradleVersion>() {

            @Override
            public boolean isSatisfiedBy(GradleVersion element) {
                return !element.equals(GradleVersion.current());
            }
        };
    }
    if (trimmed.startsWith("=")) {
        final GradleVersion target = GradleVersion.version(trimmed.substring(1)).getBaseVersion();
        return new Spec<GradleVersion>() {

            @Override
            public boolean isSatisfiedBy(GradleVersion element) {
                return element.getBaseVersion().equals(target);
            }
        };
    }
    List<Spec<GradleVersion>> specs = new ArrayList<Spec<GradleVersion>>();
    String[] patterns = trimmed.split("\\s+");
    for (String value : patterns) {
        if (value.startsWith(">=")) {
            final GradleVersion minVersion = GradleVersion.version(value.substring(2));
            specs.add(new Spec<GradleVersion>() {

                @Override
                public boolean isSatisfiedBy(GradleVersion element) {
                    return element.getBaseVersion().compareTo(minVersion) >= 0;
                }
            });
        } else if (value.startsWith(">")) {
            final GradleVersion minVersion = GradleVersion.version(value.substring(1));
            specs.add(new Spec<GradleVersion>() {

                @Override
                public boolean isSatisfiedBy(GradleVersion element) {
                    return element.getBaseVersion().compareTo(minVersion) > 0;
                }
            });
        } else if (value.startsWith("<=")) {
            final GradleVersion maxVersion = GradleVersion.version(value.substring(2));
            specs.add(new Spec<GradleVersion>() {

                @Override
                public boolean isSatisfiedBy(GradleVersion element) {
                    return element.getBaseVersion().compareTo(maxVersion) <= 0;
                }
            });
        } else if (value.startsWith("<")) {
            final GradleVersion maxVersion = GradleVersion.version(value.substring(1));
            specs.add(new Spec<GradleVersion>() {

                @Override
                public boolean isSatisfiedBy(GradleVersion element) {
                    return element.getBaseVersion().compareTo(maxVersion) < 0;
                }
            });
        } else if (value.startsWith("!")) {
            final GradleVersion excludedVersion = GradleVersion.version(value.substring(1));
            specs.add(new Spec<GradleVersion>() {

                @Override
                public boolean isSatisfiedBy(GradleVersion element) {
                    return !element.getBaseVersion().equals(excludedVersion);
                }
            });
        } else {
            throw new RuntimeException(String.format("Unsupported version range '%s' specified in constraint '%s'. Supported formats: '>=nnn', '>nnn', '<=nnn', '<nnn', '!nnn' or space-separate patterns", value, constraint));
        }
    }
    if (specs.size() == 1) {
        return specs.get(0);
    }
    return Specs.intersect(specs);
}
Also used : ArrayList(java.util.ArrayList) GradleVersion(org.gradle.util.GradleVersion)

Example 12 with GradleVersion

use of org.gradle.util.GradleVersion in project intellij-community by JetBrains.

the class GradleProjectResolver method doResolveProjectInfo.

@NotNull
private DataNode<ProjectData> doResolveProjectInfo(@NotNull final DefaultProjectResolverContext resolverCtx, @NotNull final GradleProjectResolverExtension projectResolverChain, boolean isBuildSrcProject) throws IllegalArgumentException, IllegalStateException {
    final BuildEnvironment buildEnvironment = GradleExecutionHelper.getBuildEnvironment(resolverCtx.getConnection());
    GradleVersion gradleVersion = null;
    boolean isGradleProjectDirSupported = false;
    boolean isCompositeBuildsSupported = false;
    if (buildEnvironment != null) {
        gradleVersion = GradleVersion.version(buildEnvironment.getGradle().getGradleVersion());
        isGradleProjectDirSupported = gradleVersion.compareTo(GradleVersion.version("2.4")) >= 0;
        isCompositeBuildsSupported = isGradleProjectDirSupported && gradleVersion.compareTo(GradleVersion.version("3.1")) >= 0;
    }
    final ProjectImportAction projectImportAction = new ProjectImportAction(resolverCtx.isPreviewMode(), isGradleProjectDirSupported, isCompositeBuildsSupported);
    GradleExecutionSettings executionSettings = resolverCtx.getSettings();
    if (executionSettings == null) {
        executionSettings = new GradleExecutionSettings(null, null, DistributionType.BUNDLED, false);
    }
    executionSettings.withArgument("-Didea.version=" + getIdeaVersion());
    if (resolverCtx.isPreviewMode()) {
        executionSettings.withArgument("-Didea.isPreviewMode=true");
        final Set<Class> previewLightWeightToolingModels = ContainerUtil.set(ExternalProjectPreview.class, GradleBuild.class);
        projectImportAction.addExtraProjectModelClasses(previewLightWeightToolingModels);
    }
    if (resolverCtx.isResolveModulePerSourceSet()) {
        executionSettings.withArgument("-Didea.resolveSourceSetDependencies=true");
    }
    if (!isBuildSrcProject) {
        for (GradleBuildParticipant buildParticipant : executionSettings.getExecutionWorkspace().getBuildParticipants()) {
            executionSettings.withArguments(GradleConstants.INCLUDE_BUILD_CMD_OPTION, buildParticipant.getProjectPath());
        }
    }
    final Set<Class> toolingExtensionClasses = ContainerUtil.newHashSet();
    final GradleImportCustomizer importCustomizer = GradleImportCustomizer.get();
    for (GradleProjectResolverExtension resolverExtension = projectResolverChain; resolverExtension != null; resolverExtension = resolverExtension.getNext()) {
        // inject ProjectResolverContext into gradle project resolver extensions
        resolverExtension.setProjectResolverContext(resolverCtx);
        // pre-import checks
        resolverExtension.preImportCheck();
        if (!resolverCtx.isPreviewMode()) {
            // register classes of extra gradle project models required for extensions (e.g. com.android.builder.model.AndroidProject)
            projectImportAction.addExtraProjectModelClasses(resolverExtension.getExtraProjectModelClasses());
        }
        if (importCustomizer == null || importCustomizer.useExtraJvmArgs()) {
            // collect extra JVM arguments provided by gradle project resolver extensions
            final ParametersList parametersList = new ParametersList();
            for (Pair<String, String> jvmArg : resolverExtension.getExtraJvmArgs()) {
                parametersList.addProperty(jvmArg.first, jvmArg.second);
            }
            executionSettings.withVmOptions(parametersList.getParameters());
        }
        // collect extra command-line arguments
        executionSettings.withArguments(resolverExtension.getExtraCommandLineArgs());
        // collect tooling extensions classes
        toolingExtensionClasses.addAll(resolverExtension.getToolingExtensionsClasses());
    }
    BuildActionExecuter<ProjectImportAction.AllModels> buildActionExecutor = resolverCtx.getConnection().action(projectImportAction);
    File initScript = GradleExecutionHelper.generateInitScript(isBuildSrcProject, toolingExtensionClasses);
    if (initScript != null) {
        executionSettings.withArguments(GradleConstants.INIT_SCRIPT_CMD_OPTION, initScript.getAbsolutePath());
    }
    GradleExecutionHelper.prepare(buildActionExecutor, resolverCtx.getExternalSystemTaskId(), executionSettings, resolverCtx.getListener(), resolverCtx.getConnection());
    resolverCtx.checkCancelled();
    ProjectImportAction.AllModels allModels;
    final CancellationTokenSource cancellationTokenSource = GradleConnector.newCancellationTokenSource();
    final long startTime = System.currentTimeMillis();
    try {
        resolverCtx.setCancellationTokenSource(cancellationTokenSource);
        buildActionExecutor.withCancellationToken(cancellationTokenSource.token());
        synchronized (myCancellationMap) {
            myCancellationMap.putValue(resolverCtx.getExternalSystemTaskId(), cancellationTokenSource);
            if (gradleVersion != null && gradleVersion.compareTo(GradleVersion.version("2.1")) < 0) {
                myCancellationMap.putValue(resolverCtx.getExternalSystemTaskId(), new UnsupportedCancellationToken());
            }
        }
        allModels = buildActionExecutor.run();
        if (allModels == null) {
            throw new IllegalStateException("Unable to get project model for the project: " + resolverCtx.getProjectPath());
        }
    } catch (UnsupportedVersionException unsupportedVersionException) {
        resolverCtx.checkCancelled();
        // Old gradle distribution version used (before ver. 1.8)
        // fallback to use ModelBuilder gradle tooling API
        Class<? extends IdeaProject> aClass = resolverCtx.isPreviewMode() ? BasicIdeaProject.class : IdeaProject.class;
        ModelBuilder<? extends IdeaProject> modelBuilder = myHelper.getModelBuilder(aClass, resolverCtx.getExternalSystemTaskId(), executionSettings, resolverCtx.getConnection(), resolverCtx.getListener());
        final IdeaProject ideaProject = modelBuilder.get();
        allModels = new ProjectImportAction.AllModels(ideaProject);
    } finally {
        final long timeInMs = (System.currentTimeMillis() - startTime);
        synchronized (myCancellationMap) {
            myCancellationMap.remove(resolverCtx.getExternalSystemTaskId(), cancellationTokenSource);
        }
        LOG.debug(String.format("Gradle data obtained in %d ms", timeInMs));
    }
    resolverCtx.checkCancelled();
    allModels.setBuildEnvironment(buildEnvironment);
    final long startDataConversionTime = System.currentTimeMillis();
    extractExternalProjectModels(allModels, resolverCtx);
    // import project data
    ProjectData projectData = projectResolverChain.createProject();
    DataNode<ProjectData> projectDataNode = new DataNode<>(ProjectKeys.PROJECT, projectData, null);
    // import java project data
    JavaProjectData javaProjectData = projectResolverChain.createJavaProjectData();
    projectDataNode.createChild(JavaProjectData.KEY, javaProjectData);
    IdeaProject ideaProject = resolverCtx.getModels().getIdeaProject();
    projectResolverChain.populateProjectExtraModels(ideaProject, projectDataNode);
    DomainObjectSet<? extends IdeaModule> gradleModules = ideaProject.getModules();
    if (gradleModules == null || gradleModules.isEmpty()) {
        throw new IllegalStateException("No modules found for the target project: " + ideaProject);
    }
    Collection<IdeaModule> includedModules = exposeCompositeBuild(allModels, resolverCtx, projectDataNode);
    final Map<String, Pair<DataNode<ModuleData>, IdeaModule>> /* module id */
    moduleMap = ContainerUtilRt.newHashMap();
    final Map<String, Pair<DataNode<GradleSourceSetData>, ExternalSourceSet>> /* module id */
    sourceSetsMap = ContainerUtil.newHashMap();
    projectDataNode.putUserData(RESOLVED_SOURCE_SETS, sourceSetsMap);
    final Map<String, Pair<String, ExternalSystemSourceType>> /* module id*/
    moduleOutputsMap = ContainerUtil.newTroveMap(FileUtil.PATH_HASHING_STRATEGY);
    projectDataNode.putUserData(MODULES_OUTPUTS, moduleOutputsMap);
    final Map<String, String> /* module id*/
    artifactsMap = ContainerUtil.newTroveMap(FileUtil.PATH_HASHING_STRATEGY);
    projectDataNode.putUserData(CONFIGURATION_ARTIFACTS, artifactsMap);
    // import modules data
    for (IdeaModule gradleModule : ContainerUtil.concat(gradleModules, includedModules)) {
        if (gradleModule == null) {
            continue;
        }
        resolverCtx.checkCancelled();
        if (ExternalSystemDebugEnvironment.DEBUG_ORPHAN_MODULES_PROCESSING) {
            LOG.info(String.format("Importing module data: %s", gradleModule));
        }
        final String moduleName = gradleModule.getName();
        if (moduleName == null) {
            throw new IllegalStateException("Module with undefined name detected: " + gradleModule);
        }
        DataNode<ModuleData> moduleDataNode = projectResolverChain.createModule(gradleModule, projectDataNode);
        String mainModuleId = getModuleId(resolverCtx, gradleModule);
        if (moduleMap.containsKey(mainModuleId)) {
            // we should ensure deduplicated module names in the scope of single import
            throw new IllegalStateException("Duplicate modules names detected: " + gradleModule);
        }
        moduleMap.put(mainModuleId, Pair.create(moduleDataNode, gradleModule));
    }
    executionSettings.getExecutionWorkspace().addModuleMap(moduleMap);
    File gradleHomeDir = null;
    // populate modules nodes
    for (final Pair<DataNode<ModuleData>, IdeaModule> pair : moduleMap.values()) {
        final DataNode<ModuleData> moduleDataNode = pair.first;
        final IdeaModule ideaModule = pair.second;
        if (gradleHomeDir == null) {
            final BuildScriptClasspathModel buildScriptClasspathModel = resolverCtx.getExtraProject(ideaModule, BuildScriptClasspathModel.class);
            if (buildScriptClasspathModel != null) {
                gradleHomeDir = buildScriptClasspathModel.getGradleHomeDir();
            }
        }
        projectResolverChain.populateModuleContentRoots(ideaModule, moduleDataNode);
        projectResolverChain.populateModuleCompileOutputSettings(ideaModule, moduleDataNode);
        if (!isBuildSrcProject) {
            projectResolverChain.populateModuleTasks(ideaModule, moduleDataNode, projectDataNode);
        }
        final List<DataNode<? extends ModuleData>> modules = ContainerUtil.newSmartList();
        modules.add(moduleDataNode);
        modules.addAll(ExternalSystemApiUtil.findAll(moduleDataNode, GradleSourceSetData.KEY));
        final ExternalSystemSourceType[] sourceTypes = new ExternalSystemSourceType[] { ExternalSystemSourceType.SOURCE, ExternalSystemSourceType.RESOURCE, ExternalSystemSourceType.TEST, ExternalSystemSourceType.TEST_RESOURCE };
        for (DataNode<? extends ModuleData> module : modules) {
            final ModuleData moduleData = module.getData();
            for (ExternalSystemSourceType sourceType : sourceTypes) {
                final String path = moduleData.getCompileOutputPath(sourceType);
                if (path != null) {
                    moduleOutputsMap.put(path, Pair.create(moduleData.getId(), sourceType));
                }
            }
            if (moduleData instanceof GradleSourceSetData) {
                for (File artifactFile : moduleData.getArtifacts()) {
                    artifactsMap.put(ExternalSystemApiUtil.toCanonicalPath(artifactFile.getAbsolutePath()), moduleData.getId());
                }
            }
        }
    }
    for (final Pair<DataNode<ModuleData>, IdeaModule> pair : moduleMap.values()) {
        final DataNode<ModuleData> moduleDataNode = pair.first;
        final IdeaModule ideaModule = pair.second;
        projectResolverChain.populateModuleDependencies(ideaModule, moduleDataNode, projectDataNode);
        projectResolverChain.populateModuleExtraModels(ideaModule, moduleDataNode);
    }
    mergeSourceSetContentRoots(moduleMap, resolverCtx);
    if (resolverCtx.isResolveModulePerSourceSet()) {
        mergeLibraryAndModuleDependencyData(projectDataNode, gradleHomeDir, gradleVersion);
    }
    projectDataNode.putUserData(RESOLVED_SOURCE_SETS, null);
    projectDataNode.putUserData(MODULES_OUTPUTS, null);
    projectDataNode.putUserData(CONFIGURATION_ARTIFACTS, null);
    // ensure unique library names
    Collection<DataNode<LibraryData>> libraries = ExternalSystemApiUtil.getChildren(projectDataNode, ProjectKeys.LIBRARY);
    myLibraryNamesMixer.mixNames(libraries);
    final long timeConversionInMs = (System.currentTimeMillis() - startDataConversionTime);
    LOG.debug(String.format("Project data resolved in %d ms", timeConversionInMs));
    return projectDataNode;
}
Also used : GradleExecutionSettings(org.jetbrains.plugins.gradle.settings.GradleExecutionSettings) IdeaProject(org.gradle.tooling.model.idea.IdeaProject) BasicIdeaProject(org.gradle.tooling.model.idea.BasicIdeaProject) JavaProjectData(com.intellij.externalSystem.JavaProjectData) GradleSourceSetData(org.jetbrains.plugins.gradle.model.data.GradleSourceSetData) UnsupportedCancellationToken(org.jetbrains.plugins.gradle.service.execution.UnsupportedCancellationToken) ParametersList(com.intellij.execution.configurations.ParametersList) IdeaModule(org.gradle.tooling.model.idea.IdeaModule) DataNode(com.intellij.openapi.externalSystem.model.DataNode) GradleVersion(org.gradle.util.GradleVersion) JavaProjectData(com.intellij.externalSystem.JavaProjectData) Pair(com.intellij.openapi.util.Pair) BasicIdeaProject(org.gradle.tooling.model.idea.BasicIdeaProject) BuildEnvironment(org.gradle.tooling.model.build.BuildEnvironment) GradleBuildParticipant(org.jetbrains.plugins.gradle.settings.GradleBuildParticipant) File(java.io.File) NotNull(org.jetbrains.annotations.NotNull)

Example 13 with GradleVersion

use of org.gradle.util.GradleVersion in project intellij-community by JetBrains.

the class GradleProjectResolverUtil method attachGradleSdkSources.

public static void attachGradleSdkSources(@NotNull final IdeaModule gradleModule, @Nullable final File libFile, @NotNull final LibraryData library, @NotNull final ProjectResolverContext resolverCtx) {
    final BuildScriptClasspathModel buildScriptClasspathModel = resolverCtx.getExtraProject(gradleModule, BuildScriptClasspathModel.class);
    if (buildScriptClasspathModel == null)
        return;
    final File gradleHomeDir = buildScriptClasspathModel.getGradleHomeDir();
    if (gradleHomeDir == null)
        return;
    final GradleVersion gradleVersion = GradleVersion.version(buildScriptClasspathModel.getGradleVersion());
    attachGradleSdkSources(libFile, library, gradleHomeDir, gradleVersion);
}
Also used : GradleVersion(org.gradle.util.GradleVersion) File(java.io.File)

Example 14 with GradleVersion

use of org.gradle.util.GradleVersion in project intellij-community by JetBrains.

the class GradleTaskManager method executeTasks.

@Override
public void executeTasks(@NotNull final ExternalSystemTaskId id, @NotNull final List<String> taskNames, @NotNull String projectPath, @Nullable GradleExecutionSettings settings, @Nullable final String jvmAgentSetup, @NotNull final ExternalSystemTaskNotificationListener listener) throws ExternalSystemException {
    // TODO add support for external process mode
    if (ExternalSystemApiUtil.isInProcessMode(GradleConstants.SYSTEM_ID)) {
        for (GradleTaskManagerExtension gradleTaskManagerExtension : GradleTaskManagerExtension.EP_NAME.getExtensions()) {
            if (gradleTaskManagerExtension.executeTasks(id, taskNames, projectPath, settings, jvmAgentSetup, listener)) {
                return;
            }
        }
    }
    GradleExecutionSettings effectiveSettings = settings == null ? new GradleExecutionSettings(null, null, DistributionType.BUNDLED, false) : settings;
    Function<ProjectConnection, Void> f = connection -> {
        final List<String> initScripts = ContainerUtil.newArrayList();
        final GradleProjectResolverExtension projectResolverChain = GradleProjectResolver.createProjectResolverChain(effectiveSettings);
        for (GradleProjectResolverExtension resolverExtension = projectResolverChain; resolverExtension != null; resolverExtension = resolverExtension.getNext()) {
            final String resolverClassName = resolverExtension.getClass().getName();
            resolverExtension.enhanceTaskProcessing(taskNames, jvmAgentSetup, script -> {
                if (StringUtil.isNotEmpty(script)) {
                    ContainerUtil.addAllNotNull(initScripts, "//-- Generated by " + resolverClassName, script, "//");
                }
            });
        }
        final String initScript = effectiveSettings.getUserData(INIT_SCRIPT_KEY);
        if (StringUtil.isNotEmpty(initScript)) {
            ContainerUtil.addAll(initScripts, "//-- Additional script", initScript, "//");
        }
        if (!initScripts.isEmpty()) {
            try {
                File tempFile = GradleExecutionHelper.writeToFileGradleInitScript(StringUtil.join(initScripts, SystemProperties.getLineSeparator()));
                effectiveSettings.withArguments(GradleConstants.INIT_SCRIPT_CMD_OPTION, tempFile.getAbsolutePath());
            } catch (IOException e) {
                throw new ExternalSystemException(e);
            }
        }
        GradleVersion gradleVersion = GradleExecutionHelper.getGradleVersion(connection);
        if (gradleVersion != null && gradleVersion.compareTo(GradleVersion.version("2.5")) < 0) {
            listener.onStatusChange(new ExternalSystemTaskExecutionEvent(id, new ExternalSystemProgressEventUnsupportedImpl(gradleVersion + " does not support executions view")));
        }
        for (GradleBuildParticipant buildParticipant : effectiveSettings.getExecutionWorkspace().getBuildParticipants()) {
            effectiveSettings.withArguments(GradleConstants.INCLUDE_BUILD_CMD_OPTION, buildParticipant.getProjectPath());
        }
        BuildLauncher launcher = myHelper.getBuildLauncher(id, connection, effectiveSettings, listener);
        launcher.forTasks(ArrayUtil.toStringArray(taskNames));
        if (gradleVersion != null && gradleVersion.compareTo(GradleVersion.version("2.1")) < 0) {
            myCancellationMap.put(id, new UnsupportedCancellationToken());
        } else {
            final CancellationTokenSource cancellationTokenSource = GradleConnector.newCancellationTokenSource();
            launcher.withCancellationToken(cancellationTokenSource.token());
            myCancellationMap.put(id, cancellationTokenSource);
        }
        try {
            launcher.run();
        } finally {
            myCancellationMap.remove(id);
        }
        return null;
    };
    myHelper.execute(projectPath, effectiveSettings, f);
}
Also used : GradleExecutionSettings(org.jetbrains.plugins.gradle.settings.GradleExecutionSettings) ExternalSystemTaskNotificationListener(com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskNotificationListener) ArrayUtil(com.intellij.util.ArrayUtil) GradleExecutionSettings(org.jetbrains.plugins.gradle.settings.GradleExecutionSettings) GradleProjectResolver(org.jetbrains.plugins.gradle.service.project.GradleProjectResolver) ContainerUtil(com.intellij.util.containers.ContainerUtil) GradleExecutionHelper(org.jetbrains.plugins.gradle.service.execution.GradleExecutionHelper) ExternalSystemApiUtil(com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil) UnsupportedCancellationToken(org.jetbrains.plugins.gradle.service.execution.UnsupportedCancellationToken) Map(java.util.Map) GradleConnector(org.gradle.tooling.GradleConnector) GradleBuildParticipant(org.jetbrains.plugins.gradle.settings.GradleBuildParticipant) GradleProjectResolverExtension(org.jetbrains.plugins.gradle.service.project.GradleProjectResolverExtension) GradleVersion(org.gradle.util.GradleVersion) BuildLauncher(org.gradle.tooling.BuildLauncher) ExternalSystemTaskManager(com.intellij.openapi.externalSystem.task.ExternalSystemTaskManager) StringUtil(com.intellij.openapi.util.text.StringUtil) ExternalSystemTaskExecutionEvent(com.intellij.openapi.externalSystem.model.task.event.ExternalSystemTaskExecutionEvent) Key(com.intellij.openapi.util.Key) ExternalSystemException(com.intellij.openapi.externalSystem.model.ExternalSystemException) IOException(java.io.IOException) File(java.io.File) Nullable(org.jetbrains.annotations.Nullable) ExternalSystemTaskId(com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId) CancellationTokenSource(org.gradle.tooling.CancellationTokenSource) DistributionType(org.jetbrains.plugins.gradle.settings.DistributionType) List(java.util.List) SystemProperties(com.intellij.util.SystemProperties) Function(com.intellij.util.Function) ExternalSystemProgressEventUnsupportedImpl(com.intellij.openapi.externalSystem.model.task.event.ExternalSystemProgressEventUnsupportedImpl) GradleConstants(org.jetbrains.plugins.gradle.util.GradleConstants) ProjectConnection(org.gradle.tooling.ProjectConnection) NotNull(org.jetbrains.annotations.NotNull) GradleProjectResolverExtension(org.jetbrains.plugins.gradle.service.project.GradleProjectResolverExtension) UnsupportedCancellationToken(org.jetbrains.plugins.gradle.service.execution.UnsupportedCancellationToken) ProjectConnection(org.gradle.tooling.ProjectConnection) ExternalSystemTaskExecutionEvent(com.intellij.openapi.externalSystem.model.task.event.ExternalSystemTaskExecutionEvent) IOException(java.io.IOException) ExternalSystemException(com.intellij.openapi.externalSystem.model.ExternalSystemException) BuildLauncher(org.gradle.tooling.BuildLauncher) CancellationTokenSource(org.gradle.tooling.CancellationTokenSource) List(java.util.List) GradleVersion(org.gradle.util.GradleVersion) File(java.io.File) GradleBuildParticipant(org.jetbrains.plugins.gradle.settings.GradleBuildParticipant) ExternalSystemProgressEventUnsupportedImpl(com.intellij.openapi.externalSystem.model.task.event.ExternalSystemProgressEventUnsupportedImpl)

Example 15 with GradleVersion

use of org.gradle.util.GradleVersion in project intellij-community by JetBrains.

the class VersionMatcher method isVersionMatch.

public boolean isVersionMatch(@Nullable TargetVersions targetVersions) {
    if (targetVersions == null || targetVersions.value() == null || targetVersions.value().isEmpty())
        return true;
    final GradleVersion current = adjust(myGradleVersion, targetVersions.checkBaseVersions());
    if (targetVersions.value().endsWith("+")) {
        String minVersion = targetVersions.value().substring(0, targetVersions.value().length() - 1);
        return compare(current, minVersion, targetVersions.checkBaseVersions()) >= 0;
    } else {
        final int rangeIndex = targetVersions.value().indexOf(RANGE_TOKEN);
        if (rangeIndex != -1) {
            String minVersion = targetVersions.value().substring(0, rangeIndex);
            String maxVersion = targetVersions.value().substring(rangeIndex + RANGE_TOKEN.length());
            return compare(current, minVersion, targetVersions.checkBaseVersions()) >= 0 && compare(current, maxVersion, targetVersions.checkBaseVersions()) <= 0;
        } else {
            return compare(current, targetVersions.value(), targetVersions.checkBaseVersions()) == 0;
        }
    }
}
Also used : GradleVersion(org.gradle.util.GradleVersion)

Aggregations

GradleVersion (org.gradle.util.GradleVersion)19 File (java.io.File)10 ArrayList (java.util.ArrayList)6 DefaultGradleConnector (org.gradle.tooling.internal.consumer.DefaultGradleConnector)4 IOException (java.io.IOException)3 List (java.util.List)3 Map (java.util.Map)3 ZipFile (java.util.zip.ZipFile)3 GradleConnector (org.gradle.tooling.GradleConnector)3 ProjectConnection (org.gradle.tooling.ProjectConnection)3 InputStream (java.io.InputStream)2 BuildEnvironment (org.gradle.tooling.model.build.BuildEnvironment)2 DefaultGradleVersion (org.gradle.util.internal.DefaultGradleVersion)2 NotNull (org.jetbrains.annotations.NotNull)2 UnsupportedCancellationToken (org.jetbrains.plugins.gradle.service.execution.UnsupportedCancellationToken)2 GradleBuildParticipant (org.jetbrains.plugins.gradle.settings.GradleBuildParticipant)2 GradleExecutionSettings (org.jetbrains.plugins.gradle.settings.GradleExecutionSettings)2 AndroidProject (com.android.builder.model.AndroidProject)1 VisibleForTesting (com.google.common.annotations.VisibleForTesting)1 Joiner (com.google.common.base.Joiner)1