pwb_git_log

#!/usr/bin/env bash

enable ate
enable pwb

source <( pwb_sources \
              ate_exit_on_error       \
              pwb_exit_on_error       \
              pwb_get_regions         \
              pwb_print_array         \
              pwb_printf_limited      \
              pwb_display_ate_table   \
              pwb_get_scroll_bar      \
        )

declare PWB_NAME="gl_display"
declare PWB_MARGIN_COLOR=$'\e[48;2;64;64;64m'

goto_newline() { pwb_newline_indent "$PWB_NAME"; }

clear_comrec() { comrec=( "" "" "" "" "" "" "" ); }

declare ROW_SIZE=7
declare -n commit_hash="comrec[0]"
declare -n commit_decoration="comrec[1]"
declare -n commit_author="comrec[2]"
declare -n commit_date="comrec[3]"
declare -n commit_title="comrec[4]"
declare -n commit_message="comrec[5]"
declare -n commit_merge="comrec[6]"

declare -a commit_fields=(
    hash decoration author date title message merge
)

# longest field name, 'decoration', is 10 characters
declare -i max_field_len=10

# Test to confirm clear_comrec makes the expected (ROW_SIZE) length array:
clear_comrec
if [ "${#comrec[*]}" -ne "$ROW_SIZE" ]; then
    echo "Comrec array size must match ROW_SIZE constant."
    exit
fi

declare -a re_commit_array=(
    ^
    commit
    [[:space:]]
    \(                # capture group #1 for commit hash value
       [[:xdigit:]]+
    \)
    \(                # conditional group #2 of optional decoration
       [[:space:]]*
       \\\(           # match opening raw parenthesis
       \(             # capture group #3 for contents of decoration
          [^)]+    # capture to close raw parentesis
       \)
       \\\)
    \)?               # end of conditional group #2
    $
)

declare OIFS="$IFS"
IFS=''
declare re_commit="${re_commit_array[*]}"
IFS="$OIFS"
unset OIFS

scan_git_log()
{
    local tname="$1"

    # Confirm appropriate configuration
    ate get_row_size "$tname" -v row_size
    ate_exit_on_error
    if [ "$row_size" -lt "$ROW_SIZE" ]; then
        echo "Invalid row size of $row_size should be $ROW_SIZE"
        exit
    fi

    local -a git_log_args=(
        --no-pager
        log
        --date=iso-strict
        --pretty=medium
        --decorate=full
    )

    if [ "$#" -gt  1 ]; then
        git_log_args+=( --follow -- "$2" )
    fi

    local OIFS="$IFS"
    local IFS=$' '

    # Directly use hosted array
    ate get_array_name "$tname" -v aname
    ate_exit_on_error
    local -n sgl_array="$aname"

    local -i text_state=0
    local curline
    local -a text_block=()
    local -i commit_count=0
    local -i commit_count_predicted=$( git rev-list --count --all )

    local -a comrec
    clear_comrec

    while IFS= read -r curline; do
        if [[ "$curline" =~ ^[[:space:]]+([^[:space:]].*) ]]; then
            text_block+=( "${BASH_REMATCH[1]}" )
        elif [[ "$curline" =~ $re_commit ]]; then
            # If currec has contents, save and clear it:
            if [ -n "$commit_hash" ]; then
                if [ "${#text_block[*]}" -ne 0 ]; then
                    commit_message="${text_block[*]}"
                fi

                if (( ++commit_count % 100 == 0 )); then
                    printf $'\e[2K\e[1G%4d commits out of %4d expected, (%d%%)' \
                           "$commit_count" \
                           "$commit_count_predicted" \
                           $(( (commit_count * 100) / commit_count_predicted ))
                fi
                sgl_array+=( "${comrec[@]}" )
                text_state=0
                clear_comrec
            fi
            text_block=()
            text_state=0
            # Start next commit record
            commit_hash="${BASH_REMATCH[1]}"
            commit_decoration="${BASH_REMATCH[3]}"
        elif [[ "$curline" =~ ^Author:\ +([^\)]+)$ ]]; then
            commit_author="${BASH_REMATCH[1]}"
        elif [[ "$curline" =~ ^Date:\ *([^\)]+)$ ]]; then
            commit_date="${BASH_REMATCH[1]}"
            elif [[ "$curline" =~ ^Merge:\ +([^\)]+)$ ]]; then
            commit_merge="${BASH_REMATCH[1]}"
        elif [[ "$curline" =~ ^[[:space:]]*$ ]]; then
            (( ++text_state ))
            if (( text_state == 2 )); then
                commit_title="${text_block[*]}"
                text_block=()
            elif (( text_state > 2 )); then
                text_block+=( $'\nBOO\n' )
            fi
        fi
    done < <( git "${git_log_args[@]}" )

    # Save final commit record, not followed by a "commit" line
    if [ -n "$commit_hash" ]; then
        if [ "${#text_block[*]}" -ne 0 ]; then
            if [ "$text_state" -lt 2 ]; then
                commit_title="${text_block[*]}"
            else
                commit_message="${text_block[*]}"
            fi
        fi
        sgl_array+=( "${comrec[@]}" )
        clear_comrec
    fi

    printf $'\e[2K\e[1G'
    ate index_rows "$tname"
    ate_exit_on_error
}

