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 mavenPluginPattern = Pattern.compile( "(maven-.*-plugin)|(.*-maven-plugin)" );
  42
  43     private static final Pattern extensionPattern =
  44         Pattern.compile( "(.tar.gz$)|(.tar.bz2$)|(.[a-z0-9]*$)", Pattern.CASE_INSENSITIVE );
  45
  46     private static final Pattern SNAPSHOT_PATTERN = Pattern.compile( "^([0-9]{8}\\.[0-9]{6}-[0-9]+)(.*)$" );
  47
  48     private static final Pattern section = Pattern.compile( "([^-]*)" );
  49
  50     private Matcher matcher;
  51
  52     protected FilenameParser( String filename )
  53     {
  54         this.name = filename;
  55
  56         Matcher mat = extensionPattern.matcher( name );
  57         if ( mat.find() )
  58         {
  59             extension = filename.substring( mat.start() + 1 );
  60             name = name.substring( 0, name.length() - extension.length() - 1 );
  61         }
  62
  63         matcher = section.matcher( name );
  64
  65         reset();
  66     }
  67
  68     protected void reset()
  69     {
  70         offset = 0;
  71     }
  72
  73     protected String next()
  74     {
  75         // Past the end of the string.
  76         if ( offset > name.length() )
  77         {
  78             return null;
  79         }
  80
  81         // Return the next section.
  82         if ( matcher.find( offset ) )
  83         {
  84             // Return found section.
  85             offset = matcher.end() + 1;
  86             return matcher.group();
  87         }
  88
  89         // Nothing to return.
  90         return null;
  91     }
  92
  93     protected String expect( String expected )
  94     {
  95         String value = null;
  96
  97         if ( name.startsWith( expected, offset ) )
  98         {
  99             value = expected;
 100         }
 101         else if ( VersionUtil.isGenericSnapshot( expected ) )
 102         {
 103             String version = name.substring( offset );
 104
 105             // check it starts with the same version up to the snapshot part
 106             int leadingLength = expected.length() - 9;
 107             if ( version.startsWith( expected.substring( 0, leadingLength ) ) && version.length() > leadingLength )
 108             {
 109                 // If we expect a non-generic snapshot - look for the timestamp
 110                 Matcher m = SNAPSHOT_PATTERN.matcher( version.substring( leadingLength + 1 ) );
 111                 if ( m.matches() )
 112                 {
 113                     value = version.substring( 0, leadingLength + 1 ) + m.group( 1 );
 114                 }
 115             }
 116         }
 117
 118         if ( value != null )
 119         {
 120             // Potential hit. check for '.' or '-' at end of expected.
 121             int seperatorOffset = offset + value.length();
 122
 123             // Test for "out of bounds" first.
 124             if ( seperatorOffset >= name.length() )
 125             {
 126                 offset = name.length();
 127                 return value;
 128             }
 129
 130             // Test for seperator char.
 131             char seperatorChar = name.charAt( seperatorOffset );
 132             if ( ( seperatorChar == '-' ) || ( seperatorChar == '.' ) )
 133             {
 134                 offset = seperatorOffset + 1;
 135                 return value;
 136             }
 137         }
 138
 139         return null;
 140     }
 141
 142     /**
 143      * Get the current seperator character.
 144      *
 145      * @return the seperator character (either '.' or '-'), or 0 if no seperator character available.
 146      */
 147     protected char seperator()
 148     {
 149         // Past the end of the string?
 150         if ( offset >= name.length() )
 151         {
 152             return 0;
 153         }
 154
 155         // Before the start of the string?
 156         if ( offset <= 0 )
 157         {
 158             return 0;
 159         }
 160
 161         return name.charAt( offset - 1 );
 162     }
 163
 164     protected String getName()
 165     {
 166         return name;
 167     }
 168
 169     protected String getExtension()
 170     {
 171         return extension;
 172     }
 173
 174     protected String remaining()
 175     {
 176         if ( offset >= name.length() )
 177         {
 178             return null;
 179         }
 180
 181         String end = name.substring( offset );
 182         offset = name.length();
 183         return end;
 184     }
 185
 186     protected String nextNonVersion()
 187     {
 188         boolean done = false;
 189
 190         StringBuffer ver = new StringBuffer();
 191
 192         // Any text upto the end of a special case is considered non-version.
 193         Matcher specialMat = mavenPluginPattern.matcher( name );
 194         if ( specialMat.find() )
 195         {
 196             ver.append( name.substring( offset, specialMat.end() ) );
 197             offset = specialMat.end() + 1;
 198         }
 199
 200         while ( !done )
 201         {
 202             int initialOffset = offset;
 203             String section = next();
 204             if ( section == null )
 205             {
 206                 done = true;
 207             }
 208             else if ( !VersionUtil.isVersion( section ) )
 209             {
 210                 if ( ver.length() > 0 )
 211                 {
 212                     ver.append( '-' );
 213                 }
 214                 ver.append( section );
 215             }
 216             else
 217             {
 218                 offset = initialOffset;
 219                 done = true;
 220             }
 221         }
 222
 223         return ver.toString();
 224     }
 225
 226     protected String nextVersion()
 227     {
 228         boolean done = false;
 229
 230         StringBuffer ver = new StringBuffer();
 231
 232         while ( !done )
 233         {
 234             int initialOffset = offset;
 235             String section = next();
 236             if ( section == null )
 237             {
 238                 done = true;
 239             }
 240             else if ( VersionUtil.isVersion( section ) )
 241             {
 242                 if ( ver.length() > 0 )
 243                 {
 244                     ver.append( '-' );
 245                 }
 246                 ver.append( section );
 247             }
 248             else
 249             {
 250                 offset = initialOffset;
 251                 done = true;
 252             }
 253         }
 254
 255         return ver.toString();
 256     }
 257
 258
 259 }