104.java

/**
 * Copyright 2007 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.tonicsystems.jarjar.util;

import java.util.*;
import java.util.zip.*;
import java.io.*;
import java.util.jar.*;

public class ClassPathIterator implements Iterator<ClassPathEntry>
{
    private static final FileFilter CLASS_FILTER = new FileFilter() {
        public boolean accept(File file) {
            return file.isDirectory() || isClass(file.getName());
        }
    };

    private static final FileFilter JAR_FILTER = new FileFilter() {
        public boolean accept(File file) {
            return hasExtension(file.getName(), ".jar");
        }
    };
    
    private final Iterator<File> files;
    private Iterator<ClassPathEntry> entries = Collections.<ClassPathEntry>emptyList().iterator();
    private ClassPathEntry next;
    private List<ZipFile> zips = new ArrayList<ZipFile>();

    public ClassPathIterator(String classPath) throws IOException {
        this(new File(System.getProperty("user.dir")), classPath, null);
    }
    
    public ClassPathIterator(File parent, String classPath, String delim) throws IOException {
        if (delim == null) {
            delim = System.getProperty("path.separator");
        }
        StringTokenizer st = new StringTokenizer(classPath, delim);
        List<File> fileList = new ArrayList<File>();
        while (st.hasMoreTokens()) {
            String part = (String)st.nextElement();
            boolean wildcard = false;
            if (part.endsWith("/*")) {
                part = part.substring(0, part.length() - 1);
                if (part.indexOf('*') >= 0)
                    throw new IllegalArgumentException("Multiple wildcards are not allowed: " + part);
                wildcard = true;
            } else if (part.indexOf('*') >= 0) {
                throw new IllegalArgumentException("Incorrect wildcard usage: " + part);
            }
                
            File file = new File(part);
            if (!file.isAbsolute())
                file = new File(parent, part);
            if (!file.exists())
                throw new IllegalArgumentException("File " + file + " does not exist");

            if (wildcard) {
                if (!file.isDirectory())
                    throw new IllegalArgumentException("File " + file + " + is not a directory");
                fileList.addAll(findFiles(file, JAR_FILTER, false, new ArrayList<File>()));
            } else {
                fileList.add(file);
            }
        }
        this.files = fileList.iterator();
        advance();
    }

    public boolean hasNext() {
        return next != null;
    }

    /** Closes all zip files opened by this iterator. */
    public void close() throws IOException {
      next = null;
      for (ZipFile zip : zips) {
        zip.close();
      }
    }

    public void remove() {
        throw new UnsupportedOperationException();
    }

    public ClassPathEntry next() {
        if (!hasNext())
            throw new NoSuchElementException();
        ClassPathEntry result = next;
        try {
            advance();
        } catch (IOException e) {
            throw new RuntimeIOException(e);
        }
        return result;
    }

    private void advance() throws IOException {
        if (!entries.hasNext()) {
            if (!files.hasNext()) {
                next = null;
                return;
            }
            File file = files.next();
            if (hasExtension(file.getName(), ".jar")) {
                ZipFile zip = new JarFile(file);
                zips.add(zip);
                entries = new ZipIterator(zip);
            } else if (hasExtension(file.getName(), ".zip")) {
                ZipFile zip = new ZipFile(file);
                zips.add(zip);
                entries = new ZipIterator(zip);
            } else if (file.isDirectory()) {
                entries = new FileIterator(file);
            } else {
                throw new IllegalArgumentException("Do not know how to handle " + file);
            }
        }

        boolean foundClass = false;
        while (!foundClass && entries.hasNext()) {
          next = entries.next();
          foundClass = isClass(next.getName());
        }
        if (!foundClass) {
          advance();
        }
    }

    private static class ZipIterator implements Iterator<ClassPathEntry> {
      private final ZipFile zip;
      private final Enumeration<? extends ZipEntry> entries;

      ZipIterator(ZipFile zip) {
        this.zip = zip;
        this.entries = zip.entries();
      }

      public boolean hasNext() {
        return entries.hasMoreElements();
      }

      public void remove() {
        throw new UnsupportedOperationException();
      }

      public ClassPathEntry next() {
        final ZipEntry entry = entries.nextElement();
        return new ClassPathEntry() {
          public String getSource() {
            return zip.getName();
          }

          public String getName() {
            return entry.getName();
          }

          public InputStream openStream() throws IOException {
            return zip.getInputStream(entry);
          }
        };
      }
    }

    private static class FileIterator implements Iterator<ClassPathEntry> {
      private final File dir;
      private final Iterator<File> entries;

      FileIterator(File dir) {
        this.dir = dir;
        this.entries = findFiles(dir, CLASS_FILTER, true, new ArrayList<File>()).iterator();
      }

      public boolean hasNext() {
        return entries.hasNext();
      }

      public void remove() {
        throw new UnsupportedOperationException();
      }
      
      public ClassPathEntry next() {
        final File file = entries.next();
        return new ClassPathEntry() {
          public String getSource() throws IOException {
            return dir.getCanonicalPath();
          }

          public String getName() {
            return file.getName();
          }

          public InputStream openStream() throws IOException {
            return new BufferedInputStream(new FileInputStream(file));
          }
        };
      }
    }

    private static List<File> findFiles(File dir, FileFilter filter, boolean recurse, List<File> collect) {
        for (File file : dir.listFiles(filter)) {
            if (recurse && file.isDirectory()) {
                findFiles(file, filter, recurse, collect);
            } else {
                collect.add(file);
            }
        }
        return collect;
    }

    private static boolean isClass(String name) {
        return hasExtension(name, ".class");
    }

    private static boolean hasExtension(String name, String ext) {
        if (name.length() <  ext.length())
            return false;
        String actual = name.substring(name.length() - ext.length());
        return actual.equals(ext) || actual.equals(ext.toUpperCase());
    }
}