limoji

#!/bin/bash
# Limoji 1.0.1

limoji_version="1.0.1"
readonly limoji_version

# Functions for printing colored symbols to the console
printCross() {
    printf -- '[\e[1;31m✗\e[0m] \e[1;31m%b\e[0m\n' "${*}"
}

printInfo() {
    printf -- '[\e[1;93mi\e[0m] %b\n' "${*}"
}

printQuestion() {
    printf -- '\e[0m[\e[1;94m?\e[0m] %b' "${*}"
}

printTick() {
    printf -- '[\e[1;32m✓\e[0m] \e[1;32m%b\e[0m\n' "${*}"
}

# A function that prints the selected emoticon to the console
printEmoticon() {
    printTick "${1} was copied to the clipboard successfully:"
    printf -- '%b' "${!1}" | tee >(copyToClipboard)
    printf -- '%s\n' ""
}

# Print a list of all the available commands
printCmdHelp() {
cat << EOF
Usage: limoji <emoticon>
  -e, --emoticons Show a list of the available emoticons
  -h, --help      Show this list
  -i, --info      Show info about the project
  -r, --random    Print a random emoticon
  -v, --version   Display Limoji's version
  
For more information you can visit our GitHub repository:
https://github.com/GEROGIANNIS/Limoji

EOF
}

# Print info about the project
printCmdInfo() {
    printInfo \
    "Limoji is an open source tool that makes it easy to choose between
    hundreds of cool Unicode emoticons and share them with your friends,
    all done using the terminal!

    All you have to do is pick the right one or let Limoji choose it for you!
    "
}

# Print Limoji's version
printCmdVersion() {
    # Print current version
    printf -- 'Limoji %b' "${limoji_version}"

    # Don't check for new versions if curl is not installed or an argument has been passed
    if [[ $(command -v curl) && ! "$1" =~ (--no-update-check|-nu) ]]; then
        # Query GitHub's API to see if a new version is available
        latest_version=$(fetchLatestRelease "gerogiannis/limoji")

        # Compare current version against the one fetched from the API
        if [[ "$limoji_version" < "$latest_version" ]]; then
            printf -- ' (\e[1;93mUpdate available\e[0m)\n\n'
            printInfo "Limoji $latest_version is available."

            # Check if Limoji's parent directory is a git repository
            if [[ $is_git ]]; then
                printf -- '    %s\n' "Run 'git pull' to update."
            fi
        else
            printf -- ' (\e[1;32mUp to date\e[0m)\n'
        fi
    else
        printf -- '\n'
    fi
}

# Fetch latest release from GitHub
# Based on lukechilds/get_latest_release.sh
# v0.31.4
fetchLatestRelease() {
  curl --silent "https://api.github.com/repos/$1/releases/latest" | # Get latest release from GitHub API
    grep '"tag_name":' |                                            # Get tag line
    sed -E 's/.*"([^"]+)".*/\1/'                                    # Pluck JSON value
}

# Function that picks a random emoticon name
fetchRandomName() {
    # Generate a random number between 1 and unicode line count
    randomLine=$(( 2 + RANDOM % (UNICODE_LINES - 1) ))

    # Fetch emoticon's name from the selected line
    randomName=$(sed "${randomLine}q;d" "${config_path}"/unicode | cut -d= -f1)
}

# Function that picks a random emoticon
randomEmoticon() {
    local answer
    answer="y"
    # Until the user replies with something other than 'y', cycle through random emoticons
    # If the user replies with 'Y', it will be lowercased (i.e. ${var,,}) for the test
    until [[ "${answer,,}" != y ]]; do
        # Picks a random emoticon name
        fetchRandomName

        # Print the emoticon and copy it to the clipboard
        printEmoticon "${randomName}"

        # Ask the user if he wants another emoticon
        read -n 1 -r -p "$(printQuestion "Do you want another one? (y/n) ")" answer
        printf -- '%s\n' ""
    done
}

