{-# LANGUAGE CPP #-} -------------------------------------------------- {-# LANGUAGE NoImplicitPrelude #-} -------------------------------------------------- {-# LANGUAGE PackageImports #-} {-# LANGUAGE NamedFieldPuns, RecordWildCards #-} {-# LANGUAGE DoAndIfThenElse #-} -------------------------------------------------- {-# LANGUAGE DeriveDataTypeable, DeriveGeneric, DeriveAnyClass #-} {-# LANGUAGE PatternSynonyms #-} -------------------------------------------------- -------------------------------------------------- {-| Utilities for organizing application metadata and exporting application-specific filepaths. == API Types: * 'ApplicationInformation' * 'DesktopPlatform' * 'ApplicationInterface' Functions: * `getApplicationSpecificConfigFile` — a.k.a. the @${XDG\_CONFIG\_HOME}@. * `getApplicationSpecificDataDirectory` — a.k.a. the @${XDG\_DATA\_HOME}@. * `getApplicationSpecificCacheDirectory` — a.k.a. the @${XDG\_CACHE\_HOME}@. * `getApplicationSpecificRuntimeDirectory` — a.k.a. the @${XDG\_RUNTIME\_HOME}@. == Usage @ @ == Links * <https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html> * <https://stackoverflow.com/questions/43853548/xdg-basedir-directories-for-windows> * <https://wiki.archlinux.org/index.php/XDG_Base_Directory> -} module Prelude.Spiros.Application ( -- * Record of information for your application: ApplicationInformation(..) , ApplicationInformation0(..) , defaultApplicationInformation , defaultApplicationInformation0 , asExecutableName , ApplicationInterface(..) -- * Enumeration of your application's supported platforms. , DesktopPlatform(..) , allDesktopPlatforms , currentDesktopPlatform , posixDesktopPlatforms , asMacintoshDirectory , asPosixDirectory , asWindowsDirectory -- * Application-specific, XDG-conformant filepaths: -- | XDG-conformant filepaths, specific to your application ('ApplicationInformation'), and idiomatic for your platform ('DesktopPlatform'). -- -- * @$XDG_CONFIG_HOME@ -- * @$XDG_DATA_HOME@ -- * @$XDG_CACHE_HOME@ -- * @$XDG_RUNTIME_HOME@ -- , getApplicationSpecificConfigFile , getApplicationSpecificConfigurationDirectory , getApplicationSpecificDataDirectory , getApplicationSpecificDataFile , getApplicationSpecificCacheDirectory , getApplicationSpecificCacheFile , getApplicationSpecificRuntimeDirectory , getApplicationSpecificRuntimeFile -- * Read application-specific files. , readApplicationSpecificCacheFile , readApplicationSpecificConfigFile , readApplicationSpecificDataFile -- * Write application-specific files. , writeApplicationSpecificCacheFile , writeApplicationSpecificConfigFile , writeApplicationSpecificDataFile -- * @$XDG_CONFIG_HOME@ utilities: -- * @$XDG_DATA_HOME@ utilities: , listApplicationSpecificDataFiles -- * @$XDG_CACHE_HOME@ utilities: , clearApplicationSpecificCache -- * @$XDG_RUNTIME_HOME@ utilities: , touchApplicationSpecificRuntimeFile -- | -- -- The @getMyApplication{Config,Data,Cache}Directory@ operations -- return this application's (platform-specific, user-writeable) directory -- for @{configuration files, data files, caching}@. -- -- The @getMyApplication{Config,Data,Cache}Directory@ operations may throw these exceptions (all 'System.IO.IOError's): -- -- * @System.IO.HardwareFault@ -- A physical I\/O error has occurred. -- @[EIO]@ -- -- * 'System.IO.isDoesNotExistError' -- There is no path referring to the working directory. -- @[EPERM, ENOENT, ESTALE...]@ -- -- * 'System.IO.isPermissionError' -- The process has insufficient privileges to perform the operation. -- @[EACCES]@ -- -- * 'System.IO.isFullError' -- Insufficient resources are available to perform the operation. -- -- * @UnsupportedOperation@ -- The operating system has no notion of current working directory. -- -- ) where -------------------------------------------------- #include <sboo-base-feature-macros.h> -------------------------------------------------- -- Imports --------------------------------------- -------------------------------------------------- import Prelude.Spiros.Compatibility() import Prelude.Spiros.Reexports import Prelude.Spiros.System import Prelude.Spiros.Utilities -------------------------------------------------- -------------------------------------------------- import qualified "filepath" System.FilePath as File import "filepath" System.FilePath ((</>)) -------------------------------------------------- import qualified "directory" System.Directory as Directory -------------------------------------------------- import qualified "unix-compat" System.PosixCompat.Files as UNIX -------------------------------------------------- import qualified "split" Data.List.Split as Split -------------------------------------------------- -------------------------------------------------- --import qualified "text" Data.Text as T import qualified "text" Data.Text.IO as T import "text" Data.Text (Text) -------------------------------------------------- --import qualified "base" Control.Exception as E --import qualified "base" System.IO.Error as E import qualified "base" System.Environment as IO --import qualified "base" System.Info as Base --import qualified "base" GHC.Conc as GHC import qualified "base" Data.Char as Char -------------------------------------------------- import qualified "base" Prelude -------------------------------------------------- -- Types ----------------------------------------- -------------------------------------------------- {-| Metadata for a (cross-platform) application. == Fields Metadata: * 'name' — The name of the application. In english, should be capitalized and have spaces. * 'version' — The application's (current) version. Should be parseable by @base@'s 'Data.Version.parseVersion' (custom development versions, like injecting a git commit, should be separated from the version numbers by a hyphen). * 'license' — The application's license. Should be an SPDX License Identifier. * 'executable' — The basename (or shell identifier) of the executable file. Should match the @executable@ stanza in the package's @.cabal@. For legibility and portability, words should be separated by hyphens (i.e. @-@) or underscores (i.e. @_@). 'interface' — Whether the application has a Command-Line Interface or a Graphical-User Interface. Platform-specific metadata: * 'platforms' — Supported platforms (i.e. that the application is known to run on). * 'posixDirectory' — POSIX-Idiomatic naming convention (only alphanums and lowercase, see `asPosixDirectory`). * 'windowsDirectory' — Windows-Idiomatic naming convention (with spaces, plus the vendor name, see `asWindowsDirectory`). * 'macintoshDirectory' — MacOS-Idiomatic naming convention (with hyphens, plus the qualified vendor URI, see `asMacintoshDirectory`). == Example e.g.: @ myApplicationInformation :: ApplicationInformation myApplicationInformation = 'ApplicationInformation'{..} where 'name' = "My Application" 'version' = "0.0.0" 'license' = "GPL-3.0-or-later" 'vendor' = "sboosali.io" 'executable' = "my-application" 'interface' = 'ApplicationCLI' 'platforms' = 'allDesktopPlatforms' -- [ 'DesktopLinux', 'DesktopWindows', 'DesktopMacintosh' ] 'posixDirectory' = "myapplication\/" 'windowsDirectory' = "sboosali\/My Application\/" 'macintoshDirectory' = "io.sboosali.My-Application\/" @ -} data ApplicationInformation = ApplicationInformation { name :: String , version :: String , license :: String , vendor :: String , executable :: String , interface :: ApplicationInterface , platforms :: [DesktopPlatform] , posixDirectory :: String , windowsDirectory :: String , macintoshDirectory :: String } #if HAS_EXTENSION_DerivingStrategies deriving stock (Show,Read,Eq,Ord,Lift,Generic) deriving anyclass (NFData,Hashable) #else deriving (Show,Read,Eq,Ord,Generic) #endif -------------------------------------------------- -------------------------------------------------- {-| The primary fields of 'ApplicationInformation', from which the rest are derived (via 'defaultApplicationInformation'). Required fields share type with their namesake field (implicitly under @Identity@). Optional fields are wrapped under @Maybe@. -} data ApplicationInformation0 = ApplicationInformation0 { name0 :: String , version0 :: String , license0 :: String , vendor0 :: String , executable0 :: Maybe String , interface0 :: Maybe ApplicationInterface , platforms0 :: Maybe [DesktopPlatform] , posixDirectory0 :: Maybe String , windowsDirectory0 :: Maybe String , macintoshDirectory0 :: Maybe String } #if HAS_EXTENSION_DerivingStrategies deriving stock (Show,Read,Eq,Ord,Lift,Generic) deriving anyclass (NFData,Hashable) #else deriving (Show,Read,Eq,Ord,Generic) #endif -------------------------------------------------- -- | @= 'defaultApplicationInformation0'@ instance Default ApplicationInformation0 where def = defaultApplicationInformation0 -------------------------------------------------- {-| Default 'ApplicationInformation'. May call: * `asExecutableName` * `allDesktopPlatforms` * `asPosixDirectory` * `windowsDirectory` * `macintoshDirectory` -} defaultApplicationInformation :: ApplicationInformation0 -> ApplicationInformation defaultApplicationInformation ApplicationInformation0{..} = ApplicationInformation{..} where name = name0 version = version0 license = license0 vendor = vendor0 executable = executable0 & fromMaybe (asExecutableName name) interface = interface0 & fromMaybe def platforms = platforms0 & fromMaybe allDesktopPlatforms posixDirectory = posixDirectory0 & fromMaybe (asPosixDirectory name vendor) windowsDirectory = windowsDirectory0 & fromMaybe (asWindowsDirectory name vendor) macintoshDirectory = macintoshDirectory0 & fromMaybe (asMacintoshDirectory name vendor) -------------------------------------------------- -- | Required fields are @""@. Optional fields are @Nothing@. defaultApplicationInformation0 :: ApplicationInformation0 defaultApplicationInformation0 = ApplicationInformation0{..} where name0 = "" version0 = "" license0 = "" vendor0 = "" executable0 = Nothing interface0 = Nothing platforms0 = Nothing posixDirectory0 = Nothing windowsDirectory0 = Nothing macintoshDirectory0 = Nothing -------------------------------------------------- -------------------------------------------------- {-| Platform for desktop applications. -} data DesktopPlatform = DesktopLinux | DesktopWindows | DesktopMacintosh #if HAS_EXTENSION_DerivingStrategies deriving stock (Enum,Bounded,Ix) deriving anyclass (GEnum) deriving stock (Show,Read,Eq,Ord,Lift,Generic) deriving anyclass (NFData,Hashable) #else deriving (Enum,Bounded,Ix,Show,Read,Eq,Ord,Generic) #endif -------------------------------------------------- -------------------------------------------------- {-| The kind of application interface. Cases: * 'ApplicationCLI' — the application has a Command-Line Interface. * 'ApplicationGUI' — the application has a Graphical-User Interface. -} data ApplicationInterface = ApplicationCLI | ApplicationGUI #if HAS_EXTENSION_DerivingStrategies deriving stock (Enum,Bounded,Ix) deriving anyclass (GEnum) deriving stock (Show,Read,Eq,Ord,Lift,Generic) deriving anyclass (NFData,Hashable) #else deriving (Enum,Bounded,Ix,Show,Read,Eq,Ord,Generic) #endif -------------------------------------------------- -- | @= 'ApplicationCLI'@ instance Default ApplicationInterface where def = ApplicationCLI -------------------------------------------------- -- Constants ------------------------------------- -------------------------------------------------- currentDesktopPlatform :: Maybe DesktopPlatform currentDesktopPlatform = case currentOperatingSystem of Right Linux -> Just DesktopLinux Right Windows -> Just DesktopWindows Right OSX -> Just DesktopMacintosh _ -> Nothing --TODO runtimeDesktopPlatform: -- respect cross-compilation, i.e. TARGET_OS, not HOST_OS. -------------------------------------------------- allDesktopPlatforms :: [DesktopPlatform] allDesktopPlatforms = constructors' -------------------------------------------------- posixDesktopPlatforms :: [DesktopPlatform] posixDesktopPlatforms = [ DesktopLinux, DesktopMacintosh ] -------------------------------------------------- -- Functions ------------------------------------- -------------------------------------------------- -- Application Files... {- Return a (platform-specific) **configuration file** for the application. Conforms to the @XDG BaseDir@s specification. Environment Variables: * @$XDG_CONFIG_DIR@ — on POSIX. * @%APPDATA%@ — on Windows. Wraps 'getApplicationSpecificConfigFile'. -} getApplicationSpecificConfigFile :: ApplicationInformation -> FilePath -> IO FilePath getApplicationSpecificConfigFile application path = do directory <- getApplicationSpecificConfigurationDirectory application return (directory </> path) -------------------------------------------------- {- Return a (platform-specific) **data file** for the application. Conforms to the @XDG BaseDir@s specification. Environment Variables: * @$XDG_DATA_DIR@ — on POSIX. * @%APPDATA%@ — on Windows. Wraps 'getApplicationSpecificDataFile'. -} getApplicationSpecificDataFile :: ApplicationInformation -> FilePath -> IO FilePath getApplicationSpecificDataFile application path = do directory <- getApplicationSpecificDataDirectory application return (directory </> path) -------------------------------------------------- {- Return a **cached file** for the running application. Conforms to the @XDG BaseDir@s specification. Environment Variables: * @$XDG_CACHE_DIR@ — on POSIX. * @%LOCALAPPDATA%@ — on Windows. Wraps 'getApplicationSpecificCacheFile'. -} getApplicationSpecificCacheFile :: ApplicationInformation -> FilePath -> IO FilePath getApplicationSpecificCacheFile application path = do directory <- getApplicationSpecificCacheDirectory application return (directory </> path) -------------------------------------------------- {- Return an **ephemeral file** (or pipe, socket, etc) for the running application. Conforms to the @XDG BaseDir@s specification. Environment Variables: * @$XDG_RUNTIME_DIR@ — on POSIX. * @%TEMP%@ — on Windows. Wraps 'getApplicationSpecificRuntimeFile'. -} getApplicationSpecificRuntimeFile :: ApplicationInformation -> FilePath -> IO FilePath getApplicationSpecificRuntimeFile application path = do directory <- getApplicationSpecificRuntimeDirectory application return (directory </> path) -------------------------------------------------- -- Application Directories... {- Return the application's (platform-specific) **configuration directory**. Output: * is an absolute path * should be a user-writeable directory. Conforms to the @XDG BaseDir@s specification. Environment Variables: * @$XDG_CONFIG_DIR@ — on POSIX. * @%APPDATA%@ — on Windows. Notes: > -} getApplicationSpecificConfigurationDirectory :: ApplicationInformation -> IO FilePath getApplicationSpecificConfigurationDirectory application = getApplicationSpecificXdgDirectory Directory.XdgConfig application "" -------------------------------------------------- {- Return the application's (platform-specific) **data directory**. Output: * is an absolute path * should be a user-writeable directory. Conforms to the @XDG BaseDir@s specification. Environment Variables: * @$XDG_DATA_DIR@ — on POSIX. * @%APPDATA%@ — on Windows. Notes: > -} getApplicationSpecificDataDirectory :: ApplicationInformation -> IO FilePath getApplicationSpecificDataDirectory application = getApplicationSpecificXdgDirectory Directory.XdgData application "" -------------------------------------------------- {- Return the application's (platform-specific) **cache directory**. Output: * is an absolute path * should be a user-writeable directory. Conforms to the @XDG BaseDir@s specification. Environment Variables: * @$XDG_CACHE_DIR@ — on POSIX. * @%LOCALAPPDATA%@ — on Windows. Notes: > -} getApplicationSpecificCacheDirectory :: ApplicationInformation -> IO FilePath getApplicationSpecificCacheDirectory application = getApplicationSpecificXdgDirectory Directory.XdgCache application "" -------------------------------------------------- {- Return the application's (platform-specific) **runtime directory**. Output: * is an absolute path * should be a user-writeable directory. * should be \"private\" (**not** group-readable or word-readable). Conforms to the @XDG BaseDir@s specification. Environment Variables: * @$XDG_RUNTIME_DIR@ — on POSIX. * @%TEMP%@ — on Windows. Notes: > The runtime dir should be used for storing ephemeral things like pipes and sockets or other objects restricted to the current run of the program. It is likely created when a user logs in and deleted when the user logs out. It probably lives in a RAM-based file system. -} getApplicationSpecificRuntimeDirectory :: ApplicationInformation -> IO FilePath getApplicationSpecificRuntimeDirectory application = wrap $ do let getDefaultPath = Directory.getHomeDirectory runtimeDirectory <- getPathFromEnvironmentOrDefault getDefaultPath environmentVariable let subdirectory = currentApplicationSpecificSubDirectory application let directory = runtimeDirectory </> subdirectory absolutePath <- Directory.makeAbsolute directory return absolutePath where wrap action = {-(`E.ioeAddLocation` "getXdgDirectory") `E.modifyIOError`-} action environmentVariable :: String environmentVariable = case currentDesktopPlatform of Just DesktopLinux -> "XDG_RUNTIME_DIR" Just DesktopWindows -> "TEMP" Just DesktopMacintosh -> "TEMP" --TODO-- "TEMP" or "XDG_RUNTIME_DIR"? Nothing -> "" -------------------------------------------------- -- File Readers... readApplicationSpecificConfigFile :: ApplicationInformation -> FilePath -> IO (Maybe Text) readApplicationSpecificConfigFile application relativePath = readTextFileWith getFilePath where getFilePath = getApplicationSpecificConfigFile application relativePath -------------------------------------------------- readApplicationSpecificDataFile :: ApplicationInformation -> FilePath -> IO (Maybe Text) readApplicationSpecificDataFile application relativePath = readTextFileWith getFilePath where getFilePath = getApplicationSpecificDataFile application relativePath -------------------------------------------------- readApplicationSpecificCacheFile :: ApplicationInformation -> FilePath -> IO (Maybe Text) readApplicationSpecificCacheFile application relativePath = readTextFileWith getFilePath where getFilePath = getApplicationSpecificCacheFile application relativePath -------------------------------------------------- -- File Writers.. writeApplicationSpecificConfigFile :: ApplicationInformation -> FilePath -> Text -> IO () writeApplicationSpecificConfigFile application relativePath fileContents = writeTextFileWith getFilePath fileContents where getFilePath = getApplicationSpecificConfigFile application relativePath -------------------------------------------------- writeApplicationSpecificDataFile :: ApplicationInformation -> FilePath -> Text -> IO () writeApplicationSpecificDataFile application relativePath fileContents = writeTextFileWith getFilePath fileContents where getFilePath = getApplicationSpecificDataFile application relativePath -------------------------------------------------- writeApplicationSpecificCacheFile :: ApplicationInformation -> FilePath -> Text -> IO () writeApplicationSpecificCacheFile application relativePath fileContents = writeTextFileWith getFilePath fileContents where getFilePath = getApplicationSpecificCacheFile application relativePath -------------------------------------------------- -- Custom File Operations... listApplicationSpecificDataFiles :: ApplicationInformation -> IO [FilePath] listApplicationSpecificDataFiles application = do absolutePath <- getApplicationSpecificCacheDirectory application exists <- Directory.doesDirectoryExist absolutePath if exists then do filePaths <- Directory.listDirectory absolutePath return filePaths -- TODO list files recursively else do return [] -------------------------------------------------- clearApplicationSpecificCache :: ApplicationInformation -> IO FilePath clearApplicationSpecificCache application = do absolutePath <- getApplicationSpecificCacheDirectory application whenM (Directory.doesDirectoryExist absolutePath) $ do Directory.removeDirectoryRecursive absolutePath whenM (Directory.doesFileExist absolutePath) $ do Directory.removeFile absolutePath return absolutePath -------------------------------------------------- touchApplicationSpecificRuntimeFile :: ApplicationInformation -> FilePath -> IO Bool touchApplicationSpecificRuntimeFile application relativePath = do absolutePath <- getApplicationSpecificRuntimeFile application relativePath exists <- Directory.doesFileExist absolutePath if exists then do UNIX.touchFile absolutePath return False -- "no", already created (just touch it, to keep it alive). else do let directoryPath = File.takeDirectory absolutePath Directory.createDirectoryIfMissing True directoryPath UNIX.touchFile absolutePath return True -- "yes", newly created. -------------------------------------------------- -- Utilities ------------------------------------- -------------------------------------------------- --createDirectoryIfMissing {- | the input @FilePath@ __must__ be /strictly relative/. i.e.: * no @../@ * -} getApplicationSpecificXdgDirectory :: Directory.XdgDirectory -> ApplicationInformation -> FilePath -> IO FilePath getApplicationSpecificXdgDirectory xdgDirectoryKind application path = do let subdirectory = currentApplicationSpecificSubDirectory application let relativePath = subdirectory File.</> path xdgPath <- Directory.getXdgDirectory xdgDirectoryKind relativePath absolutePath <- Directory.makeAbsolute xdgPath return absolutePath --TODO validation: -- fail (either throw or clean) on non-true-relative subdirectories (i.e. no « ../ »). -------------------------------------------------- currentApplicationSpecificSubDirectory :: ApplicationInformation -> FilePath currentApplicationSpecificSubDirectory ApplicationInformation{..} = case currentDesktopPlatform of Just DesktopLinux -> posixDirectory Just DesktopWindows -> windowsDirectory Just DesktopMacintosh -> macintoshDirectory Nothing -> executable -------------------------------------------------- readTextFileWith :: IO FilePath -> IO (Maybe Text) readTextFileWith getFilePath = do absolutePath <- getFilePath exists <- Directory.doesFileExist absolutePath if exists then do fileContents <- T.readFile absolutePath return (Just fileContents) else do return Nothing -------------------------------------------------- {-| Creates any (non-existant) parent directories (in Bash, like a @mkdir -p@ on the @dirname@). -} writeTextFileWith :: IO FilePath -> Text -> IO () writeTextFileWith getFilePath fileContents = do absolutePath <- getFilePath let directoryPath = File.takeDirectory absolutePath Directory.createDirectoryIfMissing True directoryPath T.writeFile absolutePath fileContents --if Directory.doesFileExist absolutePath -------------------------------------------------- getPathFromEnvironmentOrDefault :: IO FilePath -> String -> IO FilePath getPathFromEnvironmentOrDefault getDefaultPath variable = do valueDynamicPath <- go case valueDynamicPath of Nothing -> do defaultPath <- getDefaultPath pure defaultPath Just dynamicPath -> pure dynamicPath where go = if isValidEnvironmentVariableName variable then IO.lookupEnv variable else pure Nothing -------------------------------------------------- isValidEnvironmentVariableName :: String -> Bool isValidEnvironmentVariableName s = s == "" -------------------------------------------------- {- | Construct a 'executable' from a 'name'. == Examples >>> asExecutableName "My Application" "my-application" -} asExecutableName :: String -> String asExecutableName name = go name where go = fmap Char.toLower > convertSpacesToHyphens -------------------------------------------------- {- | Construct a 'posixDirectory' from a 'name'. == Examples >>> import qualified Prelude >>> asPosixDirectory "My Application" Prelude.undefined "myapplication/" -} asPosixDirectory :: String -> String -> String asPosixDirectory name _vendor = path where path = go name go = fmap Char.toLower > filter (not . Char.isSpace) > (++ "/") -------------------------------------------------- {- | Construct a 'windowsDirectory' from a 'vendor' and a 'name'. == Examples >>> asWindowsDirectory "My Application" "www.sboosali.com" "sboosali/My Application/" -} asWindowsDirectory :: String -> String -> String asWindowsDirectory name vendor = path where path = concat [ host, "/", name, "/" ] host = vendor & ( Split.splitOn "." > getSecondToLast > maybe vendor id ) getSecondToLast :: [a] -> Maybe a getSecondToLast = reverse > nth 1 -------------------------------------------------- {- | Construct a 'macintoshDirectory' from a 'vendor' and a 'name'. == Examples >>> asMacintoshDirectory "My Application" "www.sboosali.com" "com.sboosali.www.My-Application/" -} asMacintoshDirectory :: String -> String -> String asMacintoshDirectory name vendor = path where path = concat [ vendor', ".", name', "/" ] name' = name & convertSpacesToHyphens vendor' = vendor & reverseByDot reverseByDot :: String -> String reverseByDot = Split.splitOn "." > reverse > intercalate "." -------------------------------------------------- {- | Convert multiple whitespace characters to a single hyphen character. == Examples >>> convertSpacesToHyphens " phrase with spaces " "phrase-with-spaces" -} convertSpacesToHyphens :: String -> String convertSpacesToHyphens = Split.split splitter > intercalate "-" where splitter :: Split.Splitter Char splitter = Split.whenElt Char.isSpace & ( Split.condense > Split.dropBlanks > Split.dropDelims ) -- Split.defaultSplitter -- replace " " "-" -------------------------------------------------- -- Notes ----------------------------------------- -------------------------------------------------- {- -------------------------------------------------- `turtle` touch :: MonadIO io => FilePath -> io () -- Touch a file, updating the access and modification times to the current time -- -- Creates an empty file if it does not exist touch file = do exists <- testfile file liftIO (if exists #ifdef mingw32_HOST_OS then do handle <- Win32.createFile (Filesystem.encodeString file) Win32.gENERIC_WRITE Win32.fILE_SHARE_NONE Nothing Win32.oPEN_EXISTING Win32.fILE_ATTRIBUTE_NORMAL Nothing (creationTime, _, _) <- Win32.getFileTime handle systemTime <- Win32.getSystemTimeAsFileTime Win32.setFileTime handle creationTime systemTime systemTime #else then touchFile (Filesystem.encodeString file) #endif else output file empty ) -------------------------------------------------- `system-filepath` import qualified Filesystem.Path.CurrentOS as Filesystem -------------------------------------------------- `unix` import System.Posix ( touchFile ) touchFile :: FilePath -> IO () -- | @touchFile path@ sets the access and modification times associated with -- file @path@ to the current time. -- -- Note: calls @utime@. touchFile name = do withFilePath name $ \s -> throwErrnoPathIfMinus1_ "touchFile" name (c_utime s nullPtr) -------------------------------------------------- `unix-compat` touchFile :: FilePath -> IO () -- touchFile path sets the access and modification times associated with file path to the current time. -- -- Note: calls utime. touchFile -------------------------------------------------- -- `split` -- | Split on the given sublist. Equivalent to @'split' -- . 'dropDelims' . 'onSublist'@. For example: -- -- > splitOn ".." "a..b...c....d.." == ["a","b",".c","","d",""] -- -- In some parsing combinator frameworks this is also known as -- @sepBy@. -- -- Note that this is the right inverse of the 'Data.List.intercalate' function -- from "Data.List", that is, -- -- > intercalate x . splitOn x === id -- -- @'splitOn' x . 'Data.List.intercalate' x@ is the identity on -- certain lists, but it is tricky to state the precise conditions -- under which this holds. (For example, it is not enough to say -- that @x@ does not occur in any elements of the input list. -- Working out why is left as an exercise for the reader.) splitOn :: Eq a => [a] -> [a] -> [[a]] splitOn = split . dropDelims . onSublist -- | Split on elements satisfying the given predicate. Equivalent to -- @'split' . 'dropDelims' . 'whenElt'@. For example: -- -- > splitWhen (<0) [1,3,-4,5,7,-9,0,2] == [[1,3],[5,7],[0,2]] splitWhen :: (a -> Bool) -> [a] -> [[a]] splitWhen = split . dropDelims . whenElt -------------------------------------------------- -- `` -------------------------------------------------- -- `` -------------------------------------------------- -} -------------------------------------------------- -- EOF ------------------------------------------- --------------------------------------------------