1603 lines
49 KiB
Bash
1603 lines
49 KiB
Bash
# blesh/contrib/histdb (C) 2023, Koichi Murase <myoga.murase@gmail.com>
|
|
|
|
ble/util/assign _ble_histdb_sqlite3 'builtin type -P sqlite3 2>/dev/null'
|
|
if [[ ! -x $_ble_histdb_sqlite3 ]]; then
|
|
ble/util/print 'contrib/histdb: "sqlite3" is required for this module.' >&2
|
|
return 1
|
|
fi
|
|
|
|
ble-import util.bgproc
|
|
|
|
_ble_histdb_version=3
|
|
|
|
#------------------------------------------------------------------------------
|
|
# histdb_remarks
|
|
|
|
bleopt/declare -v histdb_remarks 'git: \q{contrib/histdb-remarks-git}'
|
|
|
|
_ble_histdb_remarks_data=()
|
|
function ble/prompt/unit:_ble_histdb_remarks/update {
|
|
ble/prompt/unit/add-hash '$bleopt_histdb_remarks'
|
|
ble/prompt/unit:{section}/update _ble_histdb_remarks "$bleopt_histdb_remarks" no-trace
|
|
}
|
|
|
|
## @fn ble/histdb/.get-remarks
|
|
## @var[out] remarks
|
|
function ble/histdb/.get-remarks {
|
|
remarks=
|
|
if [[ $bleopt_histdb_remarks ]]; then
|
|
local ret
|
|
ble/prompt/unit#update _ble_histdb_remarks "$bleopt_histdb_remarks"
|
|
ble/prompt/unit:{section}/get _ble_histdb_remarks
|
|
remarks=$ret
|
|
fi
|
|
}
|
|
|
|
function ble/prompt/backslash:contrib/histdb-remarks-git {
|
|
ble-import prompt-git
|
|
|
|
function ble/prompt/backslash:contrib/histdb-remarks-git {
|
|
local "${_ble_contrib_prompt_git_vars[@]/%/=}" # WA #D1570 checked
|
|
ble/contrib/prompt-git/initialize || return 0
|
|
ble/contrib/prompt-git/update-head-information
|
|
local state; ble/contrib/prompt-git/get-state
|
|
local dirty_mark; ble/contrib/prompt-git/get-dirty-mark
|
|
|
|
local path=${git_base%.git}
|
|
path=${path%/}
|
|
path=${path##*?/}
|
|
[[ $PWD == "$git_base"/?* ]] &&
|
|
path="$path/${PWD#$git_base/}"
|
|
|
|
ble/prompt/print "git: ${branch:-(detached)} ${hash:-(orphan)}$dirty_mark${state:+ $state} @ ${path:-/}"
|
|
} && "$FUNCNAME"
|
|
}
|
|
|
|
#------------------------------------------------------------------------------
|
|
# background sqlite3 process
|
|
|
|
bleopt/declare -v histdb_ignore ''
|
|
bleopt/declare -v histdb_file ''
|
|
|
|
function ble/histdb/.get-filename {
|
|
local basename=${bleopt_histdb_file%.sqlite3}
|
|
local hostname=${HOSTNAME:-$_ble_base_env_HOSTNAME}
|
|
hostname=${hostname//'/'/'%'} # filename cannot contian /
|
|
ret=${basename:-$_ble_base_state/history}${hostname:+@$hostname}.sqlite3
|
|
}
|
|
|
|
## @var _ble_histdb_file
|
|
_ble_histdb_file=
|
|
|
|
## @arr _ble_histdb_bgproc=(fd_response fd_request - bgpid)
|
|
##
|
|
_ble_histdb_bgproc=()
|
|
_ble_histdb_bgproc_fname=()
|
|
_ble_histdb_timeout=5000
|
|
_ble_histdb_keepalive=1800 # sec
|
|
|
|
function ble/histdb/escape-for-sqlite-glob {
|
|
ret=$1
|
|
if [[ $ret == *["[*?"]* ]]; then
|
|
local a b
|
|
for a in '[' '*' '?'; do
|
|
b=[$a] ret=${ret//"$a"/"$b"}
|
|
done
|
|
fi
|
|
}
|
|
|
|
function ble/histdb/sqlite3.flush {
|
|
if [[ ${_ble_histdb_bgproc[0]} && _ble_bash -ge 40000 ]]; then
|
|
local line IFS=
|
|
ble/bash/read-timeout 0.001 -r -d '' line <&"${_ble_histdb_bgproc[0]}"
|
|
fi
|
|
}
|
|
function ble/histdb/sqlite3.request {
|
|
ble/histdb/sqlite3.open
|
|
if [[ ${_ble_histdb_bgproc[1]} ]]; then
|
|
ble/histdb/sqlite3.flush
|
|
ble/util/print "$1" >&"${_ble_histdb_bgproc[1]}"
|
|
else
|
|
[[ $1 == .exit ]] && return 0
|
|
"$_ble_histdb_sqlite3" -quote "$_ble_histdb_file" ".timeout $_ble_histdb_timeout" "$1"
|
|
fi
|
|
}
|
|
|
|
function ble/histdb/read-single-value {
|
|
local line nl=$'\n' q=\' qq=\'\' Q="'\''"
|
|
local IFS=
|
|
if ble/bash/read line && [[ $line == \'* ]]; then
|
|
local out=$line ext=0
|
|
while ((ext==0)) && ! ble/string#match "$out" '^'"$q"'([^'\'']|'"$qq"')*'"$q"'$'; do
|
|
ble/bash/read line; ext=$?
|
|
out=$out$nl$line
|
|
done
|
|
line=$out
|
|
fi
|
|
line=${line#$q}
|
|
line=${line%$q}
|
|
line=${line//$qq/$q}
|
|
line=$q${line//$q/$Q}$q
|
|
ble/util/print "ret=$line"
|
|
}
|
|
|
|
function ble/histdb/sqlite3.request-single-value {
|
|
local query=$1 opts=$2
|
|
ble/histdb/sqlite3.open
|
|
if [[ ${_ble_histdb_bgproc[1]} && _ble_bash -ge 40000 ]]; then
|
|
ble/histdb/sqlite3.flush
|
|
ble/util/print "$query" >&"${_ble_histdb_bgproc[1]}"
|
|
|
|
local sync_command='ble/histdb/read-single-value <&"${_ble_histdb_bgproc[0]}"'
|
|
local sync_condition='((sync_elapsed<200)) || ! ble/complete/check-cancel'
|
|
local sync_opts=progressive-weight
|
|
[[ :$opts: == *:auto:* && $bleopt_complete_timeout_auto ]] &&
|
|
sync_opts=$sync_opts:timeout=$((bleopt_complete_timeout_auto))
|
|
ble/util/assign ret 'ble/util/conditional-sync "$sync_command" "$sync_condition" "" "$sync_opts"' &>/dev/null; local ext=$?
|
|
builtin eval -- "$ret"
|
|
((ext==142)) && ext=148
|
|
return "$ext"
|
|
else
|
|
local out q=\' qq=\'\'
|
|
ble/util/assign out '"$_ble_histdb_sqlite3" -quote "$_ble_histdb_file" ".timeout $_ble_histdb_timeout" "$query"'
|
|
out=${out#$q}
|
|
out=${out%$q}
|
|
ret=${out//$qq/$q}
|
|
fi
|
|
}
|
|
|
|
function ble/histdb/sqlite3.proc {
|
|
exec "$_ble_histdb_sqlite3" -quote -cmd "-- [ble: $BLE_SESSION_ID]" "$_ble_histdb_file"
|
|
}
|
|
|
|
_ble_histdb_keepalive_enabled=
|
|
ble/is-function ble/util/idle.push &&
|
|
_ble_histdb_keepalive_enabled=1
|
|
|
|
## @fn ble/histdb/sqlite3.open
|
|
## @var[ref] _ble_histdb_file
|
|
## @arr[out] _ble_histdb_bgproc
|
|
## @arr[out] _ble_histdb_bgproc_fname
|
|
function ble/histdb/sqlite3.open {
|
|
if [[ $_ble_histdb_file ]]; then
|
|
# background process に依らないモードの時は OK
|
|
ble/util/bgproc#opened _ble_histdb || return 0
|
|
|
|
ble/util/bgproc#alive _ble_histdb; local state=$?
|
|
if ((state==0)); then
|
|
ble/util/bgproc#keepalive _ble_histdb
|
|
return 0
|
|
else
|
|
if ((state==3)); then
|
|
# background process が死んでいる時は再度開き直す。
|
|
ble/util/print 'histdb: background sqlite3 is inactive.' >&2
|
|
fi
|
|
ble/util/bgproc#start _ble_histdb
|
|
return "$?"
|
|
fi
|
|
fi
|
|
|
|
local ret; ble/histdb/.get-filename
|
|
_ble_histdb_file=$ret
|
|
|
|
local session_id=$_ble_base_session
|
|
local start_time=${session_id%%/*}
|
|
|
|
IFS=, builtin eval 'local groups="${GROUPS[*]}"'
|
|
local user=${USER:-$_ble_base_env_USER}
|
|
local hostname=${HOSTNAME:-$_ble_base_env_HOSTNAME}
|
|
|
|
local screen_info= ssh_info=
|
|
[[ $STY ]] && screen_info="$STY $WINDOW"
|
|
[[ $SSH_TTY ]] && ssh_info="$SSH_TTY $SSH_CONNECTION"
|
|
|
|
local bgproc_opts=owner-close-on-unload:kill-timeout=60000
|
|
[[ $_ble_histdb_keepalive_enabled ]] &&
|
|
bgproc_opts=$bgproc_opts:timeout=$((_ble_histdb_keepalive*1000))
|
|
if ble/util/bgproc#open _ble_histdb ble/histdb/sqlite3.proc "$bgproc_opts"; (($?!=0&&$?!=3)); then
|
|
# Note: システムが元々サポートしていない場合 ($? == 3) はエラーメッセージは
|
|
# 出さない。
|
|
local msg='[ble histdb: background sqlite3 failed to start]'
|
|
ble/util/print "${_ble_term_setaf[9]}$msg$_ble_term_sgr0" >&2
|
|
fi
|
|
|
|
local ret q=\' qq=\'\'
|
|
ble/histdb/sqlite3.request-single-value "
|
|
BEGIN IMMEDIATE TRANSACTION;
|
|
CREATE TABLE IF NOT EXISTS misc(key TEXT PRIMARY KEY, value INTEGER);
|
|
INSERT OR IGNORE INTO misc values('version', $_ble_histdb_version);
|
|
CREATE TABLE IF NOT EXISTS sessions(
|
|
session_id TEXT PRIMARY KEY, pid INTEGER, ppid INTEGER,
|
|
hostname TEXT, user TEXT, uid INTEGER, euid INTEGER, groups TEXT,
|
|
start_time INTEGER, start_wd TEXT,
|
|
bash_path TEXT, bash_version TEXT, shlvl INTEGER,
|
|
blesh_path TEXT, blesh_version TEXT,
|
|
term TEXT, lang TEXT, display TEXT, screen_info TEXT, ssh_info TEXT,
|
|
tty TEXT, last_time INTEGER, last_wd TEXT);
|
|
CREATE TABLE IF NOT EXISTS command_history(
|
|
session_id TEXT, command_id INTEGER,
|
|
lineno INTEGER, history_index INTEGER,
|
|
command TEXT, cwd TEXT, inode INTEGER, issue_time INTEGER,
|
|
status INTEGER,
|
|
pipestatus TEXT,
|
|
lastarg TEXT,
|
|
bgpid INTEGER,
|
|
exec_time INTEGER,
|
|
exec_time_beg INTEGER,
|
|
exec_time_end INTEGER,
|
|
exec_time_real INTEGER,
|
|
exec_time_usr INTEGER,
|
|
exec_time_sys INTEGER,
|
|
exec_time_cpu INTEGER,
|
|
exec_time_usr_self INTEGER,
|
|
exec_time_sys_self INTEGER,
|
|
exec_time_usr_chld INTEGER,
|
|
exec_time_sys_chld INTEGER,
|
|
remarks TEXT,
|
|
PRIMARY KEY (session_id, command_id));
|
|
CREATE TABLE IF NOT EXISTS words(
|
|
word TEXT PRIMARY KEY, count INTEGER, ctime INTEGER, mtime INTEGER);
|
|
INSERT OR IGNORE INTO
|
|
sessions(
|
|
session_id, pid, ppid,
|
|
hostname, user, uid, euid, groups,
|
|
start_time, start_wd,
|
|
bash_path, bash_version, shlvl,
|
|
blesh_path, blesh_version,
|
|
term, lang, display, screen_info, ssh_info,
|
|
tty)
|
|
VALUES(
|
|
'${session_id//$q/$qq}', '${$//$q/$qq}', '${PPID//$q/$qq}',
|
|
'${hostname//$q/$q}', '${user//$q/$qq}', '${UID//$q/$qq}', '${EUID/$q/$qq}', '${groups//$q/$qq}',
|
|
'${start_time//$q/$qq}', '${PWD//$q/$qq}',
|
|
'${BASH//$q/$qq}', '${BASH_VERSION//$q/$qq}', '${SHLVL//$q/$qq}',
|
|
'${_ble_base_blesh//$q/$qq}', '${BLE_VERSION//$q/$qq}',
|
|
'${TERM//$q/$qq}', '${LANG//$q/$qq}', '${DISPLAY//$q/$qq}', '${screen_info//$q/$qq}', '${ssh_info//$q/$qq}',
|
|
'${_ble_prompt_const_l//$q/$qq}');
|
|
COMMIT;
|
|
SELECT VALUE FROM misc WHERE key = 'version';"
|
|
local version=$ret
|
|
|
|
if [[ $version ]] && ((version<_ble_histdb_version)); then
|
|
local query=
|
|
((version<2)) &&
|
|
query=$query$_ble_term_nl"ALTER TABLE command_history ADD COLUMN inode INTEGER;"
|
|
((version<3)) &&
|
|
query=$query$_ble_term_nl"ALTER TABLE command_history ADD COLUMN remarks TEXT;"
|
|
query=$query$_ble_term_nl"UPDATE misc SET value = $_ble_histdb_version WHERE key = 'version';"
|
|
ble/histdb/sqlite3.request "$query"
|
|
fi
|
|
}
|
|
|
|
function ble/util/bgproc/onstart:_ble_histdb {
|
|
ble/util/bgproc#post _ble_histdb ".timeout $_ble_histdb_timeout"
|
|
}
|
|
|
|
function ble/util/bgproc/onstop:_ble_histdb {
|
|
ble/util/bgproc#post _ble_histdb '.exit'
|
|
}
|
|
|
|
function ble/histdb/sqlite3.close {
|
|
[[ $_ble_histdb_file ]] || return 0
|
|
local session_id=$_ble_base_session ret
|
|
ble/util/time; local time=$ret
|
|
ble/histdb/sqlite3.request "
|
|
UPDATE sessions SET
|
|
last_time = '${time//$q/$qq}',
|
|
last_wd = '${PWD//$q/$qq}'
|
|
WHERE session_id = '${session_id//$q/$qq}';"
|
|
|
|
ble/util/bgproc#close _ble_histdb
|
|
_ble_histdb_file=
|
|
}
|
|
|
|
_ble_histdb_exec_ignore=()
|
|
_ble_histdb_exec_cwd=
|
|
_ble_histdb_exec_cwd_inode=
|
|
|
|
function ble/histdb/update-cwd-inode {
|
|
[[ $PWD == "$_ble_histdb_exec_cwd" ]] && return 0
|
|
|
|
_ble_histdb_exec_cwd=$PWD
|
|
_ble_histdb_exec_cwd_inode=
|
|
if local ret; ble/file#inode "$PWD" && ble/string#match "$ret" '^[0-9]+$'; then
|
|
_ble_histdb_exec_cwd_inode=$ret
|
|
fi
|
|
}
|
|
|
|
function ble/histdb/collect-words.proc {
|
|
[[ $wtype && ! ${wtype//[0-9]} ]] &&
|
|
ble/array#push collect_words "${_ble_edit_str:wbeg:wlen}"
|
|
}
|
|
function ble/histdb/collect-words {
|
|
ble-edit/content/update-syntax
|
|
local -a collect_words=()
|
|
ble/syntax/tree-enumerate-in-range 0 "${#_ble_edit_str}" ble/histdb/collect-words.proc
|
|
ble/array#reverse collect_words
|
|
|
|
ret=()
|
|
local word
|
|
"${_ble_util_set_declare[@]//NAME/mark}" # WA #D1570 checked
|
|
for word in "${collect_words[@]}"; do
|
|
# Note (#D1958): Even if the same words appeared in a single command, we
|
|
# only count 1 for one command. This is because the "words" table is
|
|
# used for the word completion, where the count is used as an importance
|
|
# measure. We count the number of commands where the word appears
|
|
# because the same word can easily appear in a single command multiple
|
|
# times.
|
|
ble/set#contains mark "$word" && return 0
|
|
|
|
ble/set#add mark "$word"
|
|
ble/array#push ret "$word"
|
|
done
|
|
}
|
|
|
|
## @fn ble/histdb/exec_register.hook command
|
|
## @var[in] command_id
|
|
## @var[in] lineno
|
|
## これらの変数は exec_register の側で用意される。
|
|
function ble/histdb/exec_register.hook {
|
|
local command=$1
|
|
if [[ $bleopt_histdb_ignore ]]; then
|
|
local patterns pattern
|
|
ble/string#split patterns : "$bleopt_histdb_ignore"
|
|
for pattern in "${patterns[@]}"; do
|
|
if [[ $command == $pattern ]]; then
|
|
_ble_histdb_exec_ignore[command_id]=1
|
|
return 0
|
|
fi
|
|
done
|
|
fi
|
|
builtin unset -v '_ble_histdb_exec_ignore[command_id]'
|
|
|
|
local q=\' qq=\'\'
|
|
local session_id=$_ble_base_session ret
|
|
ble/util/time; local issue_time=$ret
|
|
|
|
# @var history_index ... history index: The current command might not be
|
|
# registered to the command history, but we always pick up the index of the
|
|
# last entry because there is no way to check it reliably. We could compare
|
|
# the top element with BASH_COMMAND, but the history entry might be
|
|
# transformed by HISTCONTROL=strip, etc.
|
|
local history_index; ble/history/get-count -v history_index
|
|
((history_index++))
|
|
|
|
# Expand "bleopt histdb_remarks"
|
|
local remarks
|
|
ble/histdb/.get-remarks
|
|
|
|
local ret word extra_query=
|
|
ble/histdb/collect-words
|
|
for word in "${ret[@]}"; do
|
|
extra_query=$extra_query"INSERT OR REPLACE INTO words(word, count, ctime, mtime)
|
|
VALUES('${word//$q/$qq}',
|
|
coalesce((SELECT count FROM words WHERE word = '${word//$q/$qq}'), 0) + 1,
|
|
coalesce((SELECT ctime FROM words WHERE word = '${word//$q/$qq}'), $issue_time),
|
|
$issue_time);"
|
|
done
|
|
|
|
ble/histdb/update-cwd-inode
|
|
local inode=$_ble_histdb_exec_cwd_inode
|
|
|
|
ble/histdb/sqlite3.request "
|
|
BEGIN IMMEDIATE TRANSACTION;
|
|
UPDATE sessions SET
|
|
last_time = '${issue_time//$q/$qq}',
|
|
last_wd = '${PWD//$q/$qq}'
|
|
WHERE session_id = '${session_id//$q/$qq}';
|
|
-- Update duplicate command_id
|
|
UPDATE command_history SET
|
|
command_id = min(0, (SELECT command_id FROM command_history WHERE session_id = '${session_id//$q/$qq}')) - 1
|
|
WHERE session_id = '${session_id//$q/$qq}' AND command_id = $command_id;
|
|
-- Add command_history entry
|
|
INSERT INTO command_history(
|
|
session_id, command_id,
|
|
lineno, history_index,
|
|
command, cwd, inode, issue_time, remarks)
|
|
VALUES(
|
|
'${session_id//$q/$qq}', '${command_id//$q/$qq}',
|
|
'${lineno//$q/$qq}', '${history_index//$q/$qq}',
|
|
'${command//$q/$qq}', '${PWD//$q/$qq}', ${inode:-None}, '${issue_time//$q/$qq}', '${remarks//$q/$qq}');
|
|
$extra_query
|
|
COMMIT;"
|
|
}
|
|
|
|
function ble/histdb/postexec.hook {
|
|
local session_id=$_ble_base_session
|
|
local command_id=$_ble_edit_exec_command_id
|
|
if [[ ${_ble_histdb_exec_ignore[command_id]+set} ]]; then
|
|
builtin unset -v '_ble_histdb_exec_ignore[command_id]'
|
|
return 0
|
|
fi
|
|
|
|
local ret
|
|
ble/util/time; local last_time=$ret
|
|
|
|
IFS=, builtin eval 'local pipestatus="${_ble_edit_exec_PIPESTATUS[*]}"'
|
|
local lastarg=$_ble_edit_exec_lastarg
|
|
((${#lastarg}>=1000)) && lastarg=${lastarg::997}...
|
|
|
|
local real=$_ble_exec_time_tot
|
|
local usr=$_ble_exec_time_usr
|
|
local sys=$_ble_exec_time_sys
|
|
local cpu=$((real>0?(usr+sys)/real:0))
|
|
local usr_chld=$((usr-_ble_exec_time_usr_self))
|
|
local sys_chld=$((sys-_ble_exec_time_sys_self))
|
|
|
|
local q=\' qq=\'\'
|
|
ble/histdb/sqlite3.request "
|
|
UPDATE sessions SET
|
|
last_time = '${last_time//$q/$qq}',
|
|
last_wd = '${PWD//$q/$qq}'
|
|
WHERE session_id = '${session_id//$q/$qq}';
|
|
UPDATE command_history SET
|
|
status = '${_ble_edit_exec_lastexit//$q/$qq}',
|
|
pipestatus = '${pipestatus//$q/$qq}',
|
|
lastarg = '${lastarg//$q/$qq}',
|
|
bgpid = '${!//$q/$qq}',
|
|
exec_time = '${_ble_exec_time_ata//$q/$qq}',
|
|
exec_time_beg = '${_ble_exec_time_beg//$q/$qq}',
|
|
exec_time_end = '${_ble_exec_time_end//$q/$qq}',
|
|
exec_time_real = '${real//$q/$qq}',
|
|
exec_time_usr = '${usr//$q/$qq}',
|
|
exec_time_sys = '${sys//$q/$qq}',
|
|
exec_time_cpu = '${cpu//$q/$qq}',
|
|
exec_time_usr_self = '${_ble_exec_time_usr_self//$q/$qq}',
|
|
exec_time_sys_self = '${_ble_exec_time_sys_self//$q/$qq}',
|
|
exec_time_usr_chld = '${usr_chld//$q/$qq}',
|
|
exec_time_sys_chld = '${sys_chld//$q/$qq}'
|
|
WHERE session_id = '${session_id//$q/$qq}' AND command_id = $command_id;"
|
|
}
|
|
|
|
function ble/histdb/backup {
|
|
local file=$1
|
|
ble/bin#freeze-utility-path -n gzip || return 1
|
|
|
|
local backup=${file%.sqlite3}.backup.sqlite3 q=\' qq=\'\'
|
|
if [[ -s $backup.gz ]]; then
|
|
# If there is already an up-to-date backup file, we skip the backup.
|
|
local ret now
|
|
ble/util/time; now=$ret
|
|
ble/file#mtime "$backup.gz" || return 1
|
|
((now>ret+24*3600)) || return 1
|
|
fi
|
|
|
|
"$_ble_histdb_sqlite3" "$file" \
|
|
".timeout $_ble_histdb_timeout" \
|
|
"PRAGMA quick_check;" \
|
|
".backup '${backup//$q/$qq}'" \
|
|
"ATTACH DATABASE '${backup//$q/$qq}' AS backup;
|
|
PRAGMA backup.quick_check;" >/dev/null &&
|
|
ble/bin/gzip -c "$backup" >| "$backup.gz.part" &&
|
|
[[ -s $backup.gz.part ]] &&
|
|
ble/bin/mv -f "$backup.gz.part" "$backup.gz" &&
|
|
ble/bin/rm -f "$backup"
|
|
}
|
|
|
|
function ble/histdb/unload.hook {
|
|
if [[ $_ble_histdb_file ]]; then
|
|
local file=$_ble_histdb_file
|
|
ble/histdb/sqlite3.close
|
|
ble/histdb/backup "$file"
|
|
fi
|
|
}
|
|
|
|
# 設定が変化して記録先の history.sqlite3 のパスが変わったら現在のファイルは閉じ
|
|
# る。必要になった時に初めて新しいファイルを開く。
|
|
function ble/histdb/exec_end.hook {
|
|
local ret; ble/histdb/.get-filename
|
|
[[ $ret == "$_ble_histdb_file" ]] ||
|
|
((${#_ble_edit_exec_lines[@]})) ||
|
|
ble/histdb/sqlite3.close
|
|
}
|
|
|
|
blehook exec_register!=ble/histdb/exec_register.hook
|
|
blehook POSTEXEC!=ble/histdb/postexec.hook
|
|
blehook exec_end!=ble/histdb/exec_end.hook
|
|
blehook unload!=ble/histdb/unload.hook
|
|
|
|
#------------------------------------------------------------------------------
|
|
# auto-complete
|
|
|
|
function ble/complete/auto-complete/source:histdb-history {
|
|
local limit=$((bleopt_line_limit_length)) limit_condition=
|
|
if ((limit)); then
|
|
((limit-=${#_ble_edit_str},limit>0)) || return 1
|
|
limit_condition=" AND length(command) <= $limit"
|
|
fi
|
|
|
|
local ret
|
|
ble/histdb/escape-for-sqlite-glob "$_ble_edit_str"; local pat=$ret?*
|
|
|
|
ble/histdb/update-cwd-inode
|
|
local inode=$_ble_histdb_exec_cwd_inode
|
|
|
|
local q=\' qq=\'\'
|
|
ble/histdb/sqlite3.request-single-value "
|
|
SELECT coalesce(
|
|
(SELECT command FROM (SELECT command, max(issue_time) FROM command_history WHERE command GLOB '${pat//$q/$qq}' AND cwd = '${PWD//$q/$qq}$limit_condition')),
|
|
${inode:+(SELECT command FROM (SELECT command, max(issue_time) FROM command_history WHERE command GLOB '${pat//$q/$qq}' AND inode = $inode$limit_condition)),}
|
|
'');"
|
|
[[ $ret == "$_ble_edit_str"?* ]] || return 1
|
|
ble/complete/auto-complete/enter h 0 "${ret:${#_ble_edit_str}}" '' "$ret"
|
|
}
|
|
|
|
function ble/complete/auto-complete/source:histdb-word {
|
|
local iN=${#_ble_edit_str}
|
|
((_ble_edit_ind>0)) || return 1
|
|
|
|
local limit=$((bleopt_line_limit_length)) limit_condition=
|
|
if ((limit)); then
|
|
((limit-=iN,limit>0)) || return 1
|
|
limit_condition=" AND length(word) <= $limit"
|
|
fi
|
|
|
|
local -a wbegins=()
|
|
if ((_ble_edit_ind<iN)); then
|
|
# 行中にいる時は現在位置で完結している単語だけを対象にする。
|
|
if [[ ${_ble_syntax_tree[_ble_edit_ind-1]} ]]; then
|
|
local tree
|
|
ble/string#split-words tree "${_ble_syntax_tree[_ble_edit_ind-1]}"
|
|
local wtype=${tree[0]} wlen=${tree[1]}
|
|
[[ $wtype && ! ${wtype//[0-9]} && wlen -ge 0 ]] &&
|
|
ble/array#push wbegins "$((_ble_edit_ind-wlen))"
|
|
elif local ret; ble/syntax/completion-context/.search-last-istat "$((_ble_edit_ind-1))"; then
|
|
local istat=$ret stat wlen
|
|
ble/string#split-words stat "${_ble_syntax_stat[istat]}"
|
|
if (((wlen=stat[1])>=0)); then
|
|
ble/array#push wbegins "$((istat-wlen))"
|
|
elif [[ ${_ble_syntax_bash_command_EndWtype[stat[0]]:-} ]]; then
|
|
# 単語の始まりの時 (_ble_syntax_bash_command_EndWtype で判定できるのかは実は非自明)
|
|
ble/array#push wbegins "$istat"
|
|
fi
|
|
fi
|
|
|
|
else
|
|
# 閉じていない入れ子に対する列挙
|
|
|
|
local -a stat nest tree
|
|
ble/string#split-words stat "${_ble_syntax_stat[iN]}"
|
|
local wlen tclen
|
|
if (((wlen=stat[1])>=0)); then
|
|
ble/array#push wbegins "$((iN-wlen))"
|
|
elif (((tclen=stat[4])>=0)); then
|
|
local wend=$((iN-tclen))
|
|
ble/string#split-words tree "${_ble_syntax_tree[wend-1]}"
|
|
local wtype=${tree[0]} wlen=${tree[1]}
|
|
[[ $wtype && ! ${wtype//[0-9]} && wlen -ge 0 ]] &&
|
|
ble/array#push wbegins "$((wend-wlen))"
|
|
fi
|
|
|
|
local inest=$iN nlen=${stat[3]}
|
|
while ((nlen>0)); do
|
|
((inest-=nlen))
|
|
ble/string#split-words nest "${_ble_syntax_nest[inest]}"
|
|
(((wlen=nest[1])>=0)) &&
|
|
ble/array#push wbegins "$((inest-wlen))"
|
|
nlen=${nest[3]}
|
|
done
|
|
fi
|
|
((${#wbegins[@]})) || return 1
|
|
|
|
local -a sqls=()
|
|
|
|
local i q=\' qq=\'\'
|
|
for i in "${wbegins[@]}"; do
|
|
local word=${_ble_edit_str:i:_ble_edit_ind-i}
|
|
[[ $word ]] || continue
|
|
local ret; ble/histdb/escape-for-sqlite-glob "$word"
|
|
local pat=$ret?*
|
|
ble/array#push sqls "SELECT '$i:' || word FROM (SELECT word, max(mtime) FROM words WHERE word GLOB '${pat//$q/$qq}'$limit_condition)"
|
|
done
|
|
((${#sqls[@]})) || return 1
|
|
|
|
ble/array#reverse sqls
|
|
sqls=("${sqls[@]/#/(}") # WA #D1570 checked
|
|
sqls=("${sqls[@]/%/)}") # WA #D1570 checked
|
|
ble/array#push sqls "''"
|
|
IFS=, builtin eval 'local query="select coalesce(${sqls[*]});"'
|
|
|
|
local ret
|
|
ble/histdb/sqlite3.request-single-value "$query" auto || return 1
|
|
[[ $ret == *:* ]] || return 1
|
|
|
|
local index=${ret%%:*} insert=${ret#*:}
|
|
if local comps=${_ble_edit_str:index:_ble_edit_ind-index}; [[ $insert == "$comps"* ]]; then
|
|
local ins=${insert:_ble_edit_ind-index}
|
|
ble/complete/auto-complete/enter c "$_ble_edit_ind" "$ins" "$insert" "$ins" "$ins" ' '
|
|
else
|
|
ble/complete/auto-complete/enter r "$index" " [$insert] " "$insert" "$insert" "$insert" ' '
|
|
fi
|
|
}
|
|
ble/util/import/eval-after-load core-complete '
|
|
ble/array#insert-before _ble_complete_auto_source history histdb-history
|
|
ble/array#push _ble_complete_auto_source histdb-word'
|
|
[[ $_ble_histdb_keepalive_enabled ]] &&
|
|
ble/util/idle.push ble/histdb/sqlite3.open
|
|
|
|
#------------------------------------------------------------------------------
|
|
# ble histdb command
|
|
|
|
function ble-histdb {
|
|
builtin eval -- "$_ble_bash_POSIXLY_CORRECT_local_adjust"
|
|
local set shopt ext
|
|
ble/base/.adjust-bash-options set shopt
|
|
if (($#==0)); then
|
|
ble/histdb/sub:query 'select command from command_history;'
|
|
ext=$?
|
|
elif ble/is-function "ble/histdb/sub:$1"; then
|
|
"ble/histdb/sub:$@"
|
|
ext=$?
|
|
else
|
|
builtin printf 'ble-histdb: unknown command "%s"\n' "$1"
|
|
ext=2
|
|
fi
|
|
ble/base/.restore-bash-options set shopt
|
|
ble/util/setexit "$ext"
|
|
builtin eval -- "$_ble_bash_POSIXLY_CORRECT_local_return"
|
|
}
|
|
|
|
# 一般的な補完のフレームワークを作っても良いのではないかという気がしてきたが、
|
|
# それは後で。
|
|
function ble/cmdinfo/complete:ble-histdb {
|
|
if ((comp_cword==1)); then
|
|
local ret sub
|
|
ble/util/assign-array ret 'compgen -A function -- ble/histdb/sub:'
|
|
((${#ret[@]})) || return 0
|
|
|
|
local cands
|
|
for sub in "${ret[@]#ble/histdb/sub:}"; do
|
|
if [[ $sub != */* && $sub == "$COMPV"* ]]; then
|
|
ble/array#push cands "$sub"
|
|
fi
|
|
done
|
|
|
|
if ((${#cands[@]})); then
|
|
local "${_ble_complete_yield_varnames[@]/%/=}" # disable=#D1570
|
|
ble/complete/cand/yield.initialize word
|
|
ble/complete/cand/yield.batch word
|
|
fi
|
|
fi
|
|
}
|
|
|
|
function ble/histdb/sub:query {
|
|
local ret
|
|
ble/histdb/.get-filename; local histdb_file=$ret
|
|
"$_ble_histdb_sqlite3" "$histdb_file" '.timeout 1000' "$@"
|
|
}
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
function ble/histdb/count2si {
|
|
local si
|
|
si=('' k M G T P E Z Y R Q)
|
|
|
|
local count=$1 i
|
|
for ((i=0;i<${#si[@]}-1;i++,count/=1000)); do
|
|
if ((count<1000)); then
|
|
ret=$count${si[i]}
|
|
return 0
|
|
elif ((count<100000)); then
|
|
count=${count%???}.${count:${#count}-3}
|
|
ret=${count::4}${si[i+1]}
|
|
return 0
|
|
fi
|
|
done
|
|
ret=$count${si[${#si[@]}-1]}
|
|
}
|
|
|
|
# modified ble/contrib/prompt-elapsed/output-sec.ps
|
|
function ble/histdb/usec2s {
|
|
local usec=${1:-0}
|
|
if ((usec<1000)); then
|
|
ret=${usec}us
|
|
elif ((usec<100000)); then
|
|
usec=${usec%???}.${usec:${#usec}-3}
|
|
ret=${usec::4}ms
|
|
else
|
|
ble/histdb/msec2s "$((usec/1000))"
|
|
fi
|
|
}
|
|
|
|
function ble/histdb/msec2s {
|
|
local msec=${1:-0}
|
|
if ((msec<1000)); then
|
|
ret=${msec}ms
|
|
elif ((msec<100000)); then
|
|
msec=${msec%???}.${msec:${#msec}-3}
|
|
ret=${msec::4}s
|
|
else
|
|
ble/histdb/sec2s "$((msec/1000))"
|
|
fi
|
|
}
|
|
|
|
function ble/histdb/sec2s {
|
|
local sec=${1:-0} min
|
|
((min=sec/60,sec%=60))
|
|
if ((min<100)); then
|
|
ret=${min}m${sec}s
|
|
return 0
|
|
fi
|
|
|
|
local hour; ((hour=min/60,min%=60))
|
|
if ((hour<100)); then
|
|
ret="${hour}h:${min}m:${sec}s"
|
|
return 0
|
|
fi
|
|
|
|
local day; ((day=hour/24,hour%=24))
|
|
if ((day<365)); then
|
|
ret="${day}d-${hour}h:${min}m"
|
|
return 0
|
|
fi
|
|
|
|
local year; ((year=day/365,day%=365))
|
|
ret="${year}y-${day}d-${hour}h"
|
|
return 0
|
|
}
|
|
|
|
#------------------------------------------------------------------------------
|
|
# usage: ble histdb stats
|
|
|
|
bleopt/declare -v histdb_stats_items 'commands unique-commands successful-commands exec-time exec-cpu-time words sessions directories'
|
|
|
|
function ble/histdb/sub:stats/get-user-name {
|
|
ble/bin#has git && ble/util/assign ret '
|
|
git config user.name 2>/dev/null
|
|
' && [[ $ret ]] && return 0
|
|
|
|
ble/bin#has getenv && ble/util/assign ret '
|
|
getent passwd 2>/dev/null | ble/bin/awk -F : -v UID="$UID" '\''
|
|
$3==UID {
|
|
sub(/[[:space:]]*[<>].*$/, "", $5);
|
|
print $5;
|
|
}
|
|
'\''
|
|
' && [[ $ret ]] && return 0
|
|
|
|
ret=${USER:-$_ble_base_env_USER}@${HOSTNAME:-$_ble_base_env_HOSTNAME}
|
|
}
|
|
|
|
## @fn ble/histdb/sub:stats/where.check condition
|
|
## @param[in] condition
|
|
## @var[ref] where
|
|
function ble/histdb/sub:stats/where.check {
|
|
where="${where:- WHERE}${where:+ AND} $1"
|
|
}
|
|
## @fn ble/histdb/sub:stats/where.check-datetime column
|
|
## @param[in] column
|
|
## @var[in] time_beg time_end
|
|
## @var[ref] where
|
|
function ble/histdb/sub:stats/where.check-datetime {
|
|
[[ $time_beg ]] && ble/histdb/sub:stats/where.check "$1 >= $time_beg"
|
|
[[ $time_end ]] && ble/histdb/sub:stats/where.check "$1 < $time_end"
|
|
}
|
|
|
|
function ble/histdb/sub:stats/item:commands {
|
|
case $1 in
|
|
(init)
|
|
local where=
|
|
ble/histdb/sub:stats/where.check-datetime issue_time
|
|
ble/array#push queries "SELECT count(*) FROM command_history$where;" ;;
|
|
(get)
|
|
ble/array#push names 'Total commands'
|
|
local ret
|
|
ble/histdb/count2si "$2"
|
|
ble/array#push values "$ret" ;;
|
|
esac
|
|
}
|
|
|
|
function ble/histdb/sub:stats/item:unique-commands {
|
|
case $1 in
|
|
(init)
|
|
local where=
|
|
ble/histdb/sub:stats/where.check-datetime issue_time
|
|
ble/array#push queries "SELECT count(*) FROM (SELECT DISTINCT command FROM command_history$where);" ;;
|
|
(get)
|
|
ble/array#push names 'Total unique commands'
|
|
local ret
|
|
ble/histdb/count2si "$2"
|
|
ble/array#push values "$ret" ;;
|
|
esac
|
|
}
|
|
|
|
function ble/histdb/sub:stats/item:successful-commands {
|
|
case $1 in
|
|
(init)
|
|
local where=
|
|
ble/histdb/sub:stats/where.check 'status == 0'
|
|
ble/histdb/sub:stats/where.check-datetime issue_time
|
|
ble/array#push queries "SELECT count(*) FROM (SELECT command FROM command_history$where);" ;;
|
|
(get)
|
|
ble/array#push names 'Total successful commands'
|
|
local ret
|
|
ble/histdb/count2si "$2"
|
|
ble/array#push values "$ret" ;;
|
|
esac
|
|
}
|
|
|
|
function ble/histdb/sub:stats/item:sessions {
|
|
case $1 in
|
|
(init)
|
|
local where=
|
|
if [[ $time_end ]]; then
|
|
ble/histdb/sub:stats/where.check-datetime start_time
|
|
else
|
|
ble/histdb/sub:stats/where.check-datetime last_time
|
|
fi
|
|
ble/array#push queries "SELECT count(*) FROM sessions$where;" ;;
|
|
(get)
|
|
ble/array#push names 'Total sessions'
|
|
local ret
|
|
ble/histdb/count2si "$2"
|
|
ble/array#push values "$ret" ;;
|
|
esac
|
|
}
|
|
|
|
function ble/histdb/sub:stats/item:words {
|
|
case $1 in
|
|
(init)
|
|
local where=
|
|
if [[ $time_end ]]; then
|
|
ble/histdb/sub:stats/where.check-datetime ctime
|
|
else
|
|
ble/histdb/sub:stats/where.check-datetime mtime
|
|
fi
|
|
ble/array#push queries "SELECT count(*) FROM words$where;" ;;
|
|
(get)
|
|
ble/array#push names 'Total distinct words'
|
|
local ret
|
|
ble/histdb/count2si "$2"
|
|
ble/array#push values "$ret" ;;
|
|
esac
|
|
}
|
|
|
|
function ble/histdb/sub:stats/item:directories {
|
|
case $1 in
|
|
(init)
|
|
local where=
|
|
ble/histdb/sub:stats/where.check-datetime issue_time
|
|
ble/array#push queries "SELECT count(*) FROM (SELECT DISTINCT cwd FROM command_history$where);" ;;
|
|
(get)
|
|
ble/array#push names 'Total directories'
|
|
local ret
|
|
ble/histdb/count2si "$2"
|
|
ble/array#push values "$ret" ;;
|
|
esac
|
|
}
|
|
|
|
function ble/histdb/sub:stats/item:exec-time {
|
|
case $1 in
|
|
(init)
|
|
local where=
|
|
ble/histdb/sub:stats/where.check-datetime issue_time
|
|
ble/array#push queries "SELECT sum(exec_time) FROM command_history$where;" ;;
|
|
(get)
|
|
ble/array#push names 'Total execution time'
|
|
local ret
|
|
ble/histdb/usec2s "$2"
|
|
ble/array#push values "$ret" ;;
|
|
esac
|
|
}
|
|
|
|
function ble/histdb/sub:stats/item:exec-cpu-time {
|
|
case $1 in
|
|
(init)
|
|
local where=
|
|
ble/histdb/sub:stats/where.check-datetime issue_time
|
|
ble/array#push queries "SELECT sum(exec_time_usr + exec_time_sys) FROM command_history$where;" ;;
|
|
(get)
|
|
ble/array#push names 'Total CPU time'
|
|
local ret
|
|
ble/histdb/msec2s "$2"
|
|
ble/array#push values "$ret" ;;
|
|
esac
|
|
}
|
|
|
|
function ble/histdb/sub:stats {
|
|
local period=${1-}
|
|
|
|
local time_beg= time_end=
|
|
|
|
if [[ $period ]]; then
|
|
local ret
|
|
if ble/string#match "$period" '^([0-9]+)([smhdMy])$'; then
|
|
local delta=${BASH_REMATCH[1]}
|
|
case ${BASH_REMATCH[2]} in
|
|
(m) ((delta*=60)) ;;
|
|
(h) ((delta*=3600)) ;;
|
|
(d) ((delta*=3600*24)) ;;
|
|
(M) ((delta*=3600*24*30)) ;;
|
|
(y) ((delta*=3600*24*365)) ;;
|
|
esac
|
|
ble/util/time
|
|
((time_beg=ret-delta))
|
|
elif ble/string#match "$period" '^2[0-9]{3}(-(0[1-9]|1[0-2])(-(0[1-9]|[12][0-9]|3[01]))?)?$'; then
|
|
local y=${period::4} m=${BASH_REMATCH[2]-} d=${BASH_REMATCH[4]-}
|
|
if [[ $d ]]; then
|
|
m=${m#0} d=${d#0}
|
|
ble/util/mktime "$y-$m-$d 00:00:00"
|
|
time_beg=$ret
|
|
# Note: we here assume that 01-32 is equivalent to 02-01, etc.
|
|
ble/util/mktime "$y-$m-$((d+1)) 00:00:00"
|
|
time_end=$ret
|
|
elif [[ $m ]]; then
|
|
m=${m#0}
|
|
ble/util/mktime "$y-$m-01 00:00:00"
|
|
time_beg=$ret
|
|
ble/util/mktime "$((y+m/12))-$((m%12+1))-01 00:00:00"
|
|
time_end=$ret
|
|
else
|
|
ble/util/mktime "$y-01-01 00:00:00"
|
|
time_beg=$ret
|
|
ble/util/mktime "$((y+1))-01-01 00:00:00"
|
|
time_end=$ret
|
|
fi
|
|
else
|
|
ble/util/print "ble-histdb-stats: unrecognized argument '$period'" 2>/dev/null
|
|
return 2
|
|
fi
|
|
fi
|
|
|
|
local -a queries=()
|
|
local items item
|
|
ble/string#split-words items "$bleopt_histdb_stats_items"
|
|
for item in "${items[@]}"; do
|
|
ble/histdb/sub:stats/item:"$item" init
|
|
done
|
|
|
|
local IFS=$_ble_term_IFS
|
|
ble/histdb/sub:query -separator ' ' "${queries[*]}" | {
|
|
local result
|
|
ble/util/mapfile result
|
|
|
|
local ret sgr0=$_ble_term_sgr0
|
|
ble/color/gspec2sgr 'fg=27,bold'; local sgr1=$ret
|
|
ble/histdb/sub:stats/get-user-name
|
|
ble/util/print "$sgr1$ret's Shell Stats${period:+ ($period)}$sgr0"
|
|
|
|
local -a names=() values=()
|
|
local i=0
|
|
for item in "${items[@]}"; do
|
|
ble/histdb/sub:stats/item:"$item" get "${result[i++]}"
|
|
done
|
|
|
|
local name max_name_width=0
|
|
for name in "${names[@]}"; do
|
|
local w=$((${#name}+1))
|
|
((max_name_width<w)) && ((max_name_width=w))
|
|
done
|
|
|
|
ble/color/gspec2sgr 'bold'; local sgr2=$ret
|
|
for i in "${!names[@]}"; do
|
|
builtin printf ' %s%-*s %s%s\n' "$sgr2" "$max_name_width" "${names[i]}:" "${values[i]}" "$sgr0"
|
|
done
|
|
}
|
|
}
|
|
|
|
#------------------------------------------------------------------------------
|
|
# lib: ble/getopts
|
|
|
|
## @fn ble/getopts/scan-definition type script
|
|
## @param[in] type
|
|
## Specify the type of
|
|
##
|
|
## @fn[opt] ble/getopts/scan-definition:TYPE/label
|
|
## @fn[opt] ble/getopts/scan-definition:TYPE/flag
|
|
## @fn[opt] ble/getopts/scan-definition:TYPE/option
|
|
##
|
|
## @param[in] script
|
|
## Define the command-line interface by calling label:, flag:, and option:
|
|
##
|
|
_ble_getopts_definition_headers=(label flag option arguments)
|
|
function ble/getopts/scan-definition {
|
|
local type=$1 def=$2 header fn
|
|
for header in "${_ble_getopts_definition_headers[@]}"; do
|
|
fn=ble/getopts/scan-definition:$type/$header
|
|
if ble/is-function "$fn"; then
|
|
ble/function#push "$header" "$fn \"\$@\""
|
|
else
|
|
ble/function#push "$header" '((1))'
|
|
fi
|
|
done
|
|
builtin eval -- "$def"
|
|
for header in "${_ble_getopts_definition_headers[@]}"; do
|
|
ble/function#pop "$header"
|
|
done
|
|
}
|
|
|
|
function ble/getopts/scan-definition:parser/label {
|
|
getopts_label=$1
|
|
}
|
|
|
|
# todo array
|
|
function ble/getopts/scan-definition:parser/option {
|
|
local var=$1 opt=$2 q=\' Q="'\''"
|
|
|
|
if [[ $opt == --* ]]; then
|
|
ble/util/print NYI >&2
|
|
elif [[ $opt == -? ]]; then
|
|
opt=${opt:1}
|
|
getopts_short_options=$getopts_short_options'('\'${opt//$q/$Q}\'')
|
|
if [[ ${arg:1} ]]; then
|
|
'$var'=${arg:1} arg=
|
|
elif (($#)); then
|
|
'$var'=$1
|
|
shift
|
|
else
|
|
ble/util/print "$_getopts_label: missing option argument for '\''-$arg'\''" >&2
|
|
flags=E$flags
|
|
fi ;;
|
|
'
|
|
fi
|
|
}
|
|
function ble/getopts/scan-definition:parser/arguments {
|
|
local var=${1:-args}
|
|
getopts_arguments=$getopts_arguments'
|
|
ble/array#push '$var' "$arg"
|
|
'
|
|
}
|
|
|
|
function ble/getopts/generate-parser {
|
|
local getopts_finalize=
|
|
local getopts_initialize=
|
|
local getopts_label=
|
|
local getopts_long_options=
|
|
local getopts_short_options=
|
|
local getopts_arguments=
|
|
|
|
ble/getopts/scan-definition parser "$2"
|
|
|
|
if [[ ! $getopts_arguments ]]; then
|
|
getopts_arguments='
|
|
ble/util/print "$_getopt_label: unrecognized argument '\''$arg'\''" >&2
|
|
flags=E$flags
|
|
'
|
|
fi
|
|
|
|
local getopts_script='
|
|
local _ble_local_set _ble_local_shopt
|
|
ble/base/.adjust-bash-options _ble_local_set _ble_local_shopt
|
|
local LC_ALL= LC_COLLATE=C 2>/dev/null
|
|
|
|
local _getopts_label='$q${getopts_label//$q/$Q}$q'
|
|
|
|
flags=
|
|
'$getopts_initialize'
|
|
while (($#)); do
|
|
local arg=$1; shift
|
|
if [[ $arg == -?* && $flags != *-* ]]; then
|
|
if [[ $arg == --* ]]; then
|
|
case $arg in
|
|
(--) flags=-$flags ;;
|
|
'$getopts_long_options'
|
|
(*)
|
|
ble/util/print "$_getopts_label: unrecognized long option '\''$arg'\''" >&2
|
|
flags=E$flags ;;
|
|
esac
|
|
else
|
|
arg=${arg:1}
|
|
while [[ $arg ]]; do
|
|
case ${arg::1} in
|
|
'$getopts_short_options'
|
|
(*)
|
|
ble/util/print "$_getopts_label: unrecognized option '\''-${arg::1}'\''" >&2
|
|
flags=E$flags ;;
|
|
esac
|
|
arg=${arg:1}
|
|
done
|
|
fi
|
|
continue
|
|
fi
|
|
|
|
'$getopts_arguments'
|
|
done
|
|
'$getopts_finalize'
|
|
|
|
ble/util/unlocal LC_ALL LC_COLLATE 2>/dev/null
|
|
ble/base/.restore-bash-options _ble_local_set _ble_local_shopt
|
|
[[ $flags != *E* ]]
|
|
'
|
|
|
|
builtin eval -- "function $1 { $getopts_script }"
|
|
}
|
|
|
|
#------------------------------------------------------------------------------
|
|
# lib: ble/histdb/graph
|
|
|
|
## @fn ble/histdb/graph/board/initialize
|
|
## @arr[out] grboard_export
|
|
function ble/histdb/graph/board/initialize {
|
|
local -a colors
|
|
ble/histdb/graph/palette "$2"
|
|
|
|
local mark=$1
|
|
if [[ ! $mark ]]; then
|
|
if ble/util/is-unicode-output; then
|
|
mark='■'
|
|
else
|
|
mark='##'
|
|
fi
|
|
fi
|
|
|
|
grboard_export=()
|
|
ble/array#push grboard_export "grboard_nlevel=${#colors[@]}"
|
|
|
|
local i ret
|
|
for i in "${!colors[@]}"; do
|
|
ble/color/gspec2sgr "fg=${colors[i]}"
|
|
ble/array#push grboard_export "grboard_unit$i=$ret$mark$_ble_term_sgr0"
|
|
done
|
|
|
|
local ret
|
|
ble/util/s2w "$mark"; local w=$ret
|
|
ble/string#reserve-prototype "$w"
|
|
ble/array#push grboard_export "grboard_unit_white=${_ble_string_prototype::w}"
|
|
}
|
|
_ble_histdb_grboard_awk_lib='
|
|
function grboard_initialize(_, i) {
|
|
grboard_nlevel = ENVIRON["grboard_nlevel"];
|
|
grboard_unit[-1] = ENVIRON["grboard_unit_white"];
|
|
for (i = 0; i < grboard_nlevel; i++)
|
|
grboard_unit[i] = ENVIRON["grboard_unit" i];
|
|
}
|
|
function grboard__score2unit(score, score_max) {
|
|
if (score == "" || score < 0)
|
|
return grboard_unit[-1];
|
|
else if (score == 0)
|
|
return grboard_unit[0];
|
|
else
|
|
return grboard_unit[1 + int((grboard_nlevel - 1) * score / (score_max + 1))];
|
|
}
|
|
function grboard_render(lines, table, w, h, _, x, y, maxv, v, line) {
|
|
maxv = 0;
|
|
for (y = 0; y < h; y++)
|
|
for (x = 0; x < w; x++)
|
|
if (table[y, x] > maxv)
|
|
maxv = table[y, x];
|
|
|
|
for (y = 0; y < h; y++) {
|
|
line = "";
|
|
for (x = 0; x < w; x++) {
|
|
v = table[y, x];
|
|
line = line grboard__score2unit(v, maxv);
|
|
}
|
|
lines[y] = line;
|
|
}
|
|
}
|
|
'
|
|
|
|
## @fn ble/histdb/graph/vbar/initialize [palette]
|
|
## @var[out] grvbar_declare
|
|
function ble/histdb/graph/vbar/initialize {
|
|
local -a colors
|
|
ble/histdb/graph/palette "$1"
|
|
local gspec=${colors[0]}
|
|
|
|
grvbar_declare=()
|
|
|
|
local ret sgr1= sgr0=
|
|
if ble/util/is-unicode-output; then
|
|
local nlevel=8
|
|
if [[ $gspec ]]; then
|
|
ble/color/gspec2sgr "fg=$gspec"
|
|
sgr1=$ret sgr0=$_ble_term_sgr0
|
|
fi
|
|
ble/util/c2w "$((0x2581))"; local w=$ret
|
|
ble/array#push grvbar_declare grvbar_nlevel="$nlevel" grvbar_unit0=' '
|
|
local i
|
|
for ((i=1;i<=nlevel;i++)); do
|
|
ble/util/c2s "$((0x2580+i))"
|
|
((w==1)) && ret=$ret$ret
|
|
ble/array#push grvbar_declare "grvbar_unit$i=$sgr1$ret$sgr0"
|
|
done
|
|
else
|
|
if [[ $gspec ]]; then
|
|
ble/color/gspec2sgr "bg=$gspec"
|
|
sgr1=$ret sgr0=$_ble_term_sgr0
|
|
fi
|
|
ble/array#push grvbar_declare grvbar_nlevel=1 grvbar_unit0=' ' grvbar_unit1="$sgr1 $sgr0"
|
|
fi
|
|
}
|
|
_ble_histdb_grvbar_awk_lib='
|
|
function grvbar_initialize(_, i) {
|
|
grvbar_nlevel = ENVIRON["grvbar_nlevel"];
|
|
grvbar_unit[-1] = ENVIRON["grvbar_unit_white"];
|
|
for (i = 0; i <= grvbar_nlevel; i++)
|
|
grvbar_unit[i] = ENVIRON["grvbar_unit" i];
|
|
}
|
|
function grvbar__score2unit(score, score_max) {
|
|
if (score <= 0)
|
|
return grvbar_unit[0];
|
|
else
|
|
return grvbar_unit[1 + int((grvbar_nlevel - 1) * score / (score_max + 1))];
|
|
}
|
|
function grvbar__clamp(x, l, u) {
|
|
return x < l ? l : x > u ? u : x;
|
|
}
|
|
function grvbar_render(lines, list, w, h, _, x, y, maxv, line, s) {
|
|
maxv = 0;
|
|
for (x = 0; x < w; x++)
|
|
if (list[x] > maxv)
|
|
maxv = list[x];
|
|
for (y = 0; y < h; y++) {
|
|
line = ""
|
|
for (x = 0; x < w; x++) {
|
|
s = int((grvbar_nlevel * h + 1) * list[x] / (maxv + 1));
|
|
line = line grvbar_unit[grvbar__clamp(s - y * grvbar_nlevel, 0, grvbar_nlevel)];
|
|
}
|
|
lines[h - 1 - y] = line;
|
|
}
|
|
}
|
|
'
|
|
|
|
function ble/histdb/graph/palette {
|
|
local palette=$1
|
|
|
|
local index=
|
|
if ble/string#match "$palette" '\[([0-9]+)\]$'; then
|
|
index=${BASH_REMATCH[1]}
|
|
palette=${palette::${#palette}-${#BASH_REMATCH}}
|
|
fi
|
|
if [[ ! $palette ]]; then
|
|
local ret
|
|
ble/util/strftime -v ret '%m'
|
|
case ${ret#0} in
|
|
(10) palette=github-halloween ;;
|
|
(12) palette=github-winter ;;
|
|
(*) palette=github-light ;;
|
|
esac
|
|
fi
|
|
|
|
# https://github.com/orgs/community/discussions/7078
|
|
case $palette in
|
|
(github-light24) colors=('#ebedf0' '#9be9a8' '#30c463' '#30a14e' '#216e39') ;;
|
|
(github-dark24) colors=('#161b22' '#0e4429' '#006d32' '#26a641' '#39d353') ;;
|
|
(halloween-light24) colors=('#ebedf0' '#ffee4a' '#ffc501' '#fe9600' '#03001c') ;;
|
|
(halloween-dark24) colors=('#161b22' '#631c03' '#bd561d' '#fa7a18' '#fddf68') ;;
|
|
(winter-light24) colors=('#ebedf0' '#b6e3ff' '#54aeff' '#0969da' '#0a3069') ;;
|
|
(winter-dark24) colors=('#161b22' '#0a3069' '#0969da' '#54aeff' '#b6e3ff') ;;
|
|
(github-light) colors=(255 151 77 71 23) ;;
|
|
(github-dark) colors=(234 22 23 35 77) ;;
|
|
(halloween-light) colors=(255 227 220 208 232) ;;
|
|
(halloween-dark) colors=(234 52 130 208 221) ;;
|
|
(winter-light) colors=(255 153 75 26 23) ;;
|
|
(winter-dark) colors=(234 23 26 75 153) ;;
|
|
(rainbow)
|
|
colors=({196..220..6} {190..46..36}) ;;
|
|
(rainbow2)
|
|
colors=({16..21} {21..45..6} {51..46} {82..190..36} {220..196..6}) ;;
|
|
(*)
|
|
ble/string#split colors , "$z1"
|
|
esac
|
|
|
|
# specify one color
|
|
if [[ $index ]]; then
|
|
colors=("${colors[index<${#colors[@]}?index:0]}")
|
|
fi
|
|
}
|
|
|
|
## @fn ble/histdb/graph/hbar/initialize [palette]
|
|
## @var[out] grhbar_declare
|
|
function ble/histdb/graph/hbar/initialize {
|
|
local -a colors
|
|
ble/histdb/graph/palette "$1"
|
|
|
|
grhbar_declare=()
|
|
|
|
local -a sgr=()
|
|
local ret
|
|
if ble/util/is-unicode-output; then
|
|
local nlevel=8
|
|
if ((${#colors[@]})); then
|
|
sgr[0]=$_ble_term_sgr0
|
|
local color
|
|
for color in "${colors[@]}"; do
|
|
ble/color/gspec2sgr "fg=$color"
|
|
ble/array#push sgr "$ret"
|
|
done
|
|
fi
|
|
|
|
ble/util/c2w "$((0x2588))"; local w=$ret
|
|
ble/array#push grhbar_declare grhbar_wfactor="$((w==1?2:1))"
|
|
|
|
local i unit
|
|
unit[0]=' '
|
|
for ((i=1;i<=nlevel;i++)); do
|
|
ble/util/c2s "$((0x2590-i))"
|
|
ble/array#push unit "$ret"
|
|
done
|
|
|
|
ble/array#push grhbar_declare grhbar_unit0=' '
|
|
for ((i=1;i<=nlevel;i++)); do
|
|
ble/array#push grhbar_declare "grhbar_unit$i=${unit[i]}"
|
|
done
|
|
ble/array#push grhbar_declare grhbar_nlevel="$nlevel"
|
|
else
|
|
if ((${#colors[@]})); then
|
|
sgr[0]=$_ble_term_sgr0
|
|
local color
|
|
for color in "${colors[@]}"; do
|
|
ble/color/gspec2sgr "bg=$color"
|
|
ble/array#push sgr "$ret"
|
|
done
|
|
fi
|
|
ble/array#push grhbar_declare grhbar_nlevel=1 grhbar_unit0=' ' grhbar_unit1=' '
|
|
ble/array#push grhbar_declare grhbar_wfactor=2
|
|
fi
|
|
|
|
local glevel=$((${#sgr[@]}-1))
|
|
ble/array#push grhbar_declare grhbar_glevel="$glevel"
|
|
for ((i=0;i<=glevel;i++)); do
|
|
ble/array#push grhbar_declare "grhbar_sgr$i=${sgr[i]}"
|
|
done
|
|
}
|
|
_ble_histdb_grhbar_awk_lib='
|
|
function grhbar_initialize(_, i) {
|
|
grhbar_wfactor = ENVIRON["grhbar_wfactor"];
|
|
|
|
grhbar_nlevel = ENVIRON["grhbar_nlevel"];
|
|
for (i = 0; i <= grhbar_nlevel; i++)
|
|
grhbar_unit[i] = ENVIRON["grhbar_unit" i];
|
|
|
|
grhbar_glevel = ENVIRON["grhbar_glevel"];
|
|
if (grhbar_glevel > 0) {
|
|
for (i = 0; i <= grhbar_glevel; i++)
|
|
grhbar_sgr[i] = ENVIRON["grhbar_sgr" i];
|
|
} else {
|
|
grhbar_glevel = 0;
|
|
grhbar_sgr[0] = "";
|
|
grhbar_sgr[1] = "";
|
|
}
|
|
}
|
|
function grhbar__score2unit(score, score_max) {
|
|
if (score <= 0)
|
|
return grhbar_unit[0];
|
|
else
|
|
return grhbar_unit[1 + int((grhbar_nlevel - 1) * score / (score_max + 1))];
|
|
}
|
|
function grhbar__clamp(x, l, u) {
|
|
return x < l ? l : x > u ? u : x;
|
|
}
|
|
function grhbar_render(lines, list, w, h, _, x, y, maxv, line, s, sunit, color) {
|
|
w *= grhbar_wfactor;
|
|
maxv = 0;
|
|
for (y = 0; y < w; y++)
|
|
if (list[y] > maxv)
|
|
maxv = list[y];
|
|
for (y = 0; y < h; y++) {
|
|
line = ""
|
|
s = int((grhbar_nlevel * w + 1) * list[y] / (maxv + 1));
|
|
for (x = 0; x < w; x++) {
|
|
sunit = grhbar__clamp(s - x * grhbar_nlevel, 0, grhbar_nlevel);
|
|
color = grhbar_sgr[sunit ? grhbar__clamp(1 + int(grhbar_glevel * x / (w - 1)), 1, grhbar_glevel): 0];
|
|
line = line color grhbar_unit[sunit];
|
|
}
|
|
lines[y] = line grhbar_sgr[0];
|
|
}
|
|
}
|
|
'
|
|
|
|
#------------------------------------------------------------------------------
|
|
# usage: ble-histdb top [-x regex|-s regex]
|
|
|
|
function ble/histdb/sub:top/define {
|
|
label 'ble-histdb-top'
|
|
option exclude -x
|
|
option has_subcommand -s
|
|
option count -c
|
|
}
|
|
ble/getopts/generate-parser ble/histdb/sub:top/read-arguments ble/histdb/sub:top/define
|
|
|
|
function ble/histdb/sub:top {
|
|
local flags=
|
|
local -x exclude= has_subcommand= count=20
|
|
ble/histdb/sub:top/read-arguments "$@" || return 2
|
|
|
|
local grhbar_declare
|
|
ble/histdb/graph/hbar/initialize rainbow
|
|
local -x "${grhbar_declare[@]}" # disable=#D1566
|
|
|
|
local ret
|
|
ble/color/gspec2sgr 'bold'
|
|
local -x sgr_cmd=$ret
|
|
local -x sgr0=$_ble_term_sgr0
|
|
|
|
ble-histdb | ble/bin/awk '
|
|
BEGIN {
|
|
has_subcommand = "^(" ENVIRON["has_subcommand"] ")$";
|
|
to_exclude = "^(" ENVIRON["exclude"] ")$";
|
|
}
|
|
{
|
|
sub(/^[[:space:]]+/, "");
|
|
sub(/^\(\(?/, "& ");
|
|
if ($1 ~ to_exclude) next;
|
|
|
|
subcommand = "";
|
|
if ($1 ~ has_subcommand) {
|
|
for (i = 2; i <= NF; i++) {
|
|
if ($i ~ /^-.+/) continue;
|
|
subcommand = $i
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (subcommand != "") {
|
|
print $1 " " subcommand;
|
|
} else {
|
|
print $1;
|
|
}
|
|
}
|
|
' | ble/bin/sort | uniq -c | ble/bin/sort -nr | ble/bin/awk -v count="$count" '
|
|
'"$_ble_histdb_grhbar_awk_lib"'
|
|
BEGIN {
|
|
grhbar_initialize();
|
|
g_entry_count = 0;
|
|
sgr_cmd = ENVIRON["sgr_cmd"];
|
|
sgr0 = ENVIRON["sgr0"];
|
|
}
|
|
{
|
|
i = g_entry_count++;
|
|
g_score[i] = $1;
|
|
g_command[i] = $0;
|
|
if (g_entry_count >= count) exit;
|
|
}
|
|
END {
|
|
grhbar_render(lines_hbar, g_score, 6, g_entry_count);
|
|
for (i = 0; i < g_entry_count; i++) {
|
|
sub(/[0-9]+ /, "&[" lines_hbar[i] "] " sgr_cmd, g_command[i]);
|
|
print g_command[i] sgr0;
|
|
}
|
|
}
|
|
'
|
|
}
|
|
|
|
#------------------------------------------------------------------------------
|
|
# usage: ble-histdb calendar
|
|
# usage: ble-histdb week
|
|
|
|
function ble/histdb/sub:calendar {
|
|
local palette=$1
|
|
|
|
local grboard_export
|
|
ble/histdb/graph/board/initialize '' "$palette"
|
|
local -x "${grboard_export[@]}" # disable=#D1566
|
|
|
|
local grvbar_declare
|
|
ble/histdb/graph/vbar/initialize "$palette[2]"
|
|
local -x "${grvbar_declare[@]}" # disable=#D1566
|
|
|
|
local awk
|
|
if ble/is-function ble/bin/mawk; then
|
|
awk=ble/bin/mawk
|
|
elif ble/is-function ble/bin/gawk; then
|
|
awk=ble/bin/mawk
|
|
else
|
|
printf 'ble-histdb-calendar: gawk or mawk is needed.' >&2
|
|
return 1
|
|
fi
|
|
|
|
ble/histdb/sub:query -separator ' ' "SELECT strftime('%Y %j %w', issue_time, 'unixepoch', 'localtime') AS date FROM command_history;" |
|
|
sort | uniq -c | "$awk" '
|
|
'"$_ble_histdb_grboard_awk_lib"'
|
|
'"$_ble_histdb_grvbar_awk_lib"'
|
|
|
|
BEGIN {
|
|
grboard_initialize();
|
|
grvbar_initialize();
|
|
|
|
split("Sun,Mon,Tue,Wed,Thu,Fri,Sat, ", c_weekday, ",");
|
|
split("Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec", c_month, ",");
|
|
}
|
|
function initialize_year(year, _, i) {
|
|
g_year = year;
|
|
g_year_nday = 0 + strftime("%j", mktime(year " 12 31 01 00 00"));
|
|
g_year_wday_offset = 0 + strftime("%w", mktime(year " 01 01 01 00 00"));
|
|
g_score_max = 0;
|
|
g_score_total = 0;
|
|
for (i = -g_year_wday_offset; i < g_year_nday; i++)
|
|
g_score[i] = 0;
|
|
}
|
|
function flush_year(_, line, i, x, y, w, m, iday, iweek, lines, score_table, score_weekly) {
|
|
if (g_year == "" || g_year == 1970) return;
|
|
|
|
print "\x1b[1m# " g_year " (total = " g_score_total ", max = " g_score_max ")\x1b[m";
|
|
print "";
|
|
|
|
line = c_weekday[8];
|
|
x = 0;
|
|
for (m = 1; m <= 12; m++) {
|
|
iday = strftime("%j", mktime(g_year sprintf(" %02d 01 01 00 00", m))) - 1;
|
|
iweek = int((iday + g_year_wday_offset) / 7);
|
|
line = line sprintf("%*s", iweek * 2 - x, "") c_month[m];
|
|
x = iweek * 2 + length(c_month[m]);
|
|
}
|
|
print line;
|
|
|
|
# Fill score_table and score_weekly
|
|
w = 0;
|
|
for (i = -g_year_wday_offset; i < g_year_nday; i++) {
|
|
y = (i + g_year_wday_offset) % 7;
|
|
x = int((i + g_year_wday_offset) / 7);
|
|
if (x >= w) w = x + 1;
|
|
|
|
score_table[y, x] = i < 0 ? -1 : g_score[i];
|
|
score_weekly[x] += g_score[i];
|
|
}
|
|
|
|
grboard_render(lines, score_table, w, 7);
|
|
for (y = 0; y < 7; y++) print c_weekday[1 + y] lines[y];
|
|
|
|
grvbar_render(lines, score_weekly, w, 3);
|
|
for (y = 0; y < 3; y++) print c_weekday[8] lines[y];
|
|
|
|
print "";
|
|
}
|
|
|
|
$2 != g_year {
|
|
flush_year();
|
|
initialize_year($2);
|
|
}
|
|
{
|
|
yday = $3 - 1;
|
|
g_score[yday] = $1;
|
|
g_score_total += $1;
|
|
if ($1 > g_score_max)
|
|
g_score_max = $1;
|
|
}
|
|
|
|
END {
|
|
flush_year();
|
|
}
|
|
'
|
|
}
|
|
|
|
function ble/histdb/sub:week {
|
|
local palette=$1
|
|
|
|
local grboard_export
|
|
ble/histdb/graph/board/initialize '●' "$palette"
|
|
local -x "${grboard_export[@]}" # disable=#D1566
|
|
|
|
local grvbar_declare
|
|
ble/histdb/graph/vbar/initialize "$palette[2]"
|
|
local -x "${grvbar_declare[@]}" # disable=#D1566
|
|
|
|
local grhbar_declare
|
|
ble/histdb/graph/hbar/initialize "$palette[2]"
|
|
local -x "${grhbar_declare[@]}" # disable=#D1566
|
|
|
|
ble/histdb/sub:query -separator ' ' "SELECT strftime('%w %H', issue_time, 'unixepoch', 'localtime') AS date FROM command_history;" |
|
|
sort | uniq -c | ble/bin/awk '
|
|
'"$_ble_histdb_grboard_awk_lib"'
|
|
'"$_ble_histdb_grvbar_awk_lib"'
|
|
'"$_ble_histdb_grhbar_awk_lib"'
|
|
|
|
BEGIN {
|
|
grboard_initialize();
|
|
grvbar_initialize();
|
|
grhbar_initialize();
|
|
split("Sun,Mon,Tue,Wed,Thu,Fri,Sat, ", c_weekday, ",");
|
|
}
|
|
{
|
|
y = $2 + 0;
|
|
x = $3 + 0;
|
|
g_score[y, x] += $1;
|
|
g_score[x] += $1;
|
|
g_score_wday[y] += $1;
|
|
}
|
|
END {
|
|
line = c_weekday[8];
|
|
for (h = 0; h < 24; h++)
|
|
line = line sprintf(h % 3 == 0 ? "%02d" : " ", h);
|
|
print line;
|
|
|
|
grboard_render(lines, g_score, 24, 7);
|
|
grhbar_render(lines_hbar, g_score_wday, 4, 7);
|
|
for (y = 0; y < 7; y++) print c_weekday[1 + y] lines[y] lines_hbar[y];
|
|
|
|
grvbar_render(lines, g_score, 24, 3);
|
|
for (y = 0; y < 3; y++) print c_weekday[8] lines[y];
|
|
}
|
|
'
|
|
}
|