Synnefo » Pithos MS Client

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

            {

                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);

        }

    }

}