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

   1 package org.apache.maven.archiva.repository.content;
   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.maven.archiva.common.utils.VersionUtil;
  23
  24 import java.util.regex.Matcher;
  25 import java.util.regex.Pattern;
  26
  27 /**
  28  * Generic Filename Parser for use with layout routines.
  29  *
  30  * @author <a href="mailto:joakime@apache.org">Joakim Erdfelt</a>
  31  * @version $Id$
  32  */
  33 public class FilenameParser
  34 {
  35     private String name;
  36
  37     private String extension;
  38
  39     private int offset;
  40
  41     private static final Pattern specialCases = Pattern.compile( "(maven-.*-plugin)|(maven-plugin)" );
  42
  43     private static final Pattern extensionPattern = Pattern.compile( "(.tar.gz$)|(.tar.bz2$)|(.[a-z0-9]{1,4}$)",
  44                                                                      Pattern.CASE_INSENSITIVE );
  45
  46     private static final Pattern section = Pattern.compile( "([^-]*)" );
  47
  48     private Matcher matcher;
  49
  50     protected FilenameParser( String filename )
  51     {
  52         this.name = filename;
  53
  54         Matcher mat = extensionPattern.matcher( name );
  55         if ( mat.find() )
  56         {
  57             extension = filename.substring( mat.start() + 1 );
  58             name = name.substring( 0, name.length() - extension.length() - 1 );
  59         }
  60
  61         matcher = section.matcher( name );
  62
  63         reset();
  64     }
  65
  66     protected void reset()
  67     {
  68         offset = 0;
  69     }
  70
  71     protected String next()
  72     {
  73         // Past the end of the string.
  74         if ( offset > name.length() )
  75         {
  76             return null;
  77         }
  78
  79         // Return the next section.
  80         if ( matcher.find( offset ) )
  81         {
  82             // Return found section.
  83             offset = matcher.end() + 1;
  84             return matcher.group();
  85         }
  86
  87         // Nothing to return.
  88         return null;
  89     }
  90
  91     protected String expect( String expected )
  92     {
  93         if ( name.startsWith( expected, offset ) )
  94         {
  95             // Potential hit. check for '.' or '-' at end of expected.
  96             int seperatorOffset = offset + expected.length();
  97
  98             // Test for "out of bounds" first.
  99             if ( seperatorOffset >= name.length() )
 100             {
 101                 offset = name.length();
 102                 return expected;
 103             }
 104
 105             // Test for seperator char.
 106             char seperatorChar = name.charAt( seperatorOffset );
 107             if ( ( seperatorChar == '-' ) || ( seperatorChar == '.' ) )
 108             {
 109                 offset = seperatorOffset + 1;
 110                 return expected;
 111             }
 112         }
 113
 114         return null;
 115     }
 116
 117     protected String getName()
 118     {
 119         return name;
 120     }
 121
 122     protected String getExtension()
 123     {
 124         return extension;
 125     }
 126
 127     protected String remaining()
 128     {
 129         if ( offset >= name.length() )
 130         {
 131             return null;
 132         }
 133
 134         String end = name.substring( offset );
 135         offset = name.length();
 136         return end;
 137     }
 138
 139     protected String nextNonVersion()
 140     {
 141         boolean done = false;
 142
 143         StringBuffer ver = new StringBuffer();
 144
 145         // Any text upto the end of a special case is considered non-version.
 146         Matcher specialMat = specialCases.matcher( name );
 147         if ( specialMat.find() )
 148         {
 149             ver.append( name.substring( offset, specialMat.end() ) );
 150             offset = specialMat.end() + 1;
 151         }
 152
 153         while ( !done )
 154         {
 155             int initialOffset = offset;
 156             String section = next();
 157             if ( section == null )
 158             {
 159                 done = true;
 160             }
 161             else if ( !VersionUtil.isVersion( section ) )
 162             {
 163                 if ( ver.length() > 0 )
 164                 {
 165                     ver.append( '-' );
 166                 }
 167                 ver.append( section );
 168             }
 169             else
 170             {
 171                 offset = initialOffset;
 172                 done = true;
 173             }
 174         }
 175
 176         return ver.toString();
 177     }
 178
 179     protected String nextVersion()
 180     {
 181         boolean done = false;
 182
 183         StringBuffer ver = new StringBuffer();
 184
 185         while ( !done )
 186         {
 187             int initialOffset = offset;
 188             String section = next();
 189             if ( section == null )
 190             {
 191                 done = true;
 192             }
 193             else if ( VersionUtil.isVersion( section ) )
 194             {
 195                 if ( ver.length() > 0 )
 196                 {
 197                     ver.append( '-' );
 198                 }
 199                 ver.append( section );
 200             }
 201             else
 202             {
 203                 offset = initialOffset;
 204                 done = true;
 205             }
 206         }
 207
 208         return ver.toString();
 209     }
 210 }