Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   ***** BEGIN LICENSE BLOCK *****
   * Version: EPL 1.0/GPL 2.0/LGPL 2.1
   *
   * The contents of this file are subject to the Eclipse Public
   * License Version 1.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.eclipse.org/legal/epl-v10.html
   *
  * Software distributed under the License is distributed on an "AS
  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  * implied. See the License for the specific language governing
  * rights and limitations under the License.
  *
  * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se>
  * Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de>
  * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org>
  * Copyright (C) 2004 Joey Gibson <joey@joeygibson.com>
  * Copyright (C) 2004 Charles O Nutter <headius@headius.com>
  * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de>
  *
  * Alternatively, the contents of this file may be used under the terms of
  * either of the GNU General Public License Version 2 or later (the "GPL"),
  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  * in which case the provisions of the GPL or the LGPL are applicable instead
  * of those above. If you wish to allow use of your version of this file only
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the EPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the EPL, the GPL or the LGPL.
  ***** END LICENSE BLOCK *****/
 package org.jruby;
 
 
Implements File::Stat
 
 @JRubyClass(name="File::Stat", include="Comparable")
 public class RubyFileStat extends RubyObject {
     private static final long serialVersionUID = 1L;
 
     private static final int S_IRUGO = (. | . | .);
     private static final int S_IWUGO = (. | . | .);
     private static final int S_IXUGO = (. | . | .);
 
     private JRubyFile file;
     private FileStat stat;
 
     private static ObjectAllocator ALLOCATOR = new ObjectAllocator() {
         public IRubyObject allocate(Ruby runtimeRubyClass klass) {
             return new RubyFileStat(runtimeklass);
         }
     };
 
     public static RubyClass createFileStatClass(Ruby runtime) {
         // TODO: NOT_ALLOCATABLE_ALLOCATOR is probably ok here. Confirm. JRUBY-415
         final RubyClass fileStatClass = runtime.getFile().defineClassUnder("Stat",runtime.getObject(), );
         runtime.setFileStat(fileStatClass);
 
         fileStatClass.includeModule(runtime.getModule("Comparable"));
         fileStatClass.defineAnnotatedMethods(RubyFileStat.class);
 
         return fileStatClass;
     }
 
     protected RubyFileStat(Ruby runtimeRubyClass clazz) {
         super(runtimeclazz);
 
     }
     
     public static RubyFileStat newFileStat(Ruby runtimeString filenameboolean lstat) {
         RubyFileStat stat = new RubyFileStat(runtimeruntime.getFileStat());
 
         stat.setup(filenamelstat);
         
         return stat;
     }
 
     public static RubyFileStat newFileStat(Ruby runtimeFileDescriptor descriptor) {
         RubyFileStat stat = new RubyFileStat(runtimeruntime.getFileStat());
         
        stat.setup(descriptor);
        
        return stat;
    }
    private void setup(FileDescriptor descriptor) {
         = getRuntime().getPosix().fstat(descriptor);
    }
    
    private void setup(String filenameboolean lstat) {
        if (. && filename.length() == 2
                && filename.charAt(1) == ':' && Character.isLetter(filename.charAt(0))) {
            filename += "/";
        }
        if (filename.startsWith("file:") ) {
            if (filename.indexOf('!') != -1) {
                // file: URL handling
                String zipFileEntry = filename.substring(filename.indexOf("!") + 1);
                if (zipFileEntry.length() > 0) {
                    if (zipFileEntry.charAt(0) == '/') {
                        if (zipFileEntry.length() > 1) {
                            zipFileEntry = zipFileEntry.substring(1);
                        } else {
                            throw getRuntime().newErrnoENOENTError("invalid jar/file URL: " + filename);
                        }
                    }
                } else {
                    throw getRuntime().newErrnoENOENTError("invalid jar/file URL: " + filename);
                }
                String zipfilename = filename.substring(5, filename.indexOf("!"));
                try {
                    ZipFile zipFile = new ZipFile(zipfilename);
                    ZipEntry zipEntry = RubyFile.getFileEntry(zipFilezipFileEntry);
                    if (zipEntry == null) {
                        throw getRuntime().newErrnoENOENTError("invalid jar/file URL: " + filename);
                    }
                     = new ZipFileStat(zipEntry);
                    return;
                } catch (IOException ioe) {
                    // fall through and use the zip file as the file to stat
                }
                filename = zipfilename;
            } else {
                throw getRuntime().newErrnoENOENTError("invalid jar/file URL: " + filename);
            }
        }
         = JRubyFile.create(getRuntime().getCurrentDirectory(), filename);
        if ( instanceof JRubyNonExistentFile) {
            throw getRuntime().newErrnoENOENTError("No such file or directory - " + filename);
        }
        if (lstat) {
             = getRuntime().getPosix().lstat(.getAbsolutePath());
        } else {
             = getRuntime().getPosix().stat(.getAbsolutePath());
        }
    }
    public static class ZipFileStat implements FileStat {
        private final ZipEntry zipEntry;
        public ZipFileStat(ZipEntry zipEntry) {
            this. = zipEntry;
        }
        
        public long atime() {
            return .getTime();
        }
        public long blocks() {
            return .getSize();
        }
        public long blockSize() {
            return 1L;
        }
        public long ctime() {
            return .getTime();
        }
        public long dev() {
            return -1;
        }
        public String ftype() {
            return "zip file entry";
        }
        public int gid() {
            return -1;
        }
        public boolean groupMember(int i) {
            return false;
        }
        public long ino() {
            return -1;
        }
        public boolean isBlockDev() {
            return false;
        }
        public boolean isCharDev() {
            return false;
        }
        public boolean isDirectory() {
            return .isDirectory();
        }
        public boolean isEmpty() {
            return .getSize() == 0;
        }
        public boolean isExecutable() {
            return false;
        }
        public boolean isExecutableReal() {
            return false;
        }
        public boolean isFifo() {
            return false;
        }
        public boolean isFile() {
            return !.isDirectory();
        }
        public boolean isGroupOwned() {
            return false;
        }
        public boolean isIdentical(FileStat fs) {
            return fs instanceof ZipFileStat && ((ZipFileStat)fs)..equals();
        }
        public boolean isNamedPipe() {
            return false;
        }
        public boolean isOwned() {
            return false;
        }
        public boolean isROwned() {
            return false;
        }
        public boolean isReadable() {
            return true;
        }
        public boolean isReadableReal() {
            return true;
        }
        public boolean isWritable() {
            return false;
        }
        public boolean isWritableReal() {
            return false;
        }
        public boolean isSetgid() {
            return false;
        }
        public boolean isSetuid() {
            return false;
        }
        public boolean isSocket() {
            return false;
        }
        public boolean isSticky() {
            return false;
        }
        public boolean isSymlink() {
            return false;
        }
        public int major(long l) {
            return -1;
        }
        public int minor(long l) {
            return -1;
        }
        public int mode() {
            return -1;
        }
        public long mtime() {
            return .getTime();
        }
        public int nlink() {
            return -1;
        }
        public long rdev() {
            return -1;
        }
        public long st_size() {
            return .getSize();
        }
        public int uid() {
            return 0;
        }
    }
    @JRubyMethod(name = "initialize", required = 1, visibility = ., compat = .)
    public IRubyObject initialize(IRubyObject fnameBlock unusedBlock) {
        setup(fname.convertToString().toString(), false);
        return this;
    }
    @JRubyMethod(name = "initialize", required = 1, visibility = ., compat = .)
    public IRubyObject initialize19(IRubyObject fnameBlock unusedBlock) {
        return initialize(RubyFile.get_path(getRuntime().getCurrentContext(), fname), unusedBlock);
    }
    
    @JRubyMethod(name = "atime")
    public IRubyObject atime() {
        return getRuntime().newTime(.atime() * 1000);
    }
    
    @JRubyMethod(name = "blksize")
    public RubyFixnum blksize() {
        return getRuntime().newFixnum(.blockSize());
    }
    @JRubyMethod(name = "blockdev?")
    public IRubyObject blockdev_p() {
        return getRuntime().newBoolean(.isBlockDev());
    }
    @JRubyMethod(name = "blocks")
    public IRubyObject blocks() {
        return getRuntime().newFixnum(.blocks());
    }
    @JRubyMethod(name = "chardev?")
    public IRubyObject chardev_p() {
        return getRuntime().newBoolean(.isCharDev());
    }
    @JRubyMethod(name = "<=>", required = 1)
    public IRubyObject cmp(IRubyObject other) {
        if (!(other instanceof RubyFileStat)) return getRuntime().getNil();
        
        long time1 = .mtime();
        long time2 = ((RubyFileStatother)..mtime();
        
        if (time1 == time2) {
            return getRuntime().newFixnum(0);
        } else if (time1 < time2) {
            return getRuntime().newFixnum(-1);
        } 
        return getRuntime().newFixnum(1);
    }
    @JRubyMethod(name = "ctime")
    public IRubyObject ctime() {
        return getRuntime().newTime(.ctime() * 1000);
    }
    @JRubyMethod(name = "dev")
    public IRubyObject dev() {
        return getRuntime().newFixnum(.dev());
    }
    
    @JRubyMethod(name = "dev_major")
    public IRubyObject devMajor() {
        return getRuntime().newFixnum(.major(.dev()));
    }
    @JRubyMethod(name = "dev_minor")
    public IRubyObject devMinor() {
        return getRuntime().newFixnum(.minor(.dev()));
    }
    @JRubyMethod(name = "directory?")
    public RubyBoolean directory_p() {
        return getRuntime().newBoolean(.isDirectory());
    }
    @JRubyMethod(name = "executable?")
    public IRubyObject executable_p() {
        return getRuntime().newBoolean(.isExecutable());
    }
    @JRubyMethod(name = "executable_real?")
    public IRubyObject executableReal_p() {
        return getRuntime().newBoolean(.isExecutableReal());
    }
    @JRubyMethod(name = "file?")
    public RubyBoolean file_p() {
        return getRuntime().newBoolean(.isFile());
    }
    @JRubyMethod(name = "ftype")
    public RubyString ftype() {
        return getRuntime().newString(.ftype());
    }
    @JRubyMethod(name = "gid")
    public IRubyObject gid() {
        return getRuntime().newFixnum(.gid());
    }
    
    @JRubyMethod(name = "grpowned?")
    public IRubyObject group_owned_p() {
        return getRuntime().newBoolean(.isGroupOwned());
    }
    
    @JRubyMethod(name = "initialize_copy", required = 1)
    public IRubyObject initialize_copy(IRubyObject original) {
        if (!(original instanceof RubyFileStat)) {
            throw getRuntime().newTypeError("wrong argument class");
        }
        
        RubyFileStat originalFileStat = (RubyFileStatoriginal;
        
         = originalFileStat.file;
         = originalFileStat.stat;
        
        return this;
    }
    
    @JRubyMethod(name = "ino")
    public IRubyObject ino() {
        return getRuntime().newFixnum(.ino());
    }
    @JRubyMethod(name = "inspect")
    public IRubyObject inspect() {
        StringBuilder buf = new StringBuilder("#<");
        buf.append(getMetaClass().getRealClass().getName());
        buf.append(" ");
        // FIXME: Obvious issue that not all platforms can display all attributes.  Ugly hacks.
        // Using generic posix library makes pushing inspect behavior into specific system impls
        // rather painful.
        try { buf.append("dev=0x").append(Long.toHexString(.dev())); } catch (Exception e) {} finally { buf.append(", "); }
        try { buf.append("ino=").append(.ino()); } catch (Exception e) {} finally { buf.append(", "); }
        buf.append("mode=0").append(Integer.toOctalString(.mode())).append(", "); 
        try { buf.append("nlink=").append(.nlink()); } catch (Exception e) {} finally { buf.append(", "); }
        try { buf.append("uid=").append(.uid()); } catch (Exception e) {} finally { buf.append(", "); }
        try { buf.append("gid=").append(.gid()); } catch (Exception e) {} finally { buf.append(", "); }
        try { buf.append("rdev=0x").append(Long.toHexString(.rdev())); } catch (Exception e) {} finally { buf.append(", "); }
        buf.append("size=").append(sizeInternal()).append(", ");
        try { buf.append("blksize=").append(.blockSize()); } catch (Exception e) {} finally { buf.append(", "); }
        try { buf.append("blocks=").append(.blocks()); } catch (Exception e) {} finally { buf.append(", "); }
        
        buf.append("atime=").append(atime()).append(", ");
        buf.append("mtime=").append(mtime()).append(", ");
        buf.append("ctime=").append(ctime());
        buf.append(">");
        
        return getRuntime().newString(buf.toString());
    }
    @JRubyMethod(name = "uid")
    public IRubyObject uid() {
        return getRuntime().newFixnum(.uid());
    }
    
    @JRubyMethod(name = "mode")
    public IRubyObject mode() {
        return getRuntime().newFixnum(.mode());
    }
    @JRubyMethod(name = "mtime")
    public IRubyObject mtime() {
        return getRuntime().newTime(.mtime() * 1000);
    }
    
    public IRubyObject mtimeEquals(IRubyObject other) {
        return getRuntime().newBoolean(.mtime() == newFileStat(getRuntime(), other.convertToString().toString(), false)..mtime()); 
    }
    public IRubyObject mtimeGreaterThan(IRubyObject other) {
        return getRuntime().newBoolean(.mtime() > newFileStat(getRuntime(), other.convertToString().toString(), false)..mtime()); 
    }
    public IRubyObject mtimeLessThan(IRubyObject other) {
        return getRuntime().newBoolean(.mtime() < newFileStat(getRuntime(), other.convertToString().toString(), false)..mtime()); 
    }
    @JRubyMethod(name = "nlink")
    public IRubyObject nlink() {
        return getRuntime().newFixnum(.nlink());
    }
    @JRubyMethod(name = "owned?")
    public IRubyObject owned_p() {
        return getRuntime().newBoolean(.isOwned());
    }
    @JRubyMethod(name = "pipe?")
    public IRubyObject pipe_p() {
        return getRuntime().newBoolean(.isNamedPipe());
    }
    @JRubyMethod(name = "rdev")
    public IRubyObject rdev() {
        return getRuntime().newFixnum(.rdev());
    }
    
    @JRubyMethod(name = "rdev_major")
    public IRubyObject rdevMajor() {
        return getRuntime().newFixnum(.major(.rdev()));
    }
    @JRubyMethod(name = "rdev_minor")
    public IRubyObject rdevMinor() {
        return getRuntime().newFixnum(.minor(.rdev()));
    }
    @JRubyMethod(name = "readable?")
    public IRubyObject readable_p() {
        return getRuntime().newBoolean(.isReadable());
    }
    @JRubyMethod(name = "readable_real?")
    public IRubyObject readableReal_p() {
        return getRuntime().newBoolean(.isReadableReal());
    }
    @JRubyMethod(name = "setgid?")
    public IRubyObject setgid_p() {
        return getRuntime().newBoolean(.isSetgid());
    }
    @JRubyMethod(name = "setuid?")
    public IRubyObject setuid_p() {
        return getRuntime().newBoolean(.isSetuid());
    }
    private long sizeInternal() {
        // Workaround for JRUBY-4149
        if (. &&  != null) {
            try {
                return .length();
            } catch (SecurityException ex) {
                return 0L;
            }
        } else {
            return .st_size();
        }
    }
    @JRubyMethod(name = "size")
    public IRubyObject size() {
        return getRuntime().newFixnum(sizeInternal());
    }
    
    @JRubyMethod(name = "size?")
    public IRubyObject size_p() {
        long size = sizeInternal();
        
        if (size == 0) return getRuntime().getNil();
        
        return getRuntime().newFixnum(size);
    }
    @JRubyMethod(name = "socket?")
    public IRubyObject socket_p() {
        return getRuntime().newBoolean(.isSocket());
    }
    
    @JRubyMethod(name = "sticky?")
    public IRubyObject sticky_p() {
        Ruby runtime = getRuntime();
        
        if (runtime.getPosix().isNative()) {
            return runtime.newBoolean(.isSticky());
        }
        
        return runtime.getNil();
    }
    @JRubyMethod(name = "symlink?")
    public IRubyObject symlink_p() {
        return getRuntime().newBoolean(.isSymlink());
    }
    @JRubyMethod(name = "writable?")
    public IRubyObject writable_p() {
    	return getRuntime().newBoolean(.isWritable());
    }
    
    @JRubyMethod(name = "writable_real?")
    public IRubyObject writableReal_p() {
        return getRuntime().newBoolean(.isWritableReal());
    }
    
    @JRubyMethod(name = "zero?")
    public IRubyObject zero_p() {
        return getRuntime().newBoolean(.isEmpty());
    }
    @JRubyMethod(name = "world_readable?", compat = .)
    public IRubyObject worldReadable(ThreadContext context) {
        return getWorldMode(context.);
    }
    @JRubyMethod(name = "world_writable?", compat = .)
    public IRubyObject worldWritable(ThreadContext context) {
        return getWorldMode(context.);
    }
    private IRubyObject getWorldMode(ThreadContext contextint mode) {
        if ((.mode() & mode) == mode) {
            return RubyNumeric.int2fix(context.runtime,
                    (.mode() & ( |  | ) ));
        }
        return context.runtime.getNil();
    }