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

   1 package org.apache.archiva.repository.maven.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  * Unless required by applicable law or agreed to in writing,
  14  * software distributed under the License is distributed on an
  15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  16  * KIND, either express or implied.  See the License for the
  17  * specific language governing permissions and limitations
  18  * under the License.
  19  */
  20
  21 import org.apache.archiva.common.utils.VersionUtil;
  22
  23 import java.util.regex.Matcher;
  24 import java.util.regex.Pattern;
  25
  26 /**
  27  * Generic Filename Parser for use with layout routines.
  28  *
  29  *
  30  */
  31 public class FilenameParser
  32 {
  33     private String name;
  34
  35     private String extension;
  36
  37     private int offset;
  38
  39     private static final Pattern mavenPluginPattern = Pattern.compile( "(maven-.*-plugin)|(.*-maven-plugin)" );
  40
  41     private static final Pattern extensionPattern =
  42         Pattern.compile( "(\\.tar\\.gz$)|(\\.tar\\.bz2$)|(\\.[\\-a-z0-9]*$)", Pattern.CASE_INSENSITIVE );
  43
  44     private static final Pattern SNAPSHOT_PATTERN = Pattern.compile( "^([0-9]{8}\\.[0-9]{6}-[0-9]+)(.*)$" );
  45
  46     private static final Pattern section = Pattern.compile( "([^-]*)" );
  47
  48     private Matcher matcher;
  49
  50     public 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     public void reset()
  67     {
  68         offset = 0;
  69     }
  70
  71     public 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         String value = null;
  94
  95         if ( name.startsWith( expected, offset ) )
  96         {
  97             value = expected;
  98         }
  99         else if ( VersionUtil.isGenericSnapshot( expected ) )
 100         {
 101             String version = name.substring( offset );
 102
 103             // check it starts with the same version up to the snapshot part
 104             int leadingLength = expected.length() - 9;
 105             if ( leadingLength > 0 && version.startsWith( expected.substring( 0, leadingLength ) ) &&
 106                 version.length() > leadingLength )
 107             {
 108                 // If we expect a non-generic snapshot - look for the timestamp
 109                 Matcher m = SNAPSHOT_PATTERN.matcher( version.substring( leadingLength + 1 ) );
 110                 if ( m.matches() )
 111                 {
 112                     value = version.substring( 0, leadingLength + 1 ) + m.group( 1 );
 113                 }
 114             }
 115         }
 116
 117         if ( value != null )
 118         {
 119             // Potential hit. check for '.' or '-' at end of expected.
 120             int seperatorOffset = offset + value.length();
 121
 122             // Test for "out of bounds" first.
 123             if ( seperatorOffset >= name.length() )
 124             {
 125                 offset = name.length();
 126                 return value;
 127             }
 128
 129             // Test for seperator char.
 130             char seperatorChar = name.charAt( seperatorOffset );
 131             if ( ( seperatorChar == '-' ) || ( seperatorChar == '.' ) )
 132             {
 133                 offset = seperatorOffset + 1;
 134                 return value;
 135             }
 136         }
 137
 138         return null;
 139     }
 140
 141     /**
 142      * Get the current seperator character.
 143      *
 144      * @return the seperator character (either '.' or '-'), or 0 if no seperator character available.
 145      */
 146     protected char seperator()
 147     {
 148         // Past the end of the string?
 149         if ( offset >= name.length() )
 150         {
 151             return 0;
 152         }
 153
 154         // Before the start of the string?
 155         if ( offset <= 0 )
 156         {
 157             return 0;
 158         }
 159
 160         return name.charAt( offset - 1 );
 161     }
 162
 163     protected String getName()
 164     {
 165         return name;
 166     }
 167
 168     public String getExtension()
 169     {
 170         return extension;
 171     }
 172
 173     public String remaining()
 174     {
 175         if ( offset >= name.length() )
 176         {
 177             return null;
 178         }
 179
 180         String end = name.substring( offset );
 181         offset = name.length();
 182         return end;
 183     }
 184
 185     public String nextNonVersion()
 186     {
 187         boolean done = false;
 188
 189         StringBuilder ver = new StringBuilder();
 190
 191         // Any text upto the end of a special case is considered non-version.
 192         Matcher specialMat = mavenPluginPattern.matcher( name );
 193         if ( specialMat.find() )
 194         {
 195             ver.append( name.substring( offset, specialMat.end() ) );
 196             offset = specialMat.end() + 1;
 197         }
 198
 199         while ( !done )
 200         {
 201             int initialOffset = offset;
 202             String section = next();
 203             if ( section == null )
 204             {
 205                 done = true;
 206             }
 207             else if ( !VersionUtil.isVersion( section ) )
 208             {
 209                 if ( ver.length() > 0 )
 210                 {
 211                     ver.append( '-' );
 212                 }
 213                 ver.append( section );
 214             }
 215             else
 216             {
 217                 offset = initialOffset;
 218                 done = true;
 219             }
 220         }
 221
 222         return ver.toString();
 223     }
 224
 225     protected String nextVersion()
 226     {
 227         boolean done = false;
 228
 229         StringBuilder ver = new StringBuilder();
 230
 231         while ( !done )
 232         {
 233             int initialOffset = offset;
 234             String section = next();
 235             if ( section == null )
 236             {
 237                 done = true;
 238             }
 239             else if ( VersionUtil.isVersion( section ) )
 240             {
 241                 if ( ver.length() > 0 )
 242                 {
 243                     ver.append( '-' );
 244                 }
 245                 ver.append( section );
 246             }
 247             else
 248             {
 249                 offset = initialOffset;
 250                 done = true;
 251             }
 252         }
 253
 254         return ver.toString();
 255     }
 256
 257
 258 }