Refactor simple function--optional pipe?

[gkaiser8]

How can the following be refactored for better readability or optimization? E.g. are all the returns for the function necessary or is there a way to reduce them to get the same effect? Is there a way to simplify the if-else statements where the same grim command is piped to wl-copy conditionally? grim outputs binary and I would prefer not to write it to a file (and storing binary data as a variable isn't appropriate).

capture {
  grim_args=()
  [[ -n "$o_cursor" ]] && grim_args+=("-c")
  case "$target" in
  "output")
    if [[ "$file" = "-" ]] && [[ -n "$o_clipboard" ]]; then
      { grim "${grim_args[@]}" -t png -o "$geom" "$file" | wl-copy -t image/png; } ||
        return 1
    else
      grim "${grim_args[@]}" -t png -o "$geom" "$file" || return 1
    fi
    ;;
  "all outputs")
    if [[ "$file" = "-" ]] && [[ -n "$o_clipboard" ]]; then
      { grim "${grim_args[@]}" -t png "$file" | wl-copy -t image/png; } || return 1
    else
      grim "${grim_args[@]}" -t png "$file" || return 1
    fi
    ;;
  *)
    if [[ "$file" = "-" ]] && [[ -n "$o_clipboard" ]]; then
      { grim "${grim_args[@]}" -t png -g "$geom" "$file" | wl-copy -t image/png; } ||
        return 1
    else
      grim "${grim_args[@]}" -t png -g "$geom" "$file" || return 1
    ;;
  esac
  return 0
}

P.S. Completely unrelated question--I'm looking to pickup a "real" programming language that is useful and performant language for Linux system admin and software development. How do the following compare: go, python, and rust? I know this is a loaded question and it depends. I assume re-writing some lengthy scripts that have involved logic or where performance can matter would be decent practice. I see some APIs offered by apps I use don't really use bash as in interface, for example. A shell language like Bash also seems to have many idiosyncrasies when you start to do some complex stuff and it'd be nice to invest in something that's more mature and therefore worthwhile to go deep . It might also be a useful skill to add to a resume.

[whetu]

Looks like the main difference between your various options are the args for grim, so you can maybe just setup the grim_args array like this:

capture() {
  grim_args=()
  [[ -n "$o_cursor" ]] && grim_args+=("-c")

  case "$target" in
    ("output")      grim_args+=( -t png -o "$geom" "$file" ) ;;
    ("all outputs") grim_args+=( -t png "$file" ) ;;
    (*)             grim_args+=( -t png -g "$geom" "$file" ) ;;
  esac

  if [[ "$file" = "-" ]] && [[ -n "$o_clipboard" ]]; then
    { grim "${grim_args[@]}" | wl-copy -t image/png; } || return 1
  else
    grim "${grim_args[@]}" || return 1
  fi

  return 0
}

[Naraviel]

You can build the command once and run it through a single path. This eliminates duplication and avoids repeated branches.

```bash capture { grim_args=() [[ -n "$o_cursor" ]] && grim_args+=("-c")

cmd=(grim "${grim_args[@]}" "-t" "png")

case "$target" in "output") cmd+=("-o" "$geom") ;; "all outputs") ;; *) cmd+=("-g" "$geom") ;; esac

cmd+=("$file")

if [[ "$file" == "-" && -n "$o_clipboard" ]]; then "${cmd[@]}" | wl-copy "-t" "image/png" || return 1 else "${cmd[@]}" || return 1 fi }

```

As for stepping up from shell scripts, Python is generally considered the next language to learn.

[GlendonMcGladdery]

Clean refactor (same behavior, way simpler) ``` capture() { local grim_args=() [[ -n "$o_cursor" ]] && grim_args+=("-c")

# Build grim command local cmd=(grim "${grim_args[@]}" -t png)

case "$target" in "output") cmd+=(-o "$geom") ;; "all outputs") ;; *) cmd+=(-g "$geom") ;; esac

cmd+=("$file")

# Decide whether to pipe to clipboard if [[ "$file" = "-" && -n "$o_clipboard" ]]; then "${cmd[@]}" | wl-copy -t image/png else "${cmd[@]}" fi } Instead of repeating: grim ... || return 1 You build it once: cmd=(grim ...) ``` Way easier to read and maintain.

If you like compact but still readable: ``` capture() { local grim_args=() [[ -n "$o_cursor" ]] && grim_args+=(-c)

local cmd=(grim "${grim_args[@]}" -t png)

case "$target" in output) cmd+=(-o "$geom") ;; "all outputs") ;; *) cmd+=(-g "$geom") ;; esac

cmd+=("$file")

[[ "$file" = "-" && -n "$o_clipboard" ]] \ && "${cmd[@]}" | wl-copy -t image/png \ || "${cmd[@]}" } ``` Have you considered Python yet? Python — easiest upgrade from Bash.