flees/code/templates/flip

#!/bin/bash

set -e
_help() {
  SELF=$( basename "$0" )
  echo "Flees Clipboard  v.{{ version }}

  Usage: $SELF [command] [name] [filename]

  Commands:
    (l)ist     [default] List names of clipboards
    (r)ead     Read from clipboard, write to stdout or file
    (w)rite    Save to clipboard, read from stdin/file/folder
    (d)elete   Delete an entry
    url        Get the direct share url
    upload     Get URL for uploads [no arguments]
    update     Update flip client [no arguments]
    self       Get URL to install this client to another computer
    autocomplete  Get Bash autocompletion script

  Name: Any string for the clipboard name. default: 0

  Filename:
    When reading from clipboard:
      File or folder to write the clipboard contents. If omitted: stdout
    When writing to clipboard:
      File or folder to read from. If omitted: stdin

  Shorthand:
    echo my data | $SELF 1  # writes data with name: 1
    $SELF 1 | cat - # prints the contents of file: 1
    $SELF w file.ext # sends file keeping its name

  Config:
    set: FLEES_ROOTURL, FLEES_SHARE, FLEES_TOKEN
"
  exit
}


_load_config() {
  FLEES_SHARE="${FLEES_SHARE:-{{ name }}}"
  FLEES_TOKEN="${FLEES_TOKEN:-{{ token }}}"
  FLEES_ROOTURL="${FLEES_ROOTURL:-{{ rooturl }}}"
}

_update_client() {
  [[ -n "$FLEES_TOKEN" ]] && [[ -n "$FLEES_SHARE" ]] && {
      sharetoken="/$FLEES_SHARE/$FLEES_TOKEN"
  }
  curl -fLo "$0" "$FLEES_ROOTURL/script/flip$sharetoken"
  err=$?
  chmod +x "$0"
  exit $err
}

_list() {
  curl -s "$FLEES_ROOTURL/file/ls/$FLEES_SHARE/$FLEES_TOKEN"
  printf "\n"
}

_simple_list() {
  curl -s "$FLEES_ROOTURL/file/list/$FLEES_SHARE/$FLEES_TOKEN"
  printf "\n"
}

_write() {
  # no file mentioned, use the name as file
  [[ -z "$FILE" ]] && {
      [[ -e "$NAME" ]] && {
          # NAME is actually the file, reverse roles
          FILE="$NAME"
          NAME=$( basename "$NAME" )
      }
  }
  # stdin is open, use stdin
  [ -t 0 ] || stream_in=1

  [ -t 0 ] && [[ -z "$FILE" ]] && {
    _msg File to read needed, or use stdin
    exit 1
  }
  _msg "Writing $NAME"
  [[ "$stream_in" -eq 1 ]] && {
    _write_stdin "$NAME"
  } || {
    [[ -d "$FILE" ]] && {
      [[ "${NAME,,}" = *".tar" ]] || NAME="${NAME}".tar
      _write_folder "$NAME" "$FILE"
    } || {
      _write_file "$NAME" "$FILE"
    }
  }
}

_write_folder() { # name, file
  tar c "$2" | curl -F "file=@-;filename=$1" "${FLEES_ROOTURL}upload/${FLEES_SHARE}/${FLEES_TOKEN}" | cat -
}
_write_file() { # name, file
  curl -F "file=@$2;filename=$1" "${FLEES_ROOTURL}upload/${FLEES_SHARE}/${FLEES_TOKEN}" | cat -
}
_write_stdin() { # name
  cat - | curl -F "file=@-;filename=$1" "${FLEES_ROOTURL}upload/${FLEES_SHARE}/${FLEES_TOKEN}"
}

_read() {
  [[ -z "$FILE" ]] && stream_out=1
  [ -t 1 ] || stream_out=1

  [[ "$stream_out" -eq 1 ]] && {
    _read_stdout "$NAME"
  } || {
    _read_file "$NAME" "$FILE"
  }
}

_read_file() { # name, file
  curl "$FLEES_ROOTURL/download/$FLEES_SHARE/$FLEES_TOKEN/$1" -o "$2"
}
_read_stdout() { # name
  curl -s "$FLEES_ROOTURL/download/$FLEES_SHARE/$FLEES_TOKEN/$1"
}

_delete() { # name
  read -p "Sure to delete: $1 ? Break to exit " foo
  exitcode=$( curl -s "$FLEES_ROOTURL/file/delete/$FLEES_SHARE/$FLEES_TOKEN/$1" )
  if [[ ! "$exitcode" = "OK" ]]; then
    echo "Failed deletion"
  fi
}

