Synnefo » Pithos MS Client

#region

/* -----------------------------------------------------------------------

 * <copyright file="FileInfoExtensions.cs" company="GRNet">

 * 

 * Copyright 2011-2012 GRNET S.A. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or

 * without modification, are permitted provided that the following

 * conditions are met:

 *

 *   1. Redistributions of source code must retain the above

 *      copyright notice, this list of conditions and the following

 *      disclaimer.

 *

 *   2. Redistributions in binary form must reproduce the above

 *      copyright notice, this list of conditions and the following

 *      disclaimer in the documentation and/or other materials

 *      provided with the distribution.

 *

 *

 * THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 *

 * The views and conclusions contained in the software and

 * documentation are those of the authors and should not be

 * interpreted as representing official policies, either expressed

 * or implied, of GRNET S.A.

 * </copyright>

 * -----------------------------------------------------------------------

 */

#endregion

using System;

using System.Collections.Generic;

using System.Diagnostics.Contracts;

using System.Linq;

using System.Text;

using System.IO;

using System.Text.RegularExpressions;

using System.Threading.Tasks;

namespace Pithos.Interfaces

{

    public static class FileInfoExtensions

    {

        public static  string AsRelativeTo(this FileSystemInfo fileInfo,string path )

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path");            

            Contract.EndContractBlock();

            Contract.Assume(Enum.IsDefined(typeof(StringComparison),StringComparison.InvariantCultureIgnoreCase));

            if (!path.EndsWith("\\"))

                path=path.ToLower() + "\\";

            int pathLength = path.Length;            

            var filePath = fileInfo.GetProperCapitalization();

            if (!filePath.StartsWith(path,StringComparison.InvariantCultureIgnoreCase))

                throw new ArgumentException(String.Format("The path {0} doesn't contain the file {1}",path,filePath));

            var relativePath = filePath.Substring(pathLength, filePath.Length - pathLength);

            return relativePath;

        }

        public static string AsRelativeUrlTo(this FileSystemInfo fileInfo,string path )

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path");

            Contract.EndContractBlock();

            var relativePath = fileInfo.AsRelativeTo(path);

            var replacedSlashes = relativePath.Replace("\\","/");

            var escaped = Uri.EscapeUriString(replacedSlashes);

            return escaped;

        }

        public static string RelativeUriToFilePath(this Uri uri)

        {

            var unescaped = Uri.UnescapeDataString(uri.ToString());

            var path = unescaped.Replace("/", "\\");

            return path;

        }

        public static string GetProperDirectoryCapitalization(string fileName)

        {

            Contract.Ensures(!String.IsNullOrWhiteSpace(Contract.Result<string>()));

            Contract.EndContractBlock();

            if (String.IsNullOrWhiteSpace(fileName))

                return String.Empty;

            var dirInfo = new DirectoryInfo(fileName);

            return dirInfo.GetProperCapitalization();

        }

        public static string GetProperCapitalization(this DirectoryInfo dirInfo)

        {

            if (dirInfo == null)

                throw new ArgumentNullException("dirInfo");

            Contract.EndContractBlock();

            Contract.Assume(!String.IsNullOrWhiteSpace(dirInfo.FullName));

            var parentDirInfo = dirInfo.Parent;

            if (null == parentDirInfo)

                return dirInfo.Name;

            try

            {

                if (dirInfo.Exists)

                    return Path.Combine(GetProperDirectoryCapitalization(parentDirInfo.FullName),

                                        parentDirInfo.GetDirectories(dirInfo.Name)[0].Name);

                else

                {

                    return dirInfo.FullName;

                }

            }

            catch (DirectoryNotFoundException)

            {

                //An exception can occur if a directory is deleted right after the Exists call

                return dirInfo.FullName;

            }

        }

        public static string GetProperFilePathCapitalization(string fileName)

        {

            Contract.Ensures(!String.IsNullOrWhiteSpace(Contract.Result<string>()));

            Contract.EndContractBlock();

            if (String.IsNullOrWhiteSpace(fileName))

                return String.Empty;

            var fileInfo = new FileInfo(fileName);

            return fileInfo.GetProperCapitalization();

        }

        public static string GetProperCapitalization(this FileInfo fileInfo)

        {

            if (fileInfo == null)

                throw new ArgumentNullException("fileInfo");

            Contract.EndContractBlock();

            var dirInfo = fileInfo.Directory;

            //Directory will not be null for an absolute path

            Contract.Assume(dirInfo != null);

            try

            {

                //Exists returns a cached value that can be true even if a file was deleted since the

                //FileInfo object was created.

                fileInfo.Refresh();

                if (fileInfo.Exists)

                    return Path.Combine(GetProperDirectoryCapitalization(dirInfo.FullName),

                                        dirInfo.GetFiles(fileInfo.Name)[0].Name);

                else

                {

                    return fileInfo.FullName;

                }

            }

            catch (FileNotFoundException)

            {

                //An exception can occur if a file is deleted right after the Exists call

                return fileInfo.FullName;

            }

        }

        public static string GetProperCapitalization(this FileSystemInfo info)

        {

            if (info is FileInfo)

                return (info as FileInfo).GetProperCapitalization();

            if (info is DirectoryInfo)

                return (info as DirectoryInfo).GetProperCapitalization();

            throw new NotSupportedException("Unexpected parameter type");

        }

        public static DirectoryInfo WithProperCapitalization(this DirectoryInfo dirInfo)

        {

            if (dirInfo==null)

                throw new ArgumentNullException("dirInfo");

            Contract.EndContractBlock();

            var path = dirInfo.GetProperCapitalization();

            return new DirectoryInfo(path);

        }

        public static FileInfo WithProperCapitalization(this FileInfo fileInfo)

        {

            if (fileInfo==null)

                throw new ArgumentNullException("fileInfo");

            Contract.EndContractBlock();

            var path = fileInfo.GetProperCapitalization();

            return new FileInfo(path);

        }

        public static FileSystemInfo WithProperCapitalization(this FileSystemInfo info)

        {

            if (info==null)

                throw new ArgumentNullException("info");

            Contract.EndContractBlock();

            if (info is FileInfo)

                return (info as FileInfo).WithProperCapitalization();

            if (info is DirectoryInfo)

                return (info as DirectoryInfo).WithProperCapitalization();

            throw new NotSupportedException("Unexpected parameter type");

        }

        public static FileSystemInfo FromPath(string filePath)

        {

            if (String.IsNullOrWhiteSpace(filePath))

                throw new ArgumentNullException("filePath");

            Contract.EndContractBlock();

            return Directory.Exists(filePath) ? 

                (FileSystemInfo) new DirectoryInfo(filePath) 

                : new FileInfo(filePath);

        }

    }

}