source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.metadata.repository.memory;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *   http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import org.apache.archiva.metadata.model.ArtifactMetadata;
  23 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  24 import org.apache.archiva.metadata.model.ProjectVersionReference;
  25 import org.apache.archiva.metadata.repository.MetadataResolver;
  26 import org.apache.archiva.metadata.repository.RepositorySession;
  27
  28 import java.util.Collection;
  29 import java.util.Collections;
  30 import java.util.HashMap;
  31 import java.util.LinkedHashSet;
  32 import java.util.List;
  33 import java.util.Map;
  34 import java.util.Set;
  35
  36 public class TestMetadataResolver
  37     implements MetadataResolver
  38 {
  39     private Map<String, ProjectVersionMetadata> projectVersions = new HashMap<String, ProjectVersionMetadata>();
  40
  41     private Map<String, List<ArtifactMetadata>> artifacts = new HashMap<String, List<ArtifactMetadata>>();
  42
  43     private Map<String, List<ProjectVersionReference>> references =
  44         new HashMap<String, List<ProjectVersionReference>>();
  45
  46     private Map<String, List<String>> namespaces = new HashMap<String, List<String>>();
  47
  48     private Map<String, Collection<String>> projectsInNamespace = new HashMap<String, Collection<String>>();
  49
  50     private Map<String, Collection<String>> versionsInProject = new HashMap<String, Collection<String>>();
  51
  52     public ProjectVersionMetadata resolveProjectVersion( RepositorySession repositorySession, String repoId,
  53                                                          String namespace, String projectId, String projectVersion )
  54     {
  55         return projectVersions.get( createMapKey( repoId, namespace, projectId, projectVersion ) );
  56     }
  57
  58     public Collection<ProjectVersionReference> resolveProjectReferences( RepositorySession repositorySession,
  59                                                                          String repoId, String namespace,
  60                                                                          String projectId, String projectVersion )
  61     {
  62         Collection<ProjectVersionReference> projectVersionReferences =
  63             references.get( createMapKey( repoId, namespace, projectId, projectVersion ) );
  64         return projectVersionReferences;
  65     }
  66
  67     public Collection<String> resolveRootNamespaces( RepositorySession repositorySession, String repoId )
  68     {
  69         return resolveNamespaces( repositorySession, repoId, null );
  70     }
  71
  72     public Collection<String> resolveNamespaces( RepositorySession repositorySession, String repoId,
  73                                                  String baseNamespace )
  74     {
  75         Set<String> namespaces = new LinkedHashSet<String>();
  76         int fromIndex = baseNamespace != null ? baseNamespace.length() + 1 : 0;
  77         for ( String namespace : this.namespaces.get( repoId ) )
  78         {
  79             if ( baseNamespace == null || namespace.startsWith( baseNamespace + "." ) )
  80             {
  81                 int i = namespace.indexOf( '.', fromIndex );
  82                 if ( i >= 0 )
  83                 {
  84                     namespaces.add( namespace.substring( fromIndex, i ) );
  85                 }
  86                 else
  87                 {
  88                     namespaces.add( namespace.substring( fromIndex ) );
  89                 }
  90             }
  91         }
  92         return namespaces;
  93     }
  94
  95     public Collection<String> resolveProjects( RepositorySession repositorySession, String repoId, String namespace )
  96     {
  97         Collection<String> list = projectsInNamespace.get( namespace );
  98         return list != null ? list : Collections.<String>emptyList();
  99     }
 100
 101     public Collection<String> resolveProjectVersions( RepositorySession repositorySession, String repoId,
 102                                                       String namespace, String projectId )
 103     {
 104         Collection<String> list = versionsInProject.get( namespace + ":" + projectId );
 105         return list != null ? list : Collections.<String>emptyList();
 106     }
 107
 108     public Collection<ArtifactMetadata> resolveArtifacts( RepositorySession repositorySession, String repoId,
 109                                                           String namespace, String projectId, String projectVersion )
 110     {
 111         List<ArtifactMetadata> artifacts =
 112             this.artifacts.get( createMapKey( repoId, namespace, projectId, projectVersion ) );
 113         return ( artifacts != null ? artifacts : Collections.<ArtifactMetadata>emptyList() );
 114     }
 115
 116     public void setProjectVersion( String repoId, String namespace, String projectId,
 117                                    ProjectVersionMetadata versionMetadata )
 118     {
 119         projectVersions.put( createMapKey( repoId, namespace, projectId, versionMetadata.getId() ), versionMetadata );
 120
 121         Collection<String> projects = projectsInNamespace.get( namespace );
 122         if ( projects == null )
 123         {
 124             projects = new LinkedHashSet<String>();
 125             projectsInNamespace.put( namespace, projects );
 126         }
 127         projects.add( projectId );
 128
 129         String key = namespace + ":" + projectId;
 130         Collection<String> versions = versionsInProject.get( key );
 131         if ( versions == null )
 132         {
 133             versions = new LinkedHashSet<String>();
 134             versionsInProject.put( key, versions );
 135         }
 136         versions.add( versionMetadata.getId() );
 137     }
 138
 139     public void setArtifacts( String repoId, String namespace, String projectId, String projectVersion,
 140                               List<ArtifactMetadata> artifacts )
 141     {
 142         this.artifacts.put( createMapKey( repoId, namespace, projectId, projectVersion ), artifacts );
 143     }
 144
 145     private String createMapKey( String repoId, String namespace, String projectId, String projectVersion )
 146     {
 147         return repoId + ":" + namespace + ":" + projectId + ":" + projectVersion;
 148     }
 149
 150     public void setProjectReferences( String repoId, String namespace, String projectId, String projectVersion,
 151                                       List<ProjectVersionReference> references )
 152     {
 153         this.references.put( createMapKey( repoId, namespace, projectId, projectVersion ), references );
 154     }
 155
 156     public void setNamespaces( String repoId, List<String> namespaces )
 157     {
 158         this.namespaces.put( repoId, namespaces );
 159     }
 160 }