# Function that creates a list of the available emoticons
listEmoticons() {
    # Repeat for every single line
    for (( c=2; c<=UNICODE_LINES; c++ )); do
        # Read emoticon's name
        name=$(sed "${c}q;d" "${config_path}"/unicode | cut -d= -f1)

        # Print the name followed by the emoticon itself
        printf -- '%b:\n%b\n\n' "${name}" "${!name}"
    done
}

# Prints an error message on invalid input
invalidArgument() {
    printCross "Invalid argument!"
    printf -- '%s\n' "Try 'limoji --help' for a list of available commands."
}

# Attempt to figure out a clipboard handling method
setupClipboard() {
    case "${XDG_SESSION_TYPE}" in
        (x11)
            # If X11 and xclip are simultaneously present, that's a preferred option
            if command -v xclip >/dev/null 2>&1; then
                copyToClipboard() { xclip -selection c; }
                return 0
            else
                printInfo 'X11 detected'
                printCross 'xclip is required for copying text to the clipboard'
                exit 1
            fi
        ;;
        (wayland)
            # If Wayland and wl-copy are simultaneously present, that's a preferred option
            if command -v wl-copy >/dev/null 2>&1; then
                copyToClipboard() { wl-copy; }
                return 0
            # Fallback if wl-copy isn't installed
            elif command -v xclip >/dev/null 2>&1; then
                copyToClipboard() { xclip -selection c; }
                return 0
            else
                printInfo 'Wayland detected'
                printCross 'wl-clipboard is required for copying text to the clipboard'
                exit 1
            fi
        ;;
        (*)
            # If we get to this point, then it only means that XDG_SESSION_TYPE isn't set
            # We can run some more thorough heuristics to try and find a way to clipboard things
            if command -v wl-copy >/dev/null 2>&1; then
                copyToClipboard() { wl-copy; }
                return 0
            elif command -v xclip >/dev/null 2>&1; then
                copyToClipboard() { xclip -selection c; }
                return 0
            elif command -v xsel >/dev/null 2>&1; then
                copyToClipboard() { xsel --clipboard --input; }
                return 0
            elif command -v pbcopy >/dev/null 2>&1; then
                copyToClipboard() { pbcopy; }
                return 0
            else
                printCross "Your system is not supported yet, please create a new issue here:"
                printf -- '%s\n' "https://github.com/GEROGIANNIS/Limoji/issues/new/choose" >&2
                exit 1
            fi
        ;;
    esac
}

main() {
    # Fail fast checks.
    # First, if no args are given, give the invalid argument message and exit
    (( ${#} == 0 )) && { invalidArgument; exit 1; }

    # Next, try to get a clipboard working
    setupClipboard

    # Fetch all emoticons from the file
    source "${config_path}"/unicode

    # Store the number of emoticons in a variable
    UNICODE_LINES=$(wc -l < "${config_path}"/unicode)

    case "${1}" in
        (--emoticons|-e)    listEmoticons ;;
        (--help|-h)         printCmdHelp ;;
        (--info|-i)         printCmdInfo ;;
        (--random|-r)       randomEmoticon ;;
        (--version|-v)      printCmdVersion "$2" ;;
        (*[!0-9a-zA-Z]*)    invalidArgument ;;
        (*)
            # Convert all uppercase characters to lowercase
            set -- "${1,,}"

            # Check if the selected emoticon exists
            if [[ -n "${!1}" ]]; then
                printEmoticon "${1}"
            else
                printCross "The specified emoji doesn't exist!"
                printf -- '%s\n' "Try 'limoji --emoticons' for a list of available emojis."
            fi
        ;;
    esac
}

# Find Limoji's parent path
parent_path=$( cd "$(dirname "${BASH_SOURCE[0]}")" || exit ; pwd -P )

# Check if Limoji is installed and config files are located in /etc/limoji
if [[ ! -d $parent_path/.git && -d /etc/limoji ]]; then
    config_path="/etc/limoji"
# Otherwise, look for the config files in the parent directory
# A user might have deleted the .git folder, so we don't need to explicitly check for it
else
    # Set this flag for later use
    is_git=true

    # The config files are located in the parent directory
    config_path=$parent_path
fi

main "${@}"