(project as ProjectInternal).services


fun isGradleKotlinDslJar(file: File) =
    isGradleKotlinDslJarName(file.name)


internal
fun isGradleKotlinDslJarName(jarName: String) =

            if (host instanceof final StandardHost standardHost) {
                standardHost.setErrorReportValveClass(SuppressErrorReportValve.class.getName());
            }
        }).useTldDetect(jarName -> (jarName.contains("jstl") || jarName.contains("lasta-taglib"))).asDevelopment(isNoneEnv()).bootAwait();
    }

    public static void shutdown(final String[] args) {
        System.exit(0);
    }

                    }
                    withFiles {
                        removeAllFiles()
                        addFile("guava-$version-${jarName}.jar", "../$version-$jarName/guava-$version-${jarName}.jar")
                    }
                }
            }
        }
    }
}
// end::guava-rule[]

// tag::guava-dependencies[]
configurations.compileClasspath.attributes {

        this.resolver = resolver;
        addGradleLibsRepository();
    }

    @Override
    public File resolveLocalGroovySources(String jarName) {
        Matcher matcher = FILE_NAME_PATTERN.matcher(jarName);
        if (!matcher.matches()) {
            return null;
        }
        VersionNumber version = VersionNumber.parse(matcher.group(3));

        return component."wb-module".property.collectEntries { [(it.@name) : it.@value] }
    }

    WbModule lib(String jarName) {
        def module = modules.find {
            def handle = it.node.@handle
            return handle.startsWith('module:/classpath/') && handle.endsWith(jarName)
        }
        assert module != null
        assert module.node."dependency-type"*.text() == ['uses']
        return module
    }

            substitute module("org.gradle:module2:1.0") using project(":project1")
        }
    }
}
""")

        def classpath = classpath("project2")
        assert classpath.libs*.jarName == ["module1-1.0.jar"]
        assert classpath.projects.collect { it.name } == ["project1"]
    }


    @Test
    @ToBeFixedForConfigurationCache
    void "project dependency substituted with external dependency"() {

    public static final GradleApiSourcesResolver INSTANCE = new NullGradleApiSourcesResolver();

    private NullGradleApiSourcesResolver() {
    }

    @Override
    public File resolveLocalGroovySources(String jarName) {
        return null;
    }

 * limitations under the License.
 */

package org.gradle.plugins.ide.internal.resolver;

import java.io.File;

public interface GradleApiSourcesResolver {
    File resolveLocalGroovySources(String jarName);

        dependencies.assertHasModule('COMPILE', "two")
        assert dependencies.libraries*.jarName as Set == [someLib2Jar.name] as Set

        dependencies = parseIml("two/two.iml").dependencies
        assert dependencies.libraries*.jarName as Set == [someLib2Jar.name] as Set

        executer.withArgument("-PstrictDeps=true").withTasks("idea").run()

        //then

    <nature>org.eclipse.jdt.core.javanature</nature>
  </natures>
</projectDescription>
"""
    }

    private String getDotClasspathText(String jarName) {
        """<?xml version="1.0" encoding="UTF-8"?>
<classpath>
  <classpathentry exported="true" kind="lib" path="${jarName}"/>
  <classpathentry kind="output" path="bin"/>
</classpath>
"""
    }