Commit | Line | Data |
---|---|---|
9eaab35f | 1 | #!/usr/bin/env bash |
acaa0f3d SBS |
2 | # Desc: Wrapper for feh that accepts directory paths via posargs or stdin lines. |
3 | # Version: 0.2.0 | |
9eaab35f SBS |
4 | # Ref/Attrib: [1] Tange, Ole. GNU Parallel with Bash Array. 2019-03-24. https://unix.stackexchange.com/a/508365/411854 |
5 | # Depends: GNU Parallel, GNU Bash v5.1.16, feh 3.6.3 | |
6 | ||
7 | #===Declare local functions=== | |
8 | yell() { echo "$0: $*" >&2; } # print script path and all args to stderr | |
9 | die() { yell "$*"; exit 111; } # same as yell() but non-zero exit status | |
10 | must() { "$@" || die "cannot $*"; } # runs args as command, reports args if command fails | |
11 | checkapp() { | |
12 | # Desc: If arg is a command, save result in assoc array 'appRollCall' | |
13 | # Usage: checkapp arg1 arg2 arg3 ... | |
14 | # Version: 0.1.1 | |
15 | # Input: global assoc. array 'appRollCall' | |
16 | # Output: adds/updates key(value) to global assoc array 'appRollCall' | |
17 | # Depends: bash 5.0.3 | |
18 | local returnState | |
19 | ||
20 | #===Process Args=== | |
21 | for arg in "$@"; do | |
22 | if command -v "$arg" 1>/dev/null 2>&1; then # Check if arg is a valid command | |
23 | appRollCall[$arg]="true"; | |
24 | if ! [ "$returnState" = "false" ]; then returnState="true"; fi; | |
25 | else | |
26 | appRollCall[$arg]="false"; returnState="false"; | |
27 | fi; | |
28 | done; | |
29 | ||
30 | #===Determine function return code=== | |
31 | if [ "$returnState" = "true" ]; then | |
32 | return 0; | |
33 | else | |
34 | return 1; | |
35 | fi; | |
36 | } # Check that app exists | |
37 | checkfile() { | |
38 | # Desc: If arg is a file path, save result in assoc array 'fileRollCall' | |
39 | # Usage: checkfile arg1 arg2 arg3 ... | |
40 | # Version: 0.1.1 | |
41 | # Input: global assoc. array 'fileRollCall' | |
42 | # Output: adds/updates key(value) to global assoc array 'fileRollCall'; | |
43 | # Output: returns 0 if app found, 1 otherwise | |
44 | # Depends: bash 5.0.3 | |
45 | local returnState | |
46 | ||
47 | #===Process Args=== | |
48 | for arg in "$@"; do | |
49 | if [ -f "$arg" ]; then | |
50 | fileRollCall["$arg"]="true"; | |
51 | if ! [ "$returnState" = "false" ]; then returnState="true"; fi; | |
52 | else | |
53 | fileRollCall["$arg"]="false"; returnState="false"; | |
54 | fi; | |
55 | done; | |
56 | ||
57 | #===Determine function return code=== | |
58 | if [ "$returnState" = "true" ]; then | |
59 | return 0; | |
60 | else | |
61 | return 1; | |
62 | fi; | |
63 | } # Check that file exists | |
64 | checkdir() { | |
65 | # Desc: If arg is a dir path, save result in assoc array 'dirRollCall' | |
66 | # Usage: checkdir arg1 arg2 arg3 ... | |
67 | # Version 0.1.1 | |
68 | # Input: global assoc. array 'dirRollCall' | |
69 | # Output: adds/updates key(value) to global assoc array 'dirRollCall'; | |
70 | # Output: returns 0 if app found, 1 otherwise | |
71 | # Depends: Bash 5.0.3 | |
72 | local returnState | |
73 | ||
74 | #===Process Args=== | |
75 | for arg in "$@"; do | |
76 | if [ -d "$arg" ]; then | |
77 | dirRollCall["$arg"]="true"; | |
78 | if ! [ "$returnState" = "false" ]; then returnState="true"; fi | |
79 | else | |
80 | dirRollCall["$arg"]="false"; returnState="false"; | |
81 | fi | |
82 | done | |
83 | ||
84 | #===Determine function return code=== | |
85 | if [ "$returnState" = "true" ]; then | |
86 | return 0; | |
87 | else | |
88 | return 1; | |
89 | fi | |
90 | } # Check that dir exists | |
91 | displayMissing() { | |
92 | # Desc: Displays missing apps, files, and dirs | |
93 | # Usage: displayMissing | |
94 | # Version 0.1.1 | |
95 | # Input: associative arrays: appRollCall, fileRollCall, dirRollCall | |
96 | # Output: stderr: messages indicating missing apps, file, or dirs | |
97 | # Depends: bash 5, checkAppFileDir() | |
98 | local missingApps value appMissing missingFiles fileMissing | |
99 | local missingDirs dirMissing | |
100 | ||
101 | #==BEGIN Display errors== | |
102 | #===BEGIN Display Missing Apps=== | |
103 | missingApps="Missing apps :"; | |
104 | #for key in "${!appRollCall[@]}"; do echo "DEBUG:$key => ${appRollCall[$key]}"; done | |
105 | for key in "${!appRollCall[@]}"; do | |
106 | value="${appRollCall[$key]}"; | |
107 | if [ "$value" = "false" ]; then | |
108 | #echo "DEBUG:Missing apps: $key => $value"; | |
109 | missingApps="$missingApps""$key "; | |
110 | appMissing="true"; | |
111 | fi; | |
112 | done; | |
113 | if [ "$appMissing" = "true" ]; then # Only indicate if an app is missing. | |
114 | echo "$missingApps" 1>&2; | |
115 | fi; | |
116 | unset value; | |
117 | #===END Display Missing Apps=== | |
118 | ||
119 | #===BEGIN Display Missing Files=== | |
120 | missingFiles="Missing files:"; | |
121 | #for key in "${!fileRollCall[@]}"; do echo "DEBUG:$key => ${fileRollCall[$key]}"; done | |
122 | for key in "${!fileRollCall[@]}"; do | |
123 | value="${fileRollCall[$key]}"; | |
124 | if [ "$value" = "false" ]; then | |
125 | #echo "DEBUG:Missing files: $key => $value"; | |
126 | missingFiles="$missingFiles""$key "; | |
127 | fileMissing="true"; | |
128 | fi; | |
129 | done; | |
130 | if [ "$fileMissing" = "true" ]; then # Only indicate if an app is missing. | |
131 | echo "$missingFiles" 1>&2; | |
132 | fi; | |
133 | unset value; | |
134 | #===END Display Missing Files=== | |
135 | ||
136 | #===BEGIN Display Missing Directories=== | |
137 | missingDirs="Missing dirs:"; | |
138 | #for key in "${!dirRollCall[@]}"; do echo "DEBUG:$key => ${dirRollCall[$key]}"; done | |
139 | for key in "${!dirRollCall[@]}"; do | |
140 | value="${dirRollCall[$key]}"; | |
141 | if [ "$value" = "false" ]; then | |
142 | #echo "DEBUG:Missing dirs: $key => $value"; | |
143 | missingDirs="$missingDirs""$key "; | |
144 | dirMissing="true"; | |
145 | fi; | |
146 | done; | |
147 | if [ "$dirMissing" = "true" ]; then # Only indicate if an dir is missing. | |
148 | echo "$missingDirs" 1>&2; | |
149 | fi; | |
150 | unset value; | |
151 | #===END Display Missing Directories=== | |
152 | ||
153 | #==END Display errors== | |
154 | } # Display missing apps, files, dirs | |
155 | check_depends() { | |
156 | if ! checkapp feh parallel; then displayMissing; die "FATAL:Missing apps."; fi; | |
157 | return 1; | |
158 | }; # check dependencies | |
acaa0f3d SBS |
159 | checkInt() { |
160 | # Desc: Checks if arg is integer | |
161 | # Usage: checkInt arg | |
162 | # Input: arg: integer | |
163 | # Output: - return code 0 (if arg is integer) | |
164 | # - return code 1 (if arg is not integer) | |
165 | # Example: if ! checkInt $arg; then echo "not int"; fi; | |
166 | # Version: 0.0.1 | |
167 | local returnState | |
168 | ||
169 | #===Process Arg=== | |
170 | if [[ $# -ne 1 ]]; then | |
171 | die "ERROR:Invalid number of arguments:$#"; | |
172 | fi; | |
173 | ||
174 | RETEST1='^[0-9]+$'; # Regular Expression to test | |
175 | if [[ ! $1 =~ $RETEST1 ]] ; then | |
176 | returnState="false"; | |
177 | else | |
178 | returnState="true"; | |
179 | fi; | |
180 | ||
181 | #===Determine function return code=== | |
182 | if [ "$returnState" = "true" ]; then | |
183 | return 0; | |
184 | else | |
185 | return 1; | |
186 | fi; | |
187 | } # Checks if arg is integer | |
335b71e1 SBS |
188 | read_stdin() { |
189 | # Desc: Consumes stdin; outputs as stdout lines | |
9eaab35f | 190 | # Input: stdin (consumes) |
9eaab35f | 191 | # Output: stdout (newline delimited) |
335b71e1 | 192 | # Example: printf "foo\nbar\n" | read_stdin |
9eaab35f | 193 | # Depends: GNU bash (version 5.1.16) |
335b71e1 SBS |
194 | # Version: 0.0.1 |
195 | local input_stdin output; | |
9eaab35f SBS |
196 | |
197 | # Store stdin | |
198 | if [[ -p /dev/stdin ]]; then | |
199 | input_stdin="$(cat -)"; | |
335b71e1 | 200 | fi; |
966a8d11 | 201 | |
335b71e1 | 202 | # Store as output array elements |
9eaab35f SBS |
203 | ## Read in stdin |
204 | if [[ -n $input_stdin ]]; then | |
205 | while read -r line; do | |
206 | output+=("$line"); | |
207 | done < <(printf "%s\n" "$input_stdin"); | |
208 | fi; | |
335b71e1 SBS |
209 | |
210 | # Print to stdout | |
211 | printf "%s\n" "${output[@]}"; | |
212 | }; # read stdin to stdout lines | |
213 | read_psarg() { | |
214 | # Desc: Reads arguments; outputs as stdout lines | |
215 | # Input: args | |
216 | # Output: stdout (newline delimited) | |
217 | # Example: read_psarg "$@" | |
218 | # Depends: GNU bash (version 5.1.16) | |
219 | # Version: 0.0.1 | |
220 | local input_psarg output; | |
221 | ||
222 | # Store arguments | |
223 | if [[ $# -gt 0 ]]; then | |
224 | input_psarg="$*"; | |
225 | fi; | |
226 | ||
227 | # Store as output array elements | |
9eaab35f SBS |
228 | ## Read in positional arguments |
229 | if [[ -n $input_psarg ]]; then | |
230 | for arg in "$@"; do | |
231 | output+=("$arg"); | |
232 | done; | |
233 | fi; | |
234 | ||
235 | # Print to stdout | |
236 | printf "%s\n" "${output[@]}"; | |
335b71e1 SBS |
237 | }; # read positional argument to stdout lines |
238 | find_flist() { | |
9eaab35f SBS |
239 | # Desc: print file list to stdout via `find` using script parameters |
240 | # Input: arg1: path to dir | |
241 | # var: find_depth | |
242 | # var: pattern_find_iregex | |
243 | # var: find_size | |
244 | if [[ ! -d "$1" ]]; then return 1; fi; | |
335b71e1 | 245 | must find "$1" -maxdepth "$fdepth" -type f -iregex "$firegex" -size +"$fsize"; |
9eaab35f | 246 | }; # print file list to stdout from dir with script parameters |
4db78240 SBS |
247 | save_sample() { |
248 | # Usage: save_sample arg1 | |
249 | # Input: arg1 list_paths (list of files to take samples from) | |
250 | # envvar BKFEH_SAMPLE_DIR (environment variable set outside of this script) | |
acaa0f3d | 251 | # envvar BKFEH_SAMPLE_SIZE (space limit for sample dir files) |
4db78240 SBS |
252 | # Depends: yell(), GNU Parallel, GNU find, GNU Coreutils 8.32 (cut, find, du) |
253 | local list_paths | |
acaa0f3d SBS |
254 | sample_count="100"; # max number of images to put in sample dir |
255 | sample_max_space="10000000"; # max bytes to put in sample dir | |
256 | ||
257 | # Load environment variables if set | |
4db78240 | 258 | if [[ ! -v BKFEH_SAMPLE_DIR ]]; then return 0; fi; # return early if environment var not set. |
acaa0f3d SBS |
259 | if [[ -v BKFEH_SAMPLE_SIZE ]] && checkInt "$BKFEH_SAMPLE_SIZE"; then |
260 | sample_max_space="$BKFEH_SAMPLE_SIZE"; | |
261 | fi; | |
262 | if [[ -v BKFEH_SAMPLE_COUNT ]] && checkInt "$BKFEH_SAMPLE_COUNT"; then | |
263 | sample_count="$BKFEH_SAMPLE_COUNT"; | |
264 | fi; | |
4db78240 SBS |
265 | |
266 | if [[ ! -z "$1" ]]; then | |
267 | list_paths="$1"; # newline-delimited list of file paths to sample from | |
268 | else | |
269 | yell "ERROR:NO paths available to sample."; | |
270 | fi; | |
271 | ||
272 | if [[ -d "$BKFEH_SAMPLE_DIR" ]]; then | |
273 | sample_dir="$BKFEH_SAMPLE_DIR"; | |
274 | yell "STATUS:Environment variable BKFEH_SAMPLE_DIR set. Clearing and saving samples..."; | |
275 | ||
276 | ## clear previous sample | |
277 | count_samples="$(find $BKFEH_SAMPLE_DIR -maxdepth 1 -type f | wc -l)"; | |
278 | find "$BKFEH_SAMPLE_DIR" -maxdepth 1 -type f -exec rm '{}' \; ; | |
279 | ||
280 | ## save random sample | |
281 | yell "STATUS:Saving random sample of size $sample_count to $BKFEH_SAMPLE_DIR..."; | |
282 | list_paths_sample="$(echo "$list_paths" | shuf | head -n"$sample_count")"; | |
283 | while read -r line; do | |
284 | if [[ -z "$line" ]]; then continue; fi; | |
285 | ### check size limit | |
286 | sample_act_space="$(du -bd1 "$BKFEH_SAMPLE_DIR" | cut -f1 )"; # actual used space | |
287 | cand_space="$(du -bd1 "$line" | cut -f1 )"; # size of candidate file to add | |
288 | sample_req_space="$((sample_act_space + cand_space))"; | |
289 | if [[ "$sample_req_space" -lt "$sample_max_space" ]]; then | |
290 | #### add file to sample dir | |
291 | cp -n "$line" "$BKFEH_SAMPLE_DIR" ; | |
292 | fi; | |
293 | done < <( echo "$list_paths_sample" ); | |
294 | else | |
295 | yell "ERROR:Does not exist: $BKFEH_SAMPLE_DIR"; | |
296 | fi; | |
297 | }; # save sample of files | |
298 | ||
9eaab35f SBS |
299 | main() { |
300 | # Depends: read_stdin_psarg() v0.0.1, check_depends() | |
966a8d11 | 301 | local re_dotfile; |
335b71e1 | 302 | declare -a dirs_stdin dirs_psarg; |
9eaab35f SBS |
303 | declare -a paths_images; |
304 | declare list_paths_images; | |
305 | check_depends; | |
306 | ||
335b71e1 SBS |
307 | #Populate dirs_stdin and dirs_psarg arrays |
308 | ## Read stdin as lines | |
966a8d11 | 309 | re_dotfile="^\."; # first char is a dot |
9eaab35f | 310 | while read -r line; do |
4db78240 | 311 | line="$(readlink -e "$line")"; |
966a8d11 | 312 | # Check if dir |
9eaab35f SBS |
313 | if [[ ! -d "$line" ]]; then |
314 | echo "ERROR:Not a dir:$line" 1>&2; | |
315 | continue; | |
316 | fi; | |
966a8d11 SBS |
317 | dir_name="$(basename "$line")"; |
318 | # Exclude dotdirs | |
319 | if [[ "$dir_name" =~ $re_dotfile ]]; then | |
320 | echo "ERROR:Is a dotdir:$line" 1>&2; | |
321 | continue | |
322 | fi; | |
335b71e1 SBS |
323 | dirs_stdin+=("$line"); |
324 | done < <(read_stdin); | |
325 | ## Read positional arguments as lines | |
326 | re_dotfile="^\."; # first char is a dot | |
327 | while read -r line; do | |
4db78240 | 328 | line="$(readlink -e "$line")"; |
335b71e1 SBS |
329 | # Check if dir |
330 | if [[ ! -d "$line" ]]; then | |
331 | echo "ERROR:Not a dir:$line" 1>&2; | |
332 | continue; | |
333 | fi; | |
334 | dir_name="$(basename "$line")"; | |
335 | # Exclude dotdirs | |
336 | if [[ "$dir_name" =~ $re_dotfile ]]; then | |
337 | echo "ERROR:Is a dotdir:$line" 1>&2; | |
338 | continue | |
339 | fi; | |
340 | dirs_psarg+=("$line"); | |
341 | done < <(read_psarg "$@"); | |
342 | ||
343 | # Catch all arrays empty | |
344 | if [[ "${#dirs_stdin[@]}" -le 0 ]] && [[ "${#dirs_psarg[@]}" -le 0 ]]; then | |
345 | die "FATAL:No valid directories provided."; | |
346 | fi; | |
9eaab35f SBS |
347 | |
348 | # Generate file list | |
335b71e1 SBS |
349 | # Find settings |
350 | firegex=".+\(jpg\|jpeg\|gif\|png\|webm\)$"; # update according to `find . -type f | grep -Eo "\.([[:alnum:]])+$" | sort -u` | |
351 | fsize="10k"; # default: minimum "10k" | |
352 | export firegex fsize ; # export for parallel | |
353 | ## Call find_filelist() in parallel for positional argument input | |
354 | if [[ "${#dirs_psarg[@]}" -gt 0 ]]; then | |
355 | fdepth=10; export fdepth; # 10 for dirs from positional arguments | |
356 | paths_images+=("$( parallel find_flist {} "$fdepth" "$firegex" "$fsize" ::: "${dirs_psarg[@]}" )"); # See [1] | |
357 | fi; | |
358 | ## Call find_filelist() in parallel for stdin input | |
359 | if [[ "${#dirs_stdin[@]}" -gt 0 ]]; then | |
360 | fdepth=1; export fdepth; # 1 ofr dirs from stdin | |
361 | paths_images+=("$( parallel find_flist {} "$fdepth" "$firegex" "$fsize" ::: "${dirs_stdin[@]}" )"); # See [1] | |
362 | fi; | |
363 | ||
9eaab35f SBS |
364 | # Convert paths_images array into file list |
365 | for i in "${!paths_images[@]}"; do | |
366 | list_paths_images="$(printf "%s\n%s" "${paths_images[$i]}" "$list_paths_images")"; | |
367 | ||
368 | # Get stats | |
369 | file_count="$(wc -l < <(echo -n "$list_paths_images"))"; | |
370 | echo "$DEBUG:file_count:$file_count" | |
371 | done; | |
966a8d11 SBS |
372 | |
373 | # Sort, remove duplicate paths | |
9eaab35f SBS |
374 | list_paths_images="$(echo "$list_paths_images" | sort -u | tr -s '\n')"; |
375 | ||
335b71e1 SBS |
376 | # Remove paths with dotfiles |
377 | list_paths_images="$(echo "$list_paths_images" | grep -viE "/\." )"; | |
378 | ||
9eaab35f SBS |
379 | # Write |
380 | list_paths_images_tmp="/dev/shm/$(date +%Y%m%dT%H%M%S.%N%z)"..feh_paths.txt; | |
381 | must echo -n "$list_paths_images" > "$list_paths_images_tmp"; | |
382 | ||
383 | # Print stats | |
384 | yell "STATUS:Built file list in $SECONDS seconds."; | |
385 | ||
386 | # Run feh with filelist | |
acaa0f3d SBS |
387 | feh --full-screen --auto-zoom --draw-filename --filelist "$list_paths_images_tmp" && \ |
388 | must rm "$list_paths_images_tmp" & | |
9eaab35f | 389 | |
acaa0f3d SBS |
390 | # Save sample to path in env. var. BKFEH_SAMPLE_DIR if set |
391 | save_sample "$list_paths_images"; | |
392 | ||
9eaab35f | 393 | }; |
335b71e1 | 394 | export -f yell die must read_stdin read_psarg find_flist; |
9eaab35f SBS |
395 | #==END Define local functions== |
396 | ||
397 | main "$@"; | |
398 | ||
399 | # Author: Steven Baltakatei Sandoval | |
400 | # License: GPLv3+ |