_url() { # name
  curl -s "$FLEES_ROOTURL/file/direct/$FLEES_SHARE/$FLEES_TOKEN/$1"
  echo ''
}
_upload_url() {
  echo "This information is a security risk, watch where it's shared"
  echo "# python2 <( curl -s $FLEES_ROOTURL/script/upload_split/$FLEES_SHARE/$FLEES_TOKEN ) file_to_upload.ext"
  exit
}
_self_url() {
  SELF=$( basename "$0" )
  echo "This information is a security risk, watch where it's shared!"
  echo ""
  echo "# curl -fLo $SELF $FLEES_ROOTURL/script/flip/$FLEES_SHARE/$FLEES_TOKEN && chmod +x $SELF"
  exit
}
_msg() {
    echo "$@" >&2
}

_get_name() {
    [[ "$ARG1" = "$CMD" ]] && {
        NAME="$ARG2"
    } || {
        NAME="$ARG1"
    }
    [[ -z "$NAME" ]] && [[ ! "$CMD" = delete ]] && NAME=0
    return 0
}

_get_file() {
    [[ "$ARG1" = "$NAME" ]] && {
        FILE="$ARG2"
    }
    [[ "$ARG2" = "$NAME" ]] && {
        FILE="$ARG3"
    }
    return 0
}

_get_completer() {
  self=$( basename $( readlink -f "$0" ) )
  echo '_FLIP_EXEC_complete() {
local curr_arg
curr_arg=${COMP_WORDS[COMP_CWORD]}
if [[ $COMP_CWORD -eq 1 ]]; then
  COMPREPLY=( $(compgen -W "help autocomplete list read write delete url update upload self" -- $curr_arg ) );
fi
if [[ $COMP_CWORD -eq 2 ]]; then
  case ${COMP_WORDS[$(( $COMP_CWORD - 1 ))]} in
    r*|url|d*)
      local remotelist=$( eval FLIP_EXEC simplelist )
      COMPREPLY=( $(compgen -W "$remotelist" -- $curr_arg ) );
    ;;
    w*)
      COMPREPLY=( $(compgen -f -d -- $curr_arg ) );
    ;;
  esac
fi
if [[ $COMP_CWORD -eq 3 ]]; then
  COMPREPLY=( $(compgen -f -d -- $curr_arg ) );
fi
}
complete -F _FLIP_EXEC_complete FLIP_EXEC
# Run me as: source <( FLIP_EXEC autocomplete )
' | sed "s,FLIP_EXEC,$self,g"
  exit 0
}

_load_config
for (( i=1; i<=$#; i++ )); do
  [[ "${!i}" = "-h" ]] && _help
  [[ "${!i}" = "--help" ]] && _help
done

ARG1="$1"
ARG2="$2"
ARG3="$3"
CMD=list
# if stdout redirected, default to read
[ -t 1 ] || CMD=read
# if stdin comes from stream, default to write
[ -t 0 ] || CMD=write

[[ "$1" = "r" || "$1" = "read" ]] && { CMD=read; ARG1=$CMD; }
[[ "$1" = "w" || "$1" = "write" ]] && { CMD=write; ARG1=$CMD; }
[[ "$1" = "d" || "$1" = "delete" || "$1" = "del" ]] && { CMD=delete; ARG1=$CMD; }
[[ "$1" = "l" || "$1" = "list" ]] && { CMD=list; ARG1=$CMD; }
[[ "$1" = "simplelist" ]] && { CMD=simple_list; ARG1=$CMD; }
[[ "$1" = "autocomplete" ]] && { _get_completer; }
[[ "$1" = "url" ]] && { CMD=url; ARG1=$CMD; }
[[ "$1" = "update" ]] && { _update_client; }
[[ "$1" = "upload" ]] && { _upload_url; }
[[ "$1" = "self" ]] && { _self_url; }
[[ "$1" = "h" || "$1" = "help" ]] && _help

[[ "$CMD" = list ]] && {
    _list
    exit $?
}

[[ "$CMD" = simple_list ]] && {
    _simple_list
    exit $?
}

_get_name
_get_file
[[ "$CMD" = read ]] && {
    _read
    exit $?
}
[[ "$CMD" = delete ]] && {
    _delete "$NAME"
    exit $?
}
[[ "$CMD" = write ]] && {
    _write
    exit $?
}
[[ "$CMD" = url ]] && {
    _url "$NAME"
    exit $?
}