1  /*
     2   * Copyright (c) 2003-2006, Simon Brown
     3   * All rights reserved.
     4   *
     5   * Redistribution and use in source and binary forms, with or without
     6   * modification, are permitted provided that the following conditions are met:
     7   *
     8   *   - Redistributions of source code must retain the above copyright
     9   *     notice, this list of conditions and the following disclaimer.
    10   *
    11   *   - Redistributions in binary form must reproduce the above copyright
    12   *     notice, this list of conditions and the following disclaimer in
    13   *     the documentation and/or other materials provided with the
    14   *     distribution.
    15   *
    16   *   - Neither the name of Pebble nor the names of its contributors may
    17   *     be used to endorse or promote products derived from this software
    18   *     without specific prior written permission.
    19   *
    20   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    21   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    22   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    23   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
    24   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    25   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    26   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    27   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    28   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    29   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    30   * POSSIBILITY OF SUCH DAMAGE.
    31   */
    32  package net.sourceforge.pebble.util;
    33  
    34  import org.apache.commons.logging.Log;
    35  import org.apache.commons.logging.LogFactory;
    36  
    37  import java.io.*;
    38  import java.net.FileNameMap;
    39  import java.net.URLConnection;
    40  import java.nio.channels.FileChannel;
    41  import java.util.Properties;
    42  
    43  /**
    44   * A collection of utility methods for manipulating files.
    45   *
    46   * @author    Simon Brown
    47   */
         /* 
    P/P   *  Method: void net.sourceforge.pebble.util.FileUtils()
          */
    48  public final class FileUtils {
    49  
    50    /** the logger used by this class */
           /* 
    P/P     *  Method: net.sourceforge.pebble.util.FileUtils__static_init
            * 
            *  Presumptions:
            *    java.lang.Class:getClassLoader(...)@59 != null
            *    org.apache.commons.logging.LogFactory:getLog(...)@51 != null
            * 
            *  Postconditions:
            *    localFileNameMap in Addr_Set{null,&new Properties(FileUtils__static_init#1)}
            *    (soft) log != null
            *    new Properties(FileUtils__static_init#1) num objects <= 1
            * 
            *  Test Vectors:
            *    java.lang.ClassLoader:getResourceAsStream(...)@59: Addr_Set{null}, Inverse{null}
            */
    51    private static final Log log = LogFactory.getLog(FileUtils.class);
    52  
    53    /** the local content type map */
    54    private static Properties localFileNameMap;
    55  
    56    static {
    57      try {
    58        localFileNameMap = new Properties();
    59        InputStream in = FileUtils.class.getClassLoader().getResourceAsStream("content-types.properties");
    60        if (in != null) {
    61          localFileNameMap.load(in);
    62          in.close();
    63        }
    64      } catch (IOException ioe) {
    65        log.error("Could not load content types.", ioe);
    66      }
    67    }
    68  
    69    /**
    70     * Determines whether a given file is underneath a given root.
    71     *
    72     * @param root    the root directory
    73     * @param file    the file to test
    74     * @return    true if the file is underneath the root,
    75     *            false otherwise or if this can not be determined because
    76     *            of security constraints in place
    77     */
    78    public static boolean underneathRoot(File root, File file) {
    79      try {
    80        // first of all, find the root directory for this type of file
               /* 
    P/P         *  Method: bool underneathRoot(File, File)
                * 
                *  Preconditions:
                *    (soft) file != null
                *    (soft) root != null
                * 
                *  Postconditions:
                *    init'ed(return_value)
                * 
                *  Test Vectors:
                *    java.io.File:equals(...)@84: {0}, {1}
                */
    81        root = root.getCanonicalFile();
    82        file = file.getCanonicalFile();
    83        while (file != null) {
    84          if (file.equals(root)) {
    85            return true;
    86          } else {
    87            file = file.getParentFile();
    88          }
    89        }
    90      } catch (IOException ioe) {
    91        return false;
    92      }
    93  
    94      return false;
    95    }
    96  
    97    /**
    98     * Deletes a file, including all files and sub-directories if the
    99     * specified file is a directory.
   100     *
   101     * @param directory   a File instance representing the directory to delete
   102     */
   103    public static void deleteFile(File directory) {
             /* 
    P/P       *  Method: void deleteFile(File)
              * 
              *  Preconditions:
              *    directory != null
              * 
              *  Presumptions:
              *    files.length@104 <= 232-1
              *    files[i]@104 != null
              * 
              *  Test Vectors:
              *    java.io.File:isDirectory(...)@107: {0}, {1}
              *    java.io.File:listFiles(...)@104: Addr_Set{null}, Inverse{null}
              */
   104      File files[] = directory.listFiles();
   105      if (files != null) {
   106        for (int i = 0; i < files.length; i++) {
   107          if (files[i].isDirectory()) {
   108            deleteFile(files[i]);
   109          } else {
   110            files[i].delete();
   111          }
   112        }
   113      }
   114  
   115      directory.delete();
   116    }
   117  
   118    /**
   119     * Copies a file.
   120     *
   121     * @param source        the source File
   122     * @param destination   the destination File
   123     */
   124    public static void copyFile(File source, File destination) throws IOException {
             /* 
    P/P       *  Method: void copyFile(File, File)
              * 
              *  Presumptions:
              *    java.io.FileInputStream:getChannel(...)@125 != null
              *    java.io.FileOutputStream:getChannel(...)@126 != null
              */
   125      FileChannel srcChannel = new FileInputStream(source).getChannel();
   126      FileChannel dstChannel = new FileOutputStream(destination).getChannel();
   127      dstChannel.transferFrom(srcChannel, 0, srcChannel.size());
   128      srcChannel.close();
   129      dstChannel.close();
   130    }
   131  
   132    /**
   133     * Gets the content type for the specified filename.
   134     *
   135     * @param name    the name of a file
   136     * @return  a MIME type, or application/octet-stream if one can't be found
   137     */
   138    public static String getContentType(String name) {
   139      String contentType;
             /* 
    P/P       *  Method: String getContentType(String)
              * 
              *  Preconditions:
              *    (soft) localFileNameMap != null
              *    (soft) name != null
              * 
              *  Presumptions:
              *    java.net.URLConnection:getFileNameMap(...)@140 != null
              * 
              *  Postconditions:
              *    init'ed(return_value)
              * 
              *  Test Vectors:
              *    java.lang.String:lastIndexOf(...)@144: {-231..-1}, {0..232-1}
              *    java.net.FileNameMap:getContentTypeFor(...)@141: Inverse{null}, Addr_Set{null}
              */
   140      FileNameMap fileNameMap = URLConnection.getFileNameMap();
   141      contentType = fileNameMap.getContentTypeFor(name);
   142  
   143      if (contentType == null) {
   144        int index = name.lastIndexOf(".");
   145        if (index > -1) {
   146          contentType = localFileNameMap.getProperty(name.substring(index));
   147        }
   148      }
   149  
   150      return contentType;
   151    }
   152  
   153  }