* limitations under the License.
 */

package org.gradle.test.fixtures.ivy

import groovy.namespace.QName
import groovy.xml.XmlParser
import org.apache.commons.lang.StringUtils

class IvyDescriptor {
    Map<String, IvyDescriptorConfiguration> configurations = [:]
    List<IvyDescriptorArtifact> artifacts = []
    Map<String, IvyDescriptorDependency> dependencies = [:]

        List<Exclude> excludes = converter.extractExcludes(ivyDescriptor);
        Map<NamespaceId, String> extraAttributes = converter.extractExtraAttributes(ivyDescriptor);
        MutableIvyModuleResolveMetadata metadata = metadataFactory.create(cid, dependencies, configurations, artifacts, excludes);
        metadata.setStatus(ivyDescriptor.getStatus());
        metadata.setExtraAttributes(extraAttributes);

            addDependency(result, dependencyDescriptor);
        }
        return result;
    }

    public List<Configuration> extractConfigurations(ModuleDescriptor ivyDescriptor) {
        List<Configuration> result = Lists.newArrayListWithCapacity(ivyDescriptor.getConfigurations().length);
        for (org.apache.ivy.core.module.descriptor.Configuration ivyConfiguration : ivyDescriptor.getConfigurations()) {

                        ivy '[module]/[organisation]/[revision]/ivy.xml'
                        m2compatible = true
                    }
                    metadataSources { gradleMetadata(); ivyDescriptor(); artifact() }
                    credentials {
                        username 'user'
                        password 'pass'
                    }
                    authentication {

        coordinates.getRevision().set(version)
        coordinates
    }

    private def ivyFile() {
        return ivyFile(ivyDescriptor())
    }

    private IvyModuleDescriptorSpecInternal ivyDescriptor() {
        IvyPublicationCoordinates publicationCoordinates = TestUtil.objectFactory().newInstance(IvyPublicationCoordinates)

        boolean gradleMetadata;
        boolean ivyDescriptor;
        boolean artifact;
        boolean ignoreGradleMetadataRedirection;

        void setDefaults() {
            ivyDescriptor();
            ignoreGradleMetadataRedirection = false;
        }

        void reset() {
            gradleMetadata = false;
            ivyDescriptor = false;
            artifact = false;

                edge("org.test:projectA:1.+", "org.test:projectA:1.2")
            }
        }
    }

    def "can resolve with only repository-specific metadata"() {
        def metadataSource = useIvy() ? "ivyDescriptor" : "mavenPom"
        buildFile << """
            repositories.all {
                metadataSources {
                    ${metadataSource}()
                }
            }
            dependencies {

            }
        """

        when:
        succeeds 'generateDescriptorFileForIvyPublication'

        then:
        file('generated-ivy.xml').assertIsFile()
        IvyDescriptor ivy = new IvyDescriptor(file('generated-ivy.xml'))
        ivy.expectArtifact(moduleName).hasAttributes("jar", "jar", ["compile", "runtime"])
        module.ivyFile.assertDoesNotExist()
    }

        """
            repositories {
                ivy {
                    url "$frontServerBaseUrl/repo"
                    metadataSources {
                        ivyDescriptor()
                        artifact()
                    }
                    $allowInsecureProtocolCall
                }
            }
            configurations { compile }

import org.gradle.internal.Cast;
import org.gradle.test.fixtures.GradleModuleMetadata;
import org.gradle.test.fixtures.Module;
import org.gradle.test.fixtures.file.TestFile;
import org.gradle.test.fixtures.ivy.IvyDescriptor;
import org.gradle.test.fixtures.ivy.IvyModule;

import java.io.File;
import java.util.Collections;
import java.util.Map;

public abstract class DelegatingIvyModule<T extends IvyModule> implements IvyModule {