get_constrained_line()
{
    local -n gcl_line="$1"
    local -i constraint="$2"
    local -n gcl_text="$3"
    local -n gcl_progress="$4"

    return 1
}

gl_print_formatted_rec()
{
    local -a comrec="$1"
    local -i screen_cols="$2"

    printf $'\e[2J'

    declare -i line_width="80"
    declare -i left_margin=$(( (screen_cols - line_width) / 2 ))
    declare -i data_margin=$(( max_field_len + left_margin + 2 ))
    declare -i text_len=$(( line_width - max_field_len - 2 ))

    declare format_field
    printf -v format_field $'\e[1B\e[%dG%%s: ' "$left_margin"

    declare format_text_cont
    printf -v format_text_cont $'%%s\e[1B\e[%dG' "$data_margin"

    local -i index max_index="${#commit_fields[*]}"
    for (( index=0; index<max_index; ++index )); do
        local value="${comrec[$index]}"
        if [ -n "$value" ]; then
            printf "$format_field" "${commit_fields[$index]}"

            local line
            local -i progress=0
            while get_constrained_line line "$value" progress; do
                printf "$format_text_cont" "$line"
            done
        fi
    done

    read -n1 -p "Press any key to return"
}

gl_show_commit()
{
    local -i index="$2"
    local dsource="$3"
    local pwb_handle="$4"

    local -a comrec
    ate get_row "$dsource" "$index" -a comrec
    ate_exit_on_error

    local termapp="$TERM"

    x-terminal-emulator -e git -p show "$commit_hash" | less -R

    # printf $'\e[2J'
    # printf $'\e[1;1H'

    # git -p show "$commit_hash" | less -R

    # printf $'\e[2J'
    pwb print_all "$pwb_handle"
    pwb_exit_on_error

    return 0
}

###########################
### PWB Print Functions ###
###########################

gl_print_line()
{
    local -i index="$1"
    local tname="$2"
    local -i char_count="$3"

    local -a comrec

    ate get_row "$tname" "$index" -a comrec
    ate_exit_on_error

    if [ -n "$commit_decoration" ]; then
        printf $'\e[35;1m'
    fi

    pwb_printf_limited "$char_count"         \
                       "%s (%s): %-s"        \
                       "${commit_date:0:10}" \
                       "${commit_hash:0:8}"  \
                       "${commit_title}"

    if [ -n "$commit_decoration" ]; then
        printf $'\e[39m'
    fi
}

gl_print_top()
{
    local -i index="$1"
    local tname="$2"
    local -i char_count="$3"
    local pwb_handle="$5"

    local -a comrec

    ate get_row "$tname" "$index" -a comrec
    ate_exit_on_error

    local -i dindex=0
    local -a dlines
    printf -v dlines[$(( dindex++ ))] "%s %s" "${commit_data:1:10}" "$commit_hash"
    printf -v dlines[$(( dindex++ ))] "     Title: %s" "$commit_title"
    printf -v dlines[$(( dindex++ ))] "    Author: %s" "$commit_author"
    if [ -n "$commit_merge" ]; then
        printf -v dlines[$(( dindex++ ))]"     Merge: %s" "$commit_merge"
    fi
    if [ -n "$commit_decoration" ]; then
        printf -v dlines[$(( dindex++ ))] "Decoration: %s" "$commit_decoration"
    fi

    printf "$PWB_MARGIN_COLOR"

    pwb_print_array dlines \
                    -t "${GL_REGIONS[TM_TOP]}" \
                    -l "${GL_REGIONS[TM_LEFT]}" \
                    -w "${GL_REGIONS[TM_WIDE]}" \
                    -c "${GL_REGIONS[TM_LINES]}"

    printf $'\e[m'
}

exit_trap() { pwb restore; }

#######################
### BEGIN EXECUTION ###
#######################

# Exit quickly if we detect that git not initiated
if ! git status >/dev/null 2>&1; then
    echo "Git not configured here, '$PWD'"
    exit
fi

declare GL_TABLE
ate declare GL_TABLE "$ROW_SIZE"
ate_exit_on_error

# Built conditional argument list
declare -a scan_log_args=(
    GL_TABLE
)
# If provided, add a path to the arguments list:
if [ "$#" -gt 0 ]; then
    scan_log_args+=( "$1" )
fi

scan_git_log "${scan_log_args[@]}"
ate get_row_count GL_TABLE -v row_count
ate_exit_on_error

declare -a disp_args=(
    GL_TABLE
    "$row_count"
    gl_print_line
    -e gl_show_commit
    -t gl_print_top
)

declare PWB_HANDLE
pwb declare PWB_HANDLE "${disp_args[@]}"
pwb_exit_on_error
pwb set_margins PWB_HANDLE 5 4 2
pwb_exit_on_error

# After margins are set, the region dimensions can be calculated
declare -A GL_REGIONS
pwb_get_regions GL_REGIONS PWB_HANDLE

trap exit_trap EXIT SIGINT SIGABRT 

pwb init

# pwb_display_ate_table gl_table
pwb start PWB_HANDLE
pwb_exit_on_error