| import java.util.function.BiFunction |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You 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. |
| */ |
| |
| // Local Lucene development repository resolution: |
| // 1) A "-Plucene.dev.version=[version]" property, resolving Lucene artifacts from a local Maven repository. |
| // 2) A non-empty property "-Plucene.dev.path=[path]" pointing to a local path. Relative paths |
| // are resolved against the root project directory. |
| // 3) An auto-wired 'lucene' subfolder, if present. To skip auto-wiring, pass |
| // a blank value in step 2: "-Plucene.dev.path=". |
| |
| |
| // This script is applied in settings.gradle and later at build time: these two contexts |
| // are distinctively different and have separate (and limited) APIs. |
| def configuringSettings = (rootProject instanceof org.gradle.api.initialization.ProjectDescriptor) |
| |
| // Accessor for -P properties from settings or at build time. |
| BiFunction<String, String, String> resolvePropertyValue = { propertyName, defValue -> |
| if (configuringSettings) { |
| return settings.ext.properties.getOrDefault(propertyName, defValue) |
| } else { |
| return project.properties.getOrDefault(propertyName, defValue) |
| } |
| } |
| |
| def PROP_FORCE_VERSION="lucene.dev.version" |
| def PROP_FORCE_PATH="lucene.dev.path" |
| def READ_ACCESS_PROPERTY="lucene-dev-path.dir" |
| |
| |
| def forcedLuceneVersion = resolvePropertyValue(PROP_FORCE_VERSION, null) |
| if (forcedLuceneVersion != null) { |
| if (!configuringSettings) { |
| logger.lifecycle("Lucene version forced by -P${PROP_FORCE_VERSION}=${forcedLuceneVersion}") |
| |
| allprojects { |
| repositories { |
| mavenLocal() |
| } |
| |
| tasks.withType(Test) { |
| def userHome = System.properties.get('user.home') |
| systemProperty READ_ACCESS_PROPERTY, file("${userHome}/.m2/repository/org/apache/lucene").absolutePath |
| } |
| |
| configurations.all { |
| resolutionStrategy.eachDependency { |
| if (requested.group == "org.apache.lucene") { |
| useVersion(forcedLuceneVersion) |
| because("Lucene version forced manually by 'lucene.dev.version' property.") |
| } |
| } |
| } |
| } |
| } |
| |
| // Step 1: end resolution |
| return |
| } |
| |
| def luceneDevRepo = null |
| def defaultLuceneDevRepo = file("${rootDir}/lucene") |
| String propertyValue = resolvePropertyValue(PROP_FORCE_PATH, null) |
| if (propertyValue != null) { |
| // Step 2. |
| if (propertyValue.isBlank()) { |
| if (defaultLuceneDevRepo.exists() && configuringSettings) { |
| logger.lifecycle("Local Lucene development repository has been detected but won't be used.") |
| } |
| } else { |
| // For relative path `propertyValue` spec, `file(propertyValue)` at settings configuration time |
| // resolves relative to "${rootDir}/gradle/" (as opposed to "${rootDir}/"); so we use the Java |
| // Path API here for consistent relative path resolution at configuration and build time |
| luceneDevRepo = file(rootDir).toPath().resolve(propertyValue).normalize().toFile() |
| if (!luceneDevRepo.exists()) { |
| throw new GradleException("Lucene repository does not exist at: -P${PROP_FORCE_PATH}=${luceneDevRepo}.") |
| } |
| } |
| } else if (defaultLuceneDevRepo.exists()) { |
| // Step 3 |
| luceneDevRepo = defaultLuceneDevRepo |
| } |
| |
| |
| if (luceneDevRepo != null) { |
| // Allow turning off this auto-wiring via -Dlucene.dev.repo=false (can't be a -P property because |
| // at settings evaluation time we don't have project properties yet). |
| if (configuringSettings) { |
| // We substitute the exact version of Lucene we currently have in versions.props across all the dependencies. |
| // We can't just substitute all references without looking at the versoin because |
| // plugin dependencies then also get substituted and everything crashes. |
| String luceneVersion = (file("${rootDir}/versions.props").getText("UTF-8") =~ /org.apache.lucene:\*=(.+)/)[0][1] |
| logger.lifecycle("Local Lucene development repository will be used substituting ${luceneVersion}: ${luceneDevRepo}") |
| |
| // Include Lucene repository as a composite and substitute module names. |
| includeBuild(luceneDevRepo) { |
| // Explicitly specify project name; otherwise project name is determined by directory name. |
| // The name of included build should match the `rootProject.name` of lucene: "lucene-root" |
| // At build time (below) the included build is retrieved by name; subproject tests in IDE |
| // will also default to run against the root project name of the included build, so it's |
| // important to have the names match. |
| name = 'lucene-root' |
| dependencySubstitution { |
| all { DependencySubstitution dependency -> |
| if (dependency.requested instanceof ModuleComponentSelector) { |
| def moduleSelector = (ModuleComponentSelector) dependency.requested |
| if (moduleSelector.group == "org.apache.lucene" && moduleSelector.version == luceneVersion) { |
| // Map Maven artifact name to lucene module name. |
| def projectModuleName = |
| moduleSelector.moduleIdentifier.name |
| .replaceFirst("^lucene-analysis-", ":lucene:analysis:") |
| .replaceFirst("^lucene-", ":lucene:") |
| |
| logger.info("Substituting Lucene dependency ${moduleSelector} with an included build project: ${projectModuleName}") |
| dependency.useTarget(project(projectModuleName)) |
| } |
| } |
| } |
| } |
| } |
| } else { |
| // We're being applied at build-time and Lucene development repository exists. Configure |
| // certain aspects of the build so that things work with it. |
| |
| // replace luceneBaseVersionProvider by one evaluating the included build: |
| configure(rootProject) { |
| def line = new File(gradle.includedBuild('lucene-root').projectDir, 'build.gradle').readLines("UTF-8").find { it =~ /\bbaseVersion\s*=\s*['"]/ } |
| if (!line) { |
| throw new GradleException('Cannot extract Lucene baseVersion from build.gradle file.') |
| } |
| def luceneBaseVersion = evaluate(line) |
| |
| logger.lifecycle("Local Lucene development repository will override luceneBaseVersion with: {}", luceneBaseVersion) |
| |
| ext { |
| luceneBaseVersionProvider = provider { luceneBaseVersion } |
| } |
| } |
| |
| // Security policy requires read access to the repo path. |
| allprojects { |
| tasks.withType(Test) { |
| systemProperty READ_ACCESS_PROPERTY, luceneDevRepo.absolutePath |
| } |
| } |
| } |
| } |
| |