ant-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dona...@apache.org
Subject cvs commit: jakarta-ant/proposal/myrmidon/src/main/org/apache/tools/ant/types ScannerUtil.java DirectoryScanner.java PatternSet.java
Date Thu, 24 Jan 2002 11:38:06 GMT
donaldp     02/01/24 03:38:06

  Modified:    proposal/myrmidon/src/main/org/apache/tools/ant/taskdefs
                        Expand.java
               proposal/myrmidon/src/main/org/apache/tools/ant/taskdefs/optional/ide
                        VAJWorkspaceScanner.java
               proposal/myrmidon/src/main/org/apache/tools/ant/taskdefs/optional/scm
                        AntStarTeamCheckOut.java
               proposal/myrmidon/src/main/org/apache/tools/ant/types
                        DirectoryScanner.java PatternSet.java
  Added:       proposal/myrmidon/src/main/org/apache/tools/ant/types
                        ScannerUtil.java
  Log:
  Create a utility class to contain all the static scanner utility functions
  
  Revision  Changes    Path
  1.16      +3 -2      jakarta-ant/proposal/myrmidon/src/main/org/apache/tools/ant/taskdefs/Expand.java
  
  Index: Expand.java
  ===================================================================
  RCS file: /home/cvs/jakarta-ant/proposal/myrmidon/src/main/org/apache/tools/ant/taskdefs/Expand.java,v
  retrieving revision 1.15
  retrieving revision 1.16
  diff -u -r1.15 -r1.16
  --- Expand.java	22 Jan 2002 12:14:58 -0000	1.15
  +++ Expand.java	24 Jan 2002 11:38:05 -0000	1.16
  @@ -22,6 +22,7 @@
   import org.apache.tools.ant.types.DirectoryScanner;
   import org.apache.tools.ant.types.FileSet;
   import org.apache.tools.ant.types.PatternSet;
  +import org.apache.tools.ant.types.ScannerUtil;
   
   /**
    * Unzip a file.
  @@ -205,7 +206,7 @@
                   {
                       for( int w = 0; w < incls.length; w++ )
                       {
  -                        boolean isIncl = DirectoryScanner.match( incls[ w ], name );
  +                        boolean isIncl = ScannerUtil.match( incls[ w ], name );
                           if( isIncl )
                           {
                               included = true;
  @@ -218,7 +219,7 @@
                   {
                       for( int w = 0; w < excls.length; w++ )
                       {
  -                        boolean isExcl = DirectoryScanner.match( excls[ w ], name );
  +                        boolean isExcl = ScannerUtil.match( excls[ w ], name );
                           if( isExcl )
                           {
                               included = false;
  
  
  
  1.8       +2 -1      jakarta-ant/proposal/myrmidon/src/main/org/apache/tools/ant/taskdefs/optional/ide/VAJWorkspaceScanner.java
  
  Index: VAJWorkspaceScanner.java
  ===================================================================
  RCS file: /home/cvs/jakarta-ant/proposal/myrmidon/src/main/org/apache/tools/ant/taskdefs/optional/ide/VAJWorkspaceScanner.java,v
  retrieving revision 1.7
  retrieving revision 1.8
  diff -u -r1.7 -r1.8
  --- VAJWorkspaceScanner.java	13 Jan 2002 00:01:42 -0000	1.7
  +++ VAJWorkspaceScanner.java	24 Jan 2002 11:38:05 -0000	1.8
  @@ -15,6 +15,7 @@
   import java.util.Iterator;
   import java.util.StringTokenizer;
   import org.apache.tools.ant.types.DirectoryScanner;
  +import org.apache.tools.ant.types.ScannerUtil;
   
   /**
    * Class for scanning a Visual Age for Java workspace for packages matching a
  @@ -69,7 +70,7 @@
        */
       protected static boolean match( String pattern, String str )
       {
  -        return DirectoryScanner.match( pattern, str );
  +        return ScannerUtil.match( pattern, str );
       }
   
       /**
  
  
  
  1.7       +2 -1      jakarta-ant/proposal/myrmidon/src/main/org/apache/tools/ant/taskdefs/optional/scm/AntStarTeamCheckOut.java
  
  Index: AntStarTeamCheckOut.java
  ===================================================================
  RCS file: /home/cvs/jakarta-ant/proposal/myrmidon/src/main/org/apache/tools/ant/taskdefs/optional/scm/AntStarTeamCheckOut.java,v
  retrieving revision 1.6
  retrieving revision 1.7
  diff -u -r1.6 -r1.7
  --- AntStarTeamCheckOut.java	12 Jan 2002 23:53:32 -0000	1.6
  +++ AntStarTeamCheckOut.java	24 Jan 2002 11:38:05 -0000	1.7
  @@ -18,6 +18,7 @@
   import java.util.StringTokenizer;
   import org.apache.myrmidon.api.TaskException;
   import org.apache.tools.ant.types.DirectoryScanner;
  +import org.apache.tools.ant.types.ScannerUtil;
   
   /**
    * Checks out files from a specific StarTeam server, project, view, and folder.
  @@ -765,7 +766,7 @@
           StringTokenizer exStr = new StringTokenizer( patterns, " " );
           while( exStr.hasMoreTokens() )
           {
  -            if( DirectoryScanner.match( exStr.nextToken(), pName ) )
  +            if( ScannerUtil.match( exStr.nextToken(), pName ) )
               {
                   return true;
               }
  
  
  
  1.2       +6 -516    jakarta-ant/proposal/myrmidon/src/main/org/apache/tools/ant/types/DirectoryScanner.java
  
  Index: DirectoryScanner.java
  ===================================================================
  RCS file: /home/cvs/jakarta-ant/proposal/myrmidon/src/main/org/apache/tools/ant/types/DirectoryScanner.java,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- DirectoryScanner.java	12 Jan 2002 23:49:29 -0000	1.1
  +++ DirectoryScanner.java	24 Jan 2002 11:38:06 -0000	1.2
  @@ -91,24 +91,6 @@
   public class DirectoryScanner
       implements FileScanner
   {
  -    /**
  -     * Patterns that should be excluded by default.
  -     *
  -     * @see #addDefaultExcludes()
  -     */
  -    private final static String[] DEFAULTEXCLUDES =
  -        {
  -            "**/*~",
  -            "**/#*#",
  -            "**/.#*",
  -            "**/%*%",
  -            "**/CVS",
  -            "**/CVS/**",
  -            "**/.cvsignore",
  -            "**/SCCS",
  -            "**/SCCS/**",
  -            "**/vssver.scc"
  -        };
   
       /**
        * Have the ArrayLists holding our results been built by a slow scan?
  @@ -175,493 +157,6 @@
       private String[] m_includes;
   
       /**
  -     * Matches a string against a pattern. The pattern contains two special
  -     * characters: '*' which means zero or more characters, '?' which means one
  -     * and only one character.
  -     *
  -     * @param pattern the (non-null) pattern to match against
  -     * @param str the (non-null) string that must be matched against the pattern
  -     * @return <code>true</code> when the string matches against the pattern,
  -     *      <code>false</code> otherwise.
  -     */
  -    public static boolean match( final String pattern, final String str )
  -    {
  -        return match( pattern, str, true );
  -    }
  -
  -    /**
  -     * Matches a string against a pattern. The pattern contains two special
  -     * characters: '*' which means zero or more characters, '?' which means one
  -     * and only one character.
  -     *
  -     * @param pattern the (non-null) pattern to match against
  -     * @param str the (non-null) string that must be matched against the pattern
  -     * @param isCaseSensitive Description of Parameter
  -     * @return <code>true</code> when the string matches against the pattern,
  -     *      <code>false</code> otherwise.
  -     */
  -    protected static boolean match( final String pattern,
  -                                    final String str,
  -                                    final boolean isCaseSensitive )
  -    {
  -        char[] patArr = pattern.toCharArray();
  -        char[] strArr = str.toCharArray();
  -        int patIdxStart = 0;
  -        int patIdxEnd = patArr.length - 1;
  -        int strIdxStart = 0;
  -        int strIdxEnd = strArr.length - 1;
  -        char ch;
  -
  -        boolean containsStar = false;
  -        for( int i = 0; i < patArr.length; i++ )
  -        {
  -            if( patArr[ i ] == '*' )
  -            {
  -                containsStar = true;
  -                break;
  -            }
  -        }
  -
  -        if( !containsStar )
  -        {
  -            // No '*'s, so we make a shortcut
  -            if( patIdxEnd != strIdxEnd )
  -            {
  -                return false;// Pattern and string do not have the same size
  -            }
  -            for( int i = 0; i <= patIdxEnd; i++ )
  -            {
  -                ch = patArr[ i ];
  -                if( ch != '?' )
  -                {
  -                    if( isCaseSensitive && ch != strArr[ i ] )
  -                    {
  -                        return false;// Character mismatch
  -                    }
  -                    if( !isCaseSensitive && Character.toUpperCase( ch ) !=
  -                        Character.toUpperCase( strArr[ i ] ) )
  -                    {
  -                        return false;// Character mismatch
  -                    }
  -                }
  -            }
  -            return true;// String matches against pattern
  -        }
  -
  -        if( patIdxEnd == 0 )
  -        {
  -            return true;// Pattern contains only '*', which matches anything
  -        }
  -
  -        // Process characters before first star
  -        while( ( ch = patArr[ patIdxStart ] ) != '*' && strIdxStart <= strIdxEnd
)
  -        {
  -            if( ch != '?' )
  -            {
  -                if( isCaseSensitive && ch != strArr[ strIdxStart ] )
  -                {
  -                    return false;// Character mismatch
  -                }
  -                if( !isCaseSensitive && Character.toUpperCase( ch ) !=
  -                    Character.toUpperCase( strArr[ strIdxStart ] ) )
  -                {
  -                    return false;// Character mismatch
  -                }
  -            }
  -            patIdxStart++;
  -            strIdxStart++;
  -        }
  -        if( strIdxStart > strIdxEnd )
  -        {
  -            // All characters in the string are used. Check if only '*'s are
  -            // left in the pattern. If so, we succeeded. Otherwise failure.
  -            for( int i = patIdxStart; i <= patIdxEnd; i++ )
  -            {
  -                if( patArr[ i ] != '*' )
  -                {
  -                    return false;
  -                }
  -            }
  -            return true;
  -        }
  -
  -        // Process characters after last star
  -        while( ( ch = patArr[ patIdxEnd ] ) != '*' && strIdxStart <= strIdxEnd
)
  -        {
  -            if( ch != '?' )
  -            {
  -                if( isCaseSensitive && ch != strArr[ strIdxEnd ] )
  -                {
  -                    return false;// Character mismatch
  -                }
  -                if( !isCaseSensitive && Character.toUpperCase( ch ) !=
  -                    Character.toUpperCase( strArr[ strIdxEnd ] ) )
  -                {
  -                    return false;// Character mismatch
  -                }
  -            }
  -            patIdxEnd--;
  -            strIdxEnd--;
  -        }
  -        if( strIdxStart > strIdxEnd )
  -        {
  -            // All characters in the string are used. Check if only '*'s are
  -            // left in the pattern. If so, we succeeded. Otherwise failure.
  -            for( int i = patIdxStart; i <= patIdxEnd; i++ )
  -            {
  -                if( patArr[ i ] != '*' )
  -                {
  -                    return false;
  -                }
  -            }
  -            return true;
  -        }
  -
  -        // process pattern between stars. padIdxStart and patIdxEnd point
  -        // always to a '*'.
  -        while( patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd )
  -        {
  -            int patIdxTmp = -1;
  -            for( int i = patIdxStart + 1; i <= patIdxEnd; i++ )
  -            {
  -                if( patArr[ i ] == '*' )
  -                {
  -                    patIdxTmp = i;
  -                    break;
  -                }
  -            }
  -            if( patIdxTmp == patIdxStart + 1 )
  -            {
  -                // Two stars next to each other, skip the first one.
  -                patIdxStart++;
  -                continue;
  -            }
  -            // Find the pattern between padIdxStart & padIdxTmp in str between
  -            // strIdxStart & strIdxEnd
  -            int patLength = ( patIdxTmp - patIdxStart - 1 );
  -            int strLength = ( strIdxEnd - strIdxStart + 1 );
  -            int foundIdx = -1;
  -            strLoop :
  -            for( int i = 0; i <= strLength - patLength; i++ )
  -            {
  -                for( int j = 0; j < patLength; j++ )
  -                {
  -                    ch = patArr[ patIdxStart + j + 1 ];
  -                    if( ch != '?' )
  -                    {
  -                        if( isCaseSensitive && ch != strArr[ strIdxStart + i +
j ] )
  -                        {
  -                            continue strLoop;
  -                        }
  -                        if( !isCaseSensitive && Character.toUpperCase( ch ) !=
  -                            Character.toUpperCase( strArr[ strIdxStart + i + j ] ) )
  -                        {
  -                            continue strLoop;
  -                        }
  -                    }
  -                }
  -
  -                foundIdx = strIdxStart + i;
  -                break;
  -            }
  -
  -            if( foundIdx == -1 )
  -            {
  -                return false;
  -            }
  -
  -            patIdxStart = patIdxTmp;
  -            strIdxStart = foundIdx + patLength;
  -        }
  -
  -        // All characters in the string are used. Check if only '*'s are left
  -        // in the pattern. If so, we succeeded. Otherwise failure.
  -        for( int i = patIdxStart; i <= patIdxEnd; i++ )
  -        {
  -            if( patArr[ i ] != '*' )
  -            {
  -                return false;
  -            }
  -        }
  -        return true;
  -    }
  -
  -    /**
  -     * Matches a path against a pattern.
  -     *
  -     * @param pattern the (non-null) pattern to match against
  -     * @param str the (non-null) string (path) to match
  -     * @return <code>true</code> when the pattern matches against the string.
  -     *      <code>false</code> otherwise.
  -     */
  -    protected static boolean matchPath( final String pattern, final String str )
  -    {
  -        return matchPath( pattern, str, true );
  -    }
  -
  -    /**
  -     * Matches a path against a pattern.
  -     *
  -     * @param pattern the (non-null) pattern to match against
  -     * @param str the (non-null) string (path) to match
  -     * @param isCaseSensitive must a case sensitive match be done?
  -     * @return <code>true</code> when the pattern matches against the string.
  -     *      <code>false</code> otherwise.
  -     */
  -    protected static boolean matchPath( final String pattern,
  -                                        final String str,
  -                                        final boolean isCaseSensitive )
  -    {
  -        // When str starts with a File.separator, pattern has to start with a
  -        // File.separator.
  -        // When pattern starts with a File.separator, str has to start with a
  -        // File.separator.
  -        if( str.startsWith( File.separator ) !=
  -            pattern.startsWith( File.separator ) )
  -        {
  -            return false;
  -        }
  -
  -        ArrayList patDirs = new ArrayList();
  -        StringTokenizer st = new StringTokenizer( pattern, File.separator );
  -        while( st.hasMoreTokens() )
  -        {
  -            patDirs.add( st.nextToken() );
  -        }
  -
  -        ArrayList strDirs = new ArrayList();
  -        st = new StringTokenizer( str, File.separator );
  -        while( st.hasMoreTokens() )
  -        {
  -            strDirs.add( st.nextToken() );
  -        }
  -
  -        int patIdxStart = 0;
  -        int patIdxEnd = patDirs.size() - 1;
  -        int strIdxStart = 0;
  -        int strIdxEnd = strDirs.size() - 1;
  -
  -        // up to first '**'
  -        while( patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd )
  -        {
  -            String patDir = (String)patDirs.get( patIdxStart );
  -            if( patDir.equals( "**" ) )
  -            {
  -                break;
  -            }
  -            if( !match( patDir, (String)strDirs.get( strIdxStart ), isCaseSensitive ) )
  -            {
  -                return false;
  -            }
  -            patIdxStart++;
  -            strIdxStart++;
  -        }
  -        if( strIdxStart > strIdxEnd )
  -        {
  -            // String is exhausted
  -            for( int i = patIdxStart; i <= patIdxEnd; i++ )
  -            {
  -                if( !patDirs.get( i ).equals( "**" ) )
  -                {
  -                    return false;
  -                }
  -            }
  -            return true;
  -        }
  -        else
  -        {
  -            if( patIdxStart > patIdxEnd )
  -            {
  -                // String not exhausted, but pattern is. Failure.
  -                return false;
  -            }
  -        }
  -
  -        // up to last '**'
  -        while( patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd )
  -        {
  -            String patDir = (String)patDirs.get( patIdxEnd );
  -            if( patDir.equals( "**" ) )
  -            {
  -                break;
  -            }
  -            if( !match( patDir, (String)strDirs.get( strIdxEnd ), isCaseSensitive ) )
  -            {
  -                return false;
  -            }
  -            patIdxEnd--;
  -            strIdxEnd--;
  -        }
  -        if( strIdxStart > strIdxEnd )
  -        {
  -            // String is exhausted
  -            for( int i = patIdxStart; i <= patIdxEnd; i++ )
  -            {
  -                if( !patDirs.get( i ).equals( "**" ) )
  -                {
  -                    return false;
  -                }
  -            }
  -            return true;
  -        }
  -
  -        while( patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd )
  -        {
  -            int patIdxTmp = -1;
  -            for( int i = patIdxStart + 1; i <= patIdxEnd; i++ )
  -            {
  -                if( patDirs.get( i ).equals( "**" ) )
  -                {
  -                    patIdxTmp = i;
  -                    break;
  -                }
  -            }
  -            if( patIdxTmp == patIdxStart + 1 )
  -            {
  -                // '**/**' situation, so skip one
  -                patIdxStart++;
  -                continue;
  -            }
  -            // Find the pattern between padIdxStart & padIdxTmp in str between
  -            // strIdxStart & strIdxEnd
  -            int patLength = ( patIdxTmp - patIdxStart - 1 );
  -            int strLength = ( strIdxEnd - strIdxStart + 1 );
  -            int foundIdx = -1;
  -            strLoop :
  -            for( int i = 0; i <= strLength - patLength; i++ )
  -            {
  -                for( int j = 0; j < patLength; j++ )
  -                {
  -                    String subPat = (String)patDirs.get( patIdxStart + j + 1 );
  -                    String subStr = (String)strDirs.get( strIdxStart + i + j );
  -                    if( !match( subPat, subStr, isCaseSensitive ) )
  -                    {
  -                        continue strLoop;
  -                    }
  -                }
  -
  -                foundIdx = strIdxStart + i;
  -                break;
  -            }
  -
  -            if( foundIdx == -1 )
  -            {
  -                return false;
  -            }
  -
  -            patIdxStart = patIdxTmp;
  -            strIdxStart = foundIdx + patLength;
  -        }
  -
  -        for( int i = patIdxStart; i <= patIdxEnd; i++ )
  -        {
  -            if( !patDirs.get( i ).equals( "**" ) )
  -            {
  -                return false;
  -            }
  -        }
  -
  -        return true;
  -    }
  -
  -    /**
  -     * Does the path match the start of this pattern up to the first "**". <p>
  -     *
  -     * This is not a general purpose test and should only be used if you can
  -     * live with false positives.</p> <p>
  -     *
  -     * <code>pattern=**\\a</code> and <code>str=b</code> will yield
true.
  -     *
  -     * @param pattern the (non-null) pattern to match against
  -     * @param str the (non-null) string (path) to match
  -     * @return Description of the Returned Value
  -     */
  -    protected static boolean matchPatternStart( final String pattern, final String str
)
  -    {
  -        return matchPatternStart( pattern, str, true );
  -    }
  -
  -    /**
  -     * Does the path match the start of this pattern up to the first "**". <p>
  -     *
  -     * This is not a general purpose test and should only be used if you can
  -     * live with false positives.</p> <p>
  -     *
  -     * <code>pattern=**\\a</code> and <code>str=b</code> will yield
true.
  -     *
  -     * @param pattern the (non-null) pattern to match against
  -     * @param str the (non-null) string (path) to match
  -     * @param isCaseSensitive must matches be case sensitive?
  -     * @return Description of the Returned Value
  -     */
  -    protected static boolean matchPatternStart( final String pattern,
  -                                                final String str,
  -                                                final boolean isCaseSensitive )
  -    {
  -        // When str starts with a File.separator, pattern has to start with a
  -        // File.separator.
  -        // When pattern starts with a File.separator, str has to start with a
  -        // File.separator.
  -        if( str.startsWith( File.separator ) !=
  -            pattern.startsWith( File.separator ) )
  -        {
  -            return false;
  -        }
  -
  -        ArrayList patDirs = new ArrayList();
  -        StringTokenizer st = new StringTokenizer( pattern, File.separator );
  -        while( st.hasMoreTokens() )
  -        {
  -            patDirs.add( st.nextToken() );
  -        }
  -
  -        ArrayList strDirs = new ArrayList();
  -        st = new StringTokenizer( str, File.separator );
  -        while( st.hasMoreTokens() )
  -        {
  -            strDirs.add( st.nextToken() );
  -        }
  -
  -        int patIdxStart = 0;
  -        int patIdxEnd = patDirs.size() - 1;
  -        int strIdxStart = 0;
  -        int strIdxEnd = strDirs.size() - 1;
  -
  -        // up to first '**'
  -        while( patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd )
  -        {
  -            String patDir = (String)patDirs.get( patIdxStart );
  -            if( patDir.equals( "**" ) )
  -            {
  -                break;
  -            }
  -            if( !match( patDir, (String)strDirs.get( strIdxStart ), isCaseSensitive ) )
  -            {
  -                return false;
  -            }
  -            patIdxStart++;
  -            strIdxStart++;
  -        }
  -
  -        if( strIdxStart > strIdxEnd )
  -        {
  -            // String is exhausted
  -            return true;
  -        }
  -        else if( patIdxStart > patIdxEnd )
  -        {
  -            // String not exhausted, but pattern is. Failure.
  -            return false;
  -        }
  -        else
  -        {
  -            // pattern now holds ** while string is not exhausted
  -            // this will generate false positives but we can live with that.
  -            return true;
  -        }
  -    }
  -
  -    /**
        * Sets the basedir for scanning. This is the directory that is scanned
        * recursively. All '/' and '\' characters are replaced by <code>File.separatorChar</code>
        * . So the separator used need not match <code>File.separatorChar</code>.
  @@ -900,14 +395,14 @@
       {
           int excludesLength = m_excludes == null ? 0 : m_excludes.length;
           String[] newExcludes;
  -        newExcludes = new String[ excludesLength + DEFAULTEXCLUDES.length ];
  +        newExcludes = new String[ excludesLength + ScannerUtil.DEFAULTEXCLUDES.length ];
           if( excludesLength > 0 )
           {
               System.arraycopy( m_excludes, 0, newExcludes, 0, excludesLength );
           }
  -        for( int i = 0; i < DEFAULTEXCLUDES.length; i++ )
  +        for( int i = 0; i < ScannerUtil.DEFAULTEXCLUDES.length; i++ )
           {
  -            newExcludes[ i + excludesLength ] = DEFAULTEXCLUDES[ i ].replace( '/', File.separatorChar
).replace( '\\', File.separatorChar );
  +            newExcludes[ i + excludesLength ] = ScannerUtil.DEFAULTEXCLUDES[ i ].replace(
'/', File.separatorChar ).replace( '\\', File.separatorChar );
           }
           m_excludes = newExcludes;
       }
  @@ -982,7 +477,7 @@
       {
           for( int i = 0; i < m_excludes.length; i++ )
           {
  -            if( matchPath( m_excludes[ i ], name, m_isCaseSensitive ) )
  +            if( ScannerUtil.matchPath( m_excludes[ i ], name, m_isCaseSensitive ) )
               {
                   return true;
               }
  @@ -1001,7 +496,7 @@
       {
           for( int i = 0; i < m_includes.length; i++ )
           {
  -            if( matchPath( m_includes[ i ], name, m_isCaseSensitive ) )
  +            if( ScannerUtil.matchPath( m_includes[ i ], name, m_isCaseSensitive ) )
               {
                   return true;
               }
  @@ -1020,7 +515,7 @@
       {
           for( int i = 0; i < m_includes.length; i++ )
           {
  -            if( matchPatternStart( m_includes[ i ], name, m_isCaseSensitive ) )
  +            if( ScannerUtil.matchPatternStart( m_includes[ i ], name, m_isCaseSensitive
) )
               {
                   return true;
               }
  @@ -1164,11 +659,6 @@
           }
   
           m_haveSlowResults = true;
  -    }
  -
  -    public static String[] getDEFAULTEXCLUDES()
  -    {
  -        return DEFAULTEXCLUDES;
       }
   
       public ArrayList getDirsExcluded()
  
  
  
  1.14      +7 -12     jakarta-ant/proposal/myrmidon/src/main/org/apache/tools/ant/types/PatternSet.java
  
  Index: PatternSet.java
  ===================================================================
  RCS file: /home/cvs/jakarta-ant/proposal/myrmidon/src/main/org/apache/tools/ant/types/PatternSet.java,v
  retrieving revision 1.13
  retrieving revision 1.14
  diff -u -r1.13 -r1.14
  --- PatternSet.java	23 Jan 2002 10:21:15 -0000	1.13
  +++ PatternSet.java	24 Jan 2002 11:38:06 -0000	1.14
  @@ -13,23 +13,18 @@
   import org.apache.myrmidon.api.TaskContext;
   import org.apache.myrmidon.api.TaskException;
   import org.apache.myrmidon.framework.Pattern;
  -import org.apache.tools.ant.ProjectComponent;
   
   /**
    * Named collection of include/exclude tags. <p>
    *
  - * Moved out of MatchingTask to make it a standalone object that could be
  - * referenced (by scripts for example).
  - *
  - * @author Arnout J. Kuiper <a href="mailto:ajkuiper@wxs.nl">ajkuiper@wxs.nl</a>
  - * @author Stefano Mazzocchi <a href="mailto:stefano@apache.org">
  - *      stefano@apache.org</a>
  - * @author Sam Ruby <a href="mailto:rubys@us.ibm.com">rubys@us.ibm.com</a>
  - * @author Jon S. Stevens <a href="mailto:jon@clearink.com">jon@clearink.com</a>
  + * @author <a href="mailto:ajkuiper@wxs.nl">Arnout J. Kuiper</a>
  + * @author <a href="mailto:stefano@apache.org">Stefano Mazzocchi</a>
  + * @author <a href="mailto:rubys@us.ibm.com">Sam Ruby</a>
  + * @author <a href="mailto:jon@clearink.com">Jon S. Stevens</a>
    * @author <a href="mailto:stefan.bodewig@epost.de">Stefan Bodewig</a>
  + * @author <a href="mailto:peter@apache.org">Peter Donald</a>
    */
   public class PatternSet
  -    extends ProjectComponent
   {
       private ArrayList m_includeList = new ArrayList();
       private ArrayList m_excludeList = new ArrayList();
  @@ -106,8 +101,8 @@
   
       public String toString()
       {
  -        return "patternSet{ includes: " + m_includeList +
  -            " excludes: " + m_excludeList + " }";
  +        return "PatternSet [ includes: " + m_includeList +
  +            " excludes: " + m_excludeList + " ]";
       }
   
       private Pattern[] parsePatterns( final String patternString )
  
  
  
  1.1                  jakarta-ant/proposal/myrmidon/src/main/org/apache/tools/ant/types/ScannerUtil.java
  
  Index: ScannerUtil.java
  ===================================================================
  /*
   * Copyright (C) The Apache Software Foundation. All rights reserved.
   *
   * This software is published under the terms of the Apache Software License
   * version 1.1, a copy of which has been included  with this distribution in
   * the LICENSE.txt file.
   */
  package org.apache.tools.ant.types;
  
  import java.io.File;
  import java.util.ArrayList;
  import java.util.StringTokenizer;
  
  /**
   *
   *
   * @author <a href="mailto:peter@apache.org">Peter Donald</a>
   * @version $Revision: 1.1 $ $Date: 2002/01/24 11:38:06 $
   */
  public class ScannerUtil
  {
      /**
       * Patterns that should be excluded by default.
       */
      public final static String[] DEFAULTEXCLUDES = new String[]
      {
          "**/*~",
          "**/#*#",
          "**/.#*",
          "**/%*%",
          "**/CVS",
          "**/CVS/**",
          "**/.cvsignore",
          "**/SCCS",
          "**/SCCS/**",
          "**/vssver.scc"
      };
  
      /**
       * Matches a string against a pattern. The pattern contains two special
       * characters: '*' which means zero or more characters, '?' which means one
       * and only one character.
       *
       * @param pattern the (non-null) pattern to match against
       * @param str the (non-null) string that must be matched against the pattern
       * @return <code>true</code> when the string matches against the pattern,
       *      <code>false</code> otherwise.
       */
      public static boolean match( final String pattern, final String str )
      {
          return match( pattern, str, true );
      }
  
      /**
       * Matches a string against a pattern. The pattern contains two special
       * characters: '*' which means zero or more characters, '?' which means one
       * and only one character.
       *
       * @param pattern the (non-null) pattern to match against
       * @param str the (non-null) string that must be matched against the pattern
       * @param isCaseSensitive Description of Parameter
       * @return <code>true</code> when the string matches against the pattern,
       *      <code>false</code> otherwise.
       */
      protected static boolean match( final String pattern,
                                      final String str,
                                      final boolean isCaseSensitive )
      {
          char[] patArr = pattern.toCharArray();
          char[] strArr = str.toCharArray();
          int patIdxStart = 0;
          int patIdxEnd = patArr.length - 1;
          int strIdxStart = 0;
          int strIdxEnd = strArr.length - 1;
          char ch;
  
          boolean containsStar = false;
          for( int i = 0; i < patArr.length; i++ )
          {
              if( patArr[ i ] == '*' )
              {
                  containsStar = true;
                  break;
              }
          }
  
          if( !containsStar )
          {
              // No '*'s, so we make a shortcut
              if( patIdxEnd != strIdxEnd )
              {
                  return false;// Pattern and string do not have the same size
              }
              for( int i = 0; i <= patIdxEnd; i++ )
              {
                  ch = patArr[ i ];
                  if( ch != '?' )
                  {
                      if( isCaseSensitive && ch != strArr[ i ] )
                      {
                          return false;// Character mismatch
                      }
                      if( !isCaseSensitive && Character.toUpperCase( ch ) !=
                          Character.toUpperCase( strArr[ i ] ) )
                      {
                          return false;// Character mismatch
                      }
                  }
              }
              return true;// String matches against pattern
          }
  
          if( patIdxEnd == 0 )
          {
              return true;// Pattern contains only '*', which matches anything
          }
  
          // Process characters before first star
          while( ( ch = patArr[ patIdxStart ] ) != '*' && strIdxStart <= strIdxEnd
)
          {
              if( ch != '?' )
              {
                  if( isCaseSensitive && ch != strArr[ strIdxStart ] )
                  {
                      return false;// Character mismatch
                  }
                  if( !isCaseSensitive && Character.toUpperCase( ch ) !=
                      Character.toUpperCase( strArr[ strIdxStart ] ) )
                  {
                      return false;// Character mismatch
                  }
              }
              patIdxStart++;
              strIdxStart++;
          }
          if( strIdxStart > strIdxEnd )
          {
              // All characters in the string are used. Check if only '*'s are
              // left in the pattern. If so, we succeeded. Otherwise failure.
              for( int i = patIdxStart; i <= patIdxEnd; i++ )
              {
                  if( patArr[ i ] != '*' )
                  {
                      return false;
                  }
              }
              return true;
          }
  
          // Process characters after last star
          while( ( ch = patArr[ patIdxEnd ] ) != '*' && strIdxStart <= strIdxEnd
)
          {
              if( ch != '?' )
              {
                  if( isCaseSensitive && ch != strArr[ strIdxEnd ] )
                  {
                      return false;// Character mismatch
                  }
                  if( !isCaseSensitive && Character.toUpperCase( ch ) !=
                      Character.toUpperCase( strArr[ strIdxEnd ] ) )
                  {
                      return false;// Character mismatch
                  }
              }
              patIdxEnd--;
              strIdxEnd--;
          }
          if( strIdxStart > strIdxEnd )
          {
              // All characters in the string are used. Check if only '*'s are
              // left in the pattern. If so, we succeeded. Otherwise failure.
              for( int i = patIdxStart; i <= patIdxEnd; i++ )
              {
                  if( patArr[ i ] != '*' )
                  {
                      return false;
                  }
              }
              return true;
          }
  
          // process pattern between stars. padIdxStart and patIdxEnd point
          // always to a '*'.
          while( patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd )
          {
              int patIdxTmp = -1;
              for( int i = patIdxStart + 1; i <= patIdxEnd; i++ )
              {
                  if( patArr[ i ] == '*' )
                  {
                      patIdxTmp = i;
                      break;
                  }
              }
              if( patIdxTmp == patIdxStart + 1 )
              {
                  // Two stars next to each other, skip the first one.
                  patIdxStart++;
                  continue;
              }
              // Find the pattern between padIdxStart & padIdxTmp in str between
              // strIdxStart & strIdxEnd
              int patLength = ( patIdxTmp - patIdxStart - 1 );
              int strLength = ( strIdxEnd - strIdxStart + 1 );
              int foundIdx = -1;
              strLoop :
              for( int i = 0; i <= strLength - patLength; i++ )
              {
                  for( int j = 0; j < patLength; j++ )
                  {
                      ch = patArr[ patIdxStart + j + 1 ];
                      if( ch != '?' )
                      {
                          if( isCaseSensitive && ch != strArr[ strIdxStart + i + j
] )
                          {
                              continue strLoop;
                          }
                          if( !isCaseSensitive && Character.toUpperCase( ch ) !=
                              Character.toUpperCase( strArr[ strIdxStart + i + j ] ) )
                          {
                              continue strLoop;
                          }
                      }
                  }
  
                  foundIdx = strIdxStart + i;
                  break;
              }
  
              if( foundIdx == -1 )
              {
                  return false;
              }
  
              patIdxStart = patIdxTmp;
              strIdxStart = foundIdx + patLength;
          }
  
          // All characters in the string are used. Check if only '*'s are left
          // in the pattern. If so, we succeeded. Otherwise failure.
          for( int i = patIdxStart; i <= patIdxEnd; i++ )
          {
              if( patArr[ i ] != '*' )
              {
                  return false;
              }
          }
          return true;
      }
  
      /**
       * Matches a path against a pattern.
       *
       * @param pattern the (non-null) pattern to match against
       * @param str the (non-null) string (path) to match
       * @return <code>true</code> when the pattern matches against the string.
       *      <code>false</code> otherwise.
       */
      protected static boolean matchPath( final String pattern, final String str )
      {
          return matchPath( pattern, str, true );
      }
  
      /**
       * Matches a path against a pattern.
       *
       * @param pattern the (non-null) pattern to match against
       * @param str the (non-null) string (path) to match
       * @param isCaseSensitive must a case sensitive match be done?
       * @return <code>true</code> when the pattern matches against the string.
       *      <code>false</code> otherwise.
       */
      protected static boolean matchPath( final String pattern,
                                          final String str,
                                          final boolean isCaseSensitive )
      {
          // When str starts with a File.separator, pattern has to start with a
          // File.separator.
          // When pattern starts with a File.separator, str has to start with a
          // File.separator.
          if( str.startsWith( File.separator ) !=
              pattern.startsWith( File.separator ) )
          {
              return false;
          }
  
          ArrayList patDirs = new ArrayList();
          StringTokenizer st = new StringTokenizer( pattern, File.separator );
          while( st.hasMoreTokens() )
          {
              patDirs.add( st.nextToken() );
          }
  
          ArrayList strDirs = new ArrayList();
          st = new StringTokenizer( str, File.separator );
          while( st.hasMoreTokens() )
          {
              strDirs.add( st.nextToken() );
          }
  
          int patIdxStart = 0;
          int patIdxEnd = patDirs.size() - 1;
          int strIdxStart = 0;
          int strIdxEnd = strDirs.size() - 1;
  
          // up to first '**'
          while( patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd )
          {
              String patDir = (String)patDirs.get( patIdxStart );
              if( patDir.equals( "**" ) )
              {
                  break;
              }
              if( !match( patDir, (String)strDirs.get( strIdxStart ), isCaseSensitive ) )
              {
                  return false;
              }
              patIdxStart++;
              strIdxStart++;
          }
          if( strIdxStart > strIdxEnd )
          {
              // String is exhausted
              for( int i = patIdxStart; i <= patIdxEnd; i++ )
              {
                  if( !patDirs.get( i ).equals( "**" ) )
                  {
                      return false;
                  }
              }
              return true;
          }
          else
          {
              if( patIdxStart > patIdxEnd )
              {
                  // String not exhausted, but pattern is. Failure.
                  return false;
              }
          }
  
          // up to last '**'
          while( patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd )
          {
              String patDir = (String)patDirs.get( patIdxEnd );
              if( patDir.equals( "**" ) )
              {
                  break;
              }
              if( !match( patDir, (String)strDirs.get( strIdxEnd ), isCaseSensitive ) )
              {
                  return false;
              }
              patIdxEnd--;
              strIdxEnd--;
          }
          if( strIdxStart > strIdxEnd )
          {
              // String is exhausted
              for( int i = patIdxStart; i <= patIdxEnd; i++ )
              {
                  if( !patDirs.get( i ).equals( "**" ) )
                  {
                      return false;
                  }
              }
              return true;
          }
  
          while( patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd )
          {
              int patIdxTmp = -1;
              for( int i = patIdxStart + 1; i <= patIdxEnd; i++ )
              {
                  if( patDirs.get( i ).equals( "**" ) )
                  {
                      patIdxTmp = i;
                      break;
                  }
              }
              if( patIdxTmp == patIdxStart + 1 )
              {
                  // '**/**' situation, so skip one
                  patIdxStart++;
                  continue;
              }
              // Find the pattern between padIdxStart & padIdxTmp in str between
              // strIdxStart & strIdxEnd
              int patLength = ( patIdxTmp - patIdxStart - 1 );
              int strLength = ( strIdxEnd - strIdxStart + 1 );
              int foundIdx = -1;
              strLoop :
              for( int i = 0; i <= strLength - patLength; i++ )
              {
                  for( int j = 0; j < patLength; j++ )
                  {
                      String subPat = (String)patDirs.get( patIdxStart + j + 1 );
                      String subStr = (String)strDirs.get( strIdxStart + i + j );
                      if( !match( subPat, subStr, isCaseSensitive ) )
                      {
                          continue strLoop;
                      }
                  }
  
                  foundIdx = strIdxStart + i;
                  break;
              }
  
              if( foundIdx == -1 )
              {
                  return false;
              }
  
              patIdxStart = patIdxTmp;
              strIdxStart = foundIdx + patLength;
          }
  
          for( int i = patIdxStart; i <= patIdxEnd; i++ )
          {
              if( !patDirs.get( i ).equals( "**" ) )
              {
                  return false;
              }
          }
  
          return true;
      }
  
      /**
       * Does the path match the start of this pattern up to the first "**". <p>
       *
       * This is not a general purpose test and should only be used if you can
       * live with false positives.</p> <p>
       *
       * <code>pattern=**\\a</code> and <code>str=b</code> will yield
true.
       *
       * @param pattern the (non-null) pattern to match against
       * @param str the (non-null) string (path) to match
       * @return Description of the Returned Value
       */
      protected static boolean matchPatternStart( final String pattern, final String str )
      {
          return matchPatternStart( pattern, str, true );
      }
  
      /**
       * Does the path match the start of this pattern up to the first "**". <p>
       *
       * This is not a general purpose test and should only be used if you can
       * live with false positives.</p> <p>
       *
       * <code>pattern=**\\a</code> and <code>str=b</code> will yield
true.
       *
       * @param pattern the (non-null) pattern to match against
       * @param str the (non-null) string (path) to match
       * @param isCaseSensitive must matches be case sensitive?
       * @return Description of the Returned Value
       */
      protected static boolean matchPatternStart( final String pattern,
                                                  final String str,
                                                  final boolean isCaseSensitive )
      {
          // When str starts with a File.separator, pattern has to start with a
          // File.separator.
          // When pattern starts with a File.separator, str has to start with a
          // File.separator.
          if( str.startsWith( File.separator ) !=
              pattern.startsWith( File.separator ) )
          {
              return false;
          }
  
          ArrayList patDirs = new ArrayList();
          StringTokenizer st = new StringTokenizer( pattern, File.separator );
          while( st.hasMoreTokens() )
          {
              patDirs.add( st.nextToken() );
          }
  
          ArrayList strDirs = new ArrayList();
          st = new StringTokenizer( str, File.separator );
          while( st.hasMoreTokens() )
          {
              strDirs.add( st.nextToken() );
          }
  
          int patIdxStart = 0;
          int patIdxEnd = patDirs.size() - 1;
          int strIdxStart = 0;
          int strIdxEnd = strDirs.size() - 1;
  
          // up to first '**'
          while( patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd )
          {
              String patDir = (String)patDirs.get( patIdxStart );
              if( patDir.equals( "**" ) )
              {
                  break;
              }
              if( !match( patDir, (String)strDirs.get( strIdxStart ), isCaseSensitive ) )
              {
                  return false;
              }
              patIdxStart++;
              strIdxStart++;
          }
  
          if( strIdxStart > strIdxEnd )
          {
              // String is exhausted
              return true;
          }
          else if( patIdxStart > patIdxEnd )
          {
              // String not exhausted, but pattern is. Failure.
              return false;
          }
          else
          {
              // pattern now holds ** while string is not exhausted
              // this will generate false positives but we can live with that.
              return true;
          }
      }
  }
  
  
  

--
To unsubscribe, e-mail:   <mailto:ant-dev-unsubscribe@jakarta.apache.org>
For additional commands, e-mail: <mailto:ant-dev-help@jakarta.apache.org>


Mime
View raw message