Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.util;
  
  import jnr.posix.FileStat;
  import jnr.posix.POSIX;
 
 public abstract class JarResource implements FileResource {
     private static Pattern PREFIX_MATCH = Pattern.compile("^(?:jar:)?(?:file:)?(.*)$");
 
     private static final JarCache jarCache = new JarCache();
 
     public static JarResource create(String pathname) {
         Matcher matcher = .matcher(pathname);
         String sanitized = matcher.matches() ? matcher.group(1) : pathname;
 
         int bang = sanitized.indexOf('!');
         if (bang < 0) {
             return null;
         }
 
         String jarPath = sanitized.substring(0, bang);
         String slashPath = sanitized.substring(bang + 1);
         if (!slashPath.startsWith("/")) {
             slashPath = "/" + slashPath;
         }
 
         // TODO: Do we really need to support both test.jar!foo/bar.rb and test.jar!/foo/bar.rb cases?
         JarResource resource = createJarResource(jarPathslashPath);
 
         if (resource == null) {
             resource = createJarResource(jarPathslashPath.substring(1));
         }
         
         return resource;
     }
 
     private static JarResource createJarResource(String jarPathString path) {
         JarCache.JarIndex index = .getIndex(jarPath);
 
         if (index == null) {
             // Jar doesn't exist
             return null;
         }
 
         // Try it as directory first, because jars tend to have foo/ entries
         // and it's not really possible disambiguate between files and directories.
         String[] entries = index.cachedDirEntries.get(path);
         if (entries != null) {
             return new JarDirectoryResource(jarPathpathentries);
         }
 
         JarEntry jarEntry = index.getJarEntry(path);
         if (jarEntry != null) {
             return new JarFileResource(jarPathjarEntry);
         }
 
         return null;
     }
 
     private final String jarPath;
     private final JarFileStat fileStat;
 
     protected JarResource(String jarPath) {
         this. = jarPath;
         this. = new JarFileStat(this);
     }
 
     @Override
     public String absolutePath() {
         return  + "!" + entryName();
     }
 
     @Override
     public boolean exists() {
         // If a jar resource got created, then it always corresponds to some kind of resource
         return true;
     }
 
     @Override
     public boolean canRead() {
         // Can always read from a jar
         return true;
     }
 
     @Override
     public boolean canWrite() {
         return false;
     }
 
     @Override
     public boolean isSymLink() {
         // Jar archives shouldn't contain symbolic links, or it would break portability. `jar`
         // command behavior seems to comform to that (it unwraps syumbolic links when creating a jar
         // and replaces symbolic links with regular file when extracting from a zip that contains
         // symbolic links). Also see:
        // http://www.linuxquestions.org/questions/linux-general-1/how-to-create-jar-files-with-symbolic-links-639381/
        return false;
    }
    @Override
    public FileStat stat(POSIX posix) {
        return ;
    }
    @Override
    public FileStat lstat(POSIX posix) {
      // jars don't have symbolic links, so lstat is no different than regular stat
      return stat(posix);
    }
    @Override
    public JRubyFile hackyGetJRubyFile() {
      return .;
    }
    abstract protected String entryName();
New to GrepCode? Check out our FAQ X