* 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()) {

                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 {

            builder.addArtifactResource(root.toURI(), "/[artifact](-[classifier]).[ext]");
        }
        IvyRepositoryDescriptor ivyDescriptor = builder.create();
        return new FlatDirRepositoryDescriptor(getName(), getDirs(), ivyDescriptor);
    }

    @Override

            apply plugin: 'java-library'

            repositories {
                ivy {
                    url "${ivyHttpRepo.uri}"
                    metadataSources {
                        ivyDescriptor()
                        artifact()
                        ignoreGradleMetadataRedirection()
                    }
                }
            }

             dependencies {

     * Publishes ivy.xml plus all artifacts. Publishes only those artifacts whose content has changed since the
     * last call to {@code #publish()}.
     */
    @Override
    IvyModule publish();

    IvyDescriptor getParsedIvy();

    /**
     * Asserts that an ivy.xml is present
     */
    void assertPublished();

    /**
     * Asserts that exactly the given artifacts, plus checksum files, have been published.