1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
module Daffm.State where
import qualified Brick.Widgets.Edit as Editor
import qualified Brick.Widgets.List as L
import Control.Applicative ((<|>))
import Control.Monad (filterM, forM)
import Daffm.Types
import Daffm.Utils (trim)
import Data.List (findIndex, sortBy)
import qualified Data.Map.Strict as Map
import Data.Maybe (fromMaybe)
import qualified Data.Set as Set
import qualified Data.Text as Text
import qualified Data.Text.Zipper.Generic as Zipper
import qualified Data.Vector as Vec
import qualified Graphics.Vty as K
import System.Directory (doesDirectoryExist, getHomeDirectory, listDirectory, makeAbsolute, setCurrentDirectory)
import System.FilePath (joinPath)
import System.PosixCompat (fileExist)
import qualified System.PosixCompat as Posix
defaultKeymaps :: Keymap
defaultKeymaps =
Map.fromList
[ ([K.KChar 'q'], CmdQuit),
([K.KChar 'r', K.KChar 'r'], CmdReload),
([K.KChar '!'], CmdSetCmdline "!"),
([K.KChar ':'], CmdEnterCmdline),
([K.KChar 'l'], CmdOpenSelection),
([K.KChar 'h'], CmdGoBack),
([K.KEnter], CmdOpenSelection),
([K.KBS], CmdGoBack),
([K.KChar 'v'], CmdToggleSelection),
([K.KChar '\t'], CmdToggleSelection),
([K.KChar 'C'], CmdClearSelection),
([K.KChar '~'], CmdChangeDir "~"),
([K.KChar '$'], CmdShell False "$SHELL"),
([K.KChar 'g', K.KChar 'x'], CmdShell False "!xdg-open % >/dev/null 2>&1"),
([K.KChar 'g', K.KChar 'h'], CmdChangeDir "~"),
([K.KChar 'g', K.KChar 'c', K.KChar 'f', K.KChar 'g'], CmdChangeDir "~/.config/daffm")
]
mkEditor :: (Zipper.GenericTextZipper a) => a -> Editor.Editor a FocusTarget
mkEditor = Editor.editor FocusCmdline (Just 1)
mkEmptyAppState :: Configuration -> AppState
mkEmptyAppState config =
AppState
{ stateFiles = L.list FocusMain (Vec.fromList []) 1,
stateCmdlineEditor = mkEditor "",
stateFocusTarget = FocusMain,
stateListPositionHistory = Map.empty,
stateFileSelections = Set.empty,
stateCwd = "",
stateKeyMap = configKeymap config <> defaultKeymaps,
stateOpenerScript = configOpener config,
stateKeySequence = []
}
toggleSetItem :: (Ord a) => a -> Set.Set a -> Set.Set a
toggleSetItem val set =
if Set.member val set then Set.delete val set else Set.insert val set
toggleFileSelection :: FilePathText -> AppState -> AppState
toggleFileSelection path st = st {stateFileSelections = toggleSetItem path $ stateFileSelections st}
normalizePath :: FilePathText -> IO FilePathText
normalizePath (Text.null -> True) = Text.pack <$> getHomeDirectory
normalizePath "~" = Text.pack <$> getHomeDirectory
normalizePath (Text.stripPrefix "~/" -> (Just rest)) = do
home <- getHomeDirectory
pure . Text.pack . joinPath $ [home, Text.unpack rest]
normalizePath dir = pure dir
stripQuotes :: Text.Text -> Text.Text
stripQuotes txt = fromMaybe txt (double <|> single)
where
double = Text.stripPrefix "\"" txt >>= Text.stripSuffix "\""
single = Text.stripPrefix "'" txt >>= Text.stripSuffix "'"
loadDirToState :: FilePathText -> AppState -> IO AppState
loadDirToState dir' appState@(AppState {stateCwd, stateListPositionHistory}) = do
dir <- normalizePath . stripQuotes $ trim dir'
doesDirectoryExist (Text.unpack dir) >>= \case
True -> do
setCurrentDirectory $ Text.unpack dir
files <- listFilesInDir dir
let prevDirPosM = findIndex ((== stateCwd) . filePath) files
let cachedPosM = Map.lookup dir stateListPositionHistory
let pos = fromMaybe 0 (cachedPosM <|> prevDirPosM)
let list = L.listMoveTo pos $ L.list FocusMain (Vec.fromList files) 1
pure $
appState
{ stateFiles = list,
stateCwd = dir
}
False -> pure appState
fileTypeFromStatus :: Posix.FileStatus -> FileType
fileTypeFromStatus s =
if
| Posix.isBlockDevice s -> BlockDevice
| Posix.isCharacterDevice s -> CharacterDevice
| Posix.isNamedPipe s -> NamedPipe
| Posix.isRegularFile s -> RegularFile
| Posix.isDirectory s -> Directory
| Posix.isSocket s -> UnixSocket
| Posix.isSymbolicLink s -> SymbolicLink
| otherwise -> UnknownFileType
getFileInfo :: FilePathText -> IO FileInfo
getFileInfo name = do
path <- makeAbsolute $ Text.unpack name
stat <- Posix.getSymbolicLinkStatus path
pure $
FileInfo
{ filePath = Text.pack path,
fileName = name,
fileSize = Posix.fileSize stat,
fileMode = Posix.fileMode stat,
fileType = fileTypeFromStatus stat
}
fileSorter :: FileInfo -> FileInfo -> Ordering
fileSorter (FileInfo {fileType = Directory, fileName = fa}) (FileInfo {fileType = Directory, fileName = fb}) =
compare (Text.toLower fa) (Text.toLower fb)
fileSorter (FileInfo {fileType = Directory}) _ = LT
fileSorter _ (FileInfo {fileType = Directory}) = GT
fileSorter (FileInfo {fileName = fa}) (FileInfo {fileName = fb}) =
compare (Text.toLower fa) (Text.toLower fb)
listFilesInDir :: FilePathText -> IO [FileInfo]
listFilesInDir dir = do
files <- listDirectory (Text.unpack dir)
sortBy fileSorter <$> forM files (getFileInfo . Text.pack)
cacheDirPosition :: AppState -> AppState
cacheDirPosition appState@(AppState {stateListPositionHistory, stateCwd, stateFiles}) =
appState {stateListPositionHistory = Map.insert stateCwd pos stateListPositionHistory}
where
pos = fromMaybe 0 $ L.listSelected stateFiles
filterInvalidSelections :: AppState -> IO AppState
filterInvalidSelections st = do
selections <- filterM (fileExist . Text.unpack) . Set.elems $ stateFileSelections st
pure $ st {stateFileSelections = Set.fromList selections}
|
