support dynamic directories in dir prompt and fix a dozen bugs

functions/utilities.zsh

@@ -86,98 +86,6 @@ segment_in_use() {
      -n "${POWERLEVEL9K_RIGHT_PROMPT_ELEMENTS[(r)${key}_joined]}" ]]
 }
 
-################################################################
-# Given a directory path, truncate it according to the settings.
-# Parameters:
-#   * $1 Path: string - the directory path to be truncated
-#   * $2 Length: integer - length to truncate to
-#   * $3 Delimiter: string - the delimiter to use
-#   * $4 From: string - "right" | "middle". If omited, assumes right.
-function truncatePath() {
-  # if the current path is not 1 character long (e.g. "/" or "~")
-  if (( ${#1} > 1 )); then
-    # convert $2 from string to integer
-    2=$(( $2 ))
-    # set $3 to "" if not defined
-    [[ -z $3 ]] && 3="" || 3=$(echo -n $3)
-    # set $4 to "right" if not defined
-    [[ -z $4 ]] && 4="right"
-    # create a variable for the truncated path.
-    local trunc_path
-    # if the path is in the home folder, add "~/" to the start otherwise "/"
-    [[ $1 == "~"* ]] && trunc_path='~/' || trunc_path='/'
-    # split the path into an array using "/" as the delimiter
-    local paths=$1
-    paths=(${(s:/:)${paths//"~\/"/}})
-    # declare locals for the directory being tested and its length
-    local test_dir test_dir_length
-    # do the needed truncation
-    case $4 in
-      right)
-        # include the delimiter length in the threshhold
-        local threshhold=$(( $2 + ${#3} ))
-        # loop through the paths
-        for (( i=1; i<${#paths}; i++ )); do
-          # get the current directory value
-          test_dir=$paths[$i]
-          test_dir_length=${#test_dir}
-          # only truncate if the resulting truncation will be shorter than
-          # the truncation + delimiter length and at least 3 characters
-          if (( $test_dir_length > $threshhold )) && (( $test_dir_length > 3 )); then
-            # use the first $2 characters and the delimiter
-            trunc_path+="${test_dir:0:$2}$3/"
-          else
-            # use the full path
-            trunc_path+="${test_dir}/"
-          fi
-        done
-      ;;
-      middle)
-        # we need double the length for start and end truncation + delimiter length
-        local threshhold=$(( $2 * 2 ))
-        # create a variable for the start of the end truncation
-        local last_pos
-        # loop through the paths
-        for (( i=1; i<${#paths}; i++ )); do
-          # get the current directory value
-          test_dir=$paths[$i]
-          test_dir_length=${#test_dir}
-          # only truncate if the resulting truncation will be shorter than
-          # the truncation + delimiter length
-          if (( $test_dir_length > $threshhold )); then
-            # use the first $2 characters, the delimiter and the last $2 characters
-            last_pos=$(( $test_dir_length - $2 ))
-            trunc_path+="${test_dir:0:$2}$3${test_dir:$last_pos:$test_dir_length}/"
-          else
-            # use the full path
-            trunc_path+="${test_dir}/"
-          fi
-        done
-      ;;
-    esac
-    # return the truncated path + the current directory
-    echo $trunc_path${1:t}
-  else # current path is 1 character long (e.g. "/" or "~")
-    echo $1
-  fi
-}
-
-# Search recursively in parent folders for given file.
-function upsearch () {
-  if [[ "$PWD" == "$HOME" || "$PWD" == "/" ]]; then
-    echo "$PWD"
-  elif test -e "$1"; then
-    pushd .. > /dev/null
-    upsearch "$1"
-    popd > /dev/null
-    echo "$PWD"
-  else
-    pushd .. > /dev/null
-    upsearch "$1"
-    popd > /dev/null
-  fi
-}
-
 # Parse IP address from ifconfig on OSX and from IP on Linux
 # Parameters:
 #  $1 - string The desired Interface

powerlevel9k.zsh-theme

@@ -145,19 +145,22 @@ _p9k_get_icon() {
 typeset -ga _P9K_LEFT_JOIN=(1)
 typeset -ga _P9K_RIGHT_JOIN=(1)
 
+_p9k_translate_color() {
+  if [[ $1 == <-> ]]; then     # decimal color code: 255
+    _P9K_RETVAL=${(l:3::0:)1}
+  elif [[ $1 == '#'* ]]; then  # hexademical color code: #ffffff
+    _P9K_RETVAL=$1
+  else                         # named color: red
+    # Strip prifixes if there are any.
+    _P9K_RETVAL=$__P9K_COLORS[${${${1#bg-}#fg-}#br}]
+  fi
+}
+
 # Resolves a color to its numerical value, or an empty string. Communicates the result back
 # by setting _P9K_RETVAL.
 _p9k_color() {
   local user_var=POWERLEVEL9K_${(U)${2}#prompt_}_${3}
-  local color=${${(P)user_var}:-${1}}
+  _p9k_translate_color ${${(P)user_var}:-${1}}
-  if [[ $color == <-> ]]; then     # decimal color code: 255
-    _P9K_RETVAL=${(l:3::0:)color}
-  elif [[ $color == '#'* ]]; then  # hexademical color code: #ffffff
-    _P9K_RETVAL=$color
-  else                             # named color: red
-    # Strip prifixes if there are any.
-    _P9K_RETVAL=$__P9K_COLORS[${${${color#bg-}#fg-}#br}]
-  fi
 }
 
 _p9k_background() {
@@ -781,31 +784,6 @@ prompt_command_execution_time() {
   "$1_prompt_segment" "$0" "$2" "red" "yellow1" 'EXECUTION_TIME_ICON' 0 '' "${humanReadableDuration}"
 }
 
-################################################################
-# Determine the unique path - this is needed for the
-# truncate_to_unique strategy.
-#
-function getUniqueFolder() {
-  local trunc_path directory test_dir test_dir_length
-  local -a matching
-  local -a paths
-  local cur_path='/'
-  paths=(${(s:/:)1})
-  for directory in ${paths[@]}; do
-    test_dir=''
-    for (( i=0; i < ${#directory}; i++ )); do
-      test_dir+="${directory:$i:1}"
-      matching=("$cur_path"/"$test_dir"*/)
-      if [[ ${#matching[@]} -eq 1 ]]; then
-        break
-      fi
-    done
-    trunc_path+="$test_dir/"
-    cur_path+="$directory/"
-  done
-  echo "${trunc_path: : -1}"
-}
-
 ################################################################
 # Dir: current working directory
 # Parameters:
@@ -824,247 +802,176 @@ set_default POWERLEVEL9K_SHORTEN_FOLDER_MARKER ".shorten_folder_marker"
 set_default -i POWERLEVEL9K_SHORTEN_DIR_LENGTH -1
 set_default -a POWERLEVEL9K_DIR_PACKAGE_FILES package.json composer.json
 prompt_dir() {
-  # using $PWD instead of "$(print -P '%~')" to allow use of POWERLEVEL9K_DIR_PATH_ABSOLUTE
+  [[ $POWERLEVEL9K_DIR_PATH_ABSOLUTE == true ]] && local p=$PWD || local p=${(%):-%~}
-  local current_path=$PWD # WAS: local current_path="$(print -P '%~')"
+
-  [[ "${POWERLEVEL9K_DIR_SHOW_WRITABLE}" == true && ! -w "$PWD" ]]
+  if [[ $p == '~['* ]]; then
-  local -i writable=$?
+    # If "${(%):-%~}" expands to "~[a]/]/b", is the first component "~[a]" or "~[a]/]"?
-  if ! _p9k_cache_get "$0" "$2" "$current_path" "$writable"; then
+    # One would expect "${(%):-%-1~}" to give the right answer but alas it always simply
-    # check if the user wants to use absolute paths or "~" paths
+    # gives the segment before the first slash, which would be "~[a]" in this case. Worse,
-    [[ ${(L)POWERLEVEL9K_DIR_PATH_ABSOLUTE} != "true" ]] && current_path=${current_path/#$HOME/"~"}
+    # for "~[a/b]" it'll give the nonsensical "~a[". To solve this problem we have to
-    # declare all local variables
+    # repeat what "${(%):-%~}" does and hope that it produces the same result.
-    local paths directory test_dir test_dir_length trunc_path threshhold
+    local func=''
-    # if we are not in "~" or "/", split the paths into an array and exclude "~"
+    local -a parts=()
-    (( ${#current_path} > 1 )) && paths=(${(s:/:)${current_path//"~\/"/}}) || paths=()
+    for func in zsh_directory_name $zsh_directory_name_functions; do
-    # only run the code if SHORTEN_DIR_LENGTH is set, or we are using the two strategies that don't rely on it.
+      if (( $+functions[$func] )) && $func d $PWD && [[ $p == '~['$reply[1]']'* ]]; then
-    if [[ "$POWERLEVEL9K_SHORTEN_DIR_LENGTH" -ge 0 ||
+        parts+='~['$reply[1]']'
-          "$POWERLEVEL9K_SHORTEN_STRATEGY" == "truncate_with_folder_marker" ||
+        break
-          "$POWERLEVEL9K_SHORTEN_STRATEGY" == "truncate_to_last" ||
+      fi
-          "$POWERLEVEL9K_SHORTEN_STRATEGY" == "truncate_with_package_name" ]]; then
+    done
-      case "$POWERLEVEL9K_SHORTEN_STRATEGY" in
+    if (( $#parts )); then
-        truncate_absolute_chars)
+      parts+=(${(s:/:)${p#$parts[1]}})
-          if [ ${#current_path} -gt $(( $POWERLEVEL9K_SHORTEN_DIR_LENGTH + ${#POWERLEVEL9K_SHORTEN_DELIMITER} )) ]; then
+    else
-            current_path=$POWERLEVEL9K_SHORTEN_DELIMITER${current_path:(-POWERLEVEL9K_SHORTEN_DIR_LENGTH)}
+      p=$PWD
+      parts=("${(s:/:)p}")
+    fi
+  else
+    local -a parts=("${(s:/:)p}")
+  fi
+
+  local -i fake_first=0
+
+  case $POWERLEVEL9K_SHORTEN_STRATEGY in
+    truncate_absolute|truncate_absolute_chars)
+      if (( POWERLEVEL9K_SHORTEN_DIR_LENGTH > 0 && $#p > POWERLEVEL9K_SHORTEN_DIR_LENGTH )); then
+        local -i n=POWERLEVEL9K_SHORTEN_DIR_LENGTH
+        local -i i=$#parts
+        while true; do
+          local dir=$parts[i]
+          local -i len=$(( $#dir + (i > 1) ))
+          if (( len <= n )); then
+            (( n -= len ))
+            (( --i ))
+          else
+            parts[i]=$'\0'$dir[-n,-1]
+            parts[1,i-1]=()
+            break
+          fi
+        done
       fi
     ;;
-        truncate_middle)
+    truncate_with_package_name|truncate_middle|truncate_from_right)
-          # truncate characters from the middle of the path
+      () {
-          current_path=$(truncatePath $current_path $POWERLEVEL9K_SHORTEN_DIR_LENGTH $POWERLEVEL9K_SHORTEN_DELIMITER "middle")
+        [[ $POWERLEVEL9K_SHORTEN_STRATEGY == truncate_with_package_name ]] || return
-        ;;
+        local -i i=$#parts
-        truncate_from_right)
+        local pkg_dir=$PWD
-          # truncate characters from the right of the path
+        for (( ; i > 0; --i )); do
-          current_path=$(truncatePath "$current_path" $POWERLEVEL9K_SHORTEN_DIR_LENGTH $POWERLEVEL9K_SHORTEN_DELIMITER)
+          local fname=''
-        ;;
+          for fname in $POWERLEVEL9K_DIR_PACKAGE_FILES; do
-        truncate_absolute)
+            if [[ -f $pkg_dir/$fname ]]; then
-          # truncate all characters except the last POWERLEVEL9K_SHORTEN_DIR_LENGTH characters
+              local pkg_name=''
-          if [ ${#current_path} -gt $(( $POWERLEVEL9K_SHORTEN_DIR_LENGTH + ${#POWERLEVEL9K_SHORTEN_DELIMITER} )) ]; then
+              pkg_name=$(jq -j '.name' <$pkg_dir/$fname) && [[ -n $pkg_name ]] || return
-            current_path=$POWERLEVEL9K_SHORTEN_DELIMITER${current_path:(-POWERLEVEL9K_SHORTEN_DIR_LENGTH)}
+              parts[1,i]=($pkg_name)
+              fake_first=1
+              return
+            fi
+          done
+          pkg_dir=${pkg_dir:h}
+        done
+      }
+      if (( POWERLEVEL9K_SHORTEN_DIR_LENGTH > 0 )); then
+        local -i pref=$POWERLEVEL9K_SHORTEN_DIR_LENGTH suf=0 i=2
+        [[ $POWERLEVEL9K_SHORTEN_STRATEGY == truncate_middle ]] && suf=pref
+        for (( ; i < $#parts; ++i )); do
+          local dir=$parts[i]
+          if (( $#dir > pref + suf )); then
+            dir[pref+1,-suf-1]=$'\0'
+            parts[i]=$dir
+          fi
+        done
       fi
     ;;
     truncate_to_last)
-          # truncate all characters before the current directory
+      fake_first=$(($#parts > 1))
-          current_path=${current_path##*/}
+      parts[1,-2]=()
     ;;
     truncate_to_first_and_last)
-          if (( ${#current_path} > 1 )) && (( ${POWERLEVEL9K_SHORTEN_DIR_LENGTH} > 0 )); then
+      if (( POWERLEVEL9K_SHORTEN_DIR_LENGTH > 0 )); then
-            threshhold=$(( ${POWERLEVEL9K_SHORTEN_DIR_LENGTH} * 2))
+        local -i i=$(( POWERLEVEL9K_SHORTEN_DIR_LENGTH + 1 ))
-            # if we are in "~", add it back into the paths array
+        [[ $p == /* ]] && (( ++i ))
-            [[ $current_path == '~'* ]] && paths=("~" "${paths[@]}")
+        for (( ; i <= $#parts - POWERLEVEL9K_SHORTEN_DIR_LENGTH; ++i )); do
-            if (( ${#paths} > $threshhold )); then
+          parts[i]=$'\0'
-              local num=$(( ${#paths} - ${POWERLEVEL9K_SHORTEN_DIR_LENGTH} ))
-              # repace the middle elements
-              for (( i=$POWERLEVEL9K_SHORTEN_DIR_LENGTH; i<$num; i++ )); do
-                paths[$i+1]=$POWERLEVEL9K_SHORTEN_DELIMITER
         done
-              [[ $current_path != '~'* ]] && current_path="/" || current_path=""
-              current_path+="${(j:/:)paths}"
-            fi
       fi
     ;;
     truncate_to_unique)
-          # for each parent path component find the shortest unique beginning
+      local parent="${PWD%/${(pj./.)parts[2,-1]}}" dir
-          # characters sequence. Source: https://stackoverflow.com/a/45336078
+      local -i i=2
-          if (( ${#current_path} > 1 )); then # root and home are exceptions and won't have paths
+      for (( ; i <= $#parts; ++i )); do
-            # cheating here to retain ~ as home folder
+        local dir=$parts[i]
-            local home_path="$(getUniqueFolder $HOME)"
+        local -i j=1
-            trunc_path="$(getUniqueFolder $PWD)"
+        for (( ; j <= $#dir; ++j )); do
-            [[ $current_path == "~"* ]] && current_path="~${trunc_path//${home_path}/}" || current_path="/${trunc_path}"
+          local -a matching=($parent/$dir[1,j]*/)
-          fi
+          (( $#matching == 1 )) && break
+        done
+        parent+=/$dir
+        parts[i]=$dir[1,j]
+      done
     ;;
     truncate_with_folder_marker)
-          if (( ${#paths} > 0 )); then # root and home are exceptions and won't have paths, so skip this
+      local dir=$PWD
-            local last_marked_folder marked_folder
+      local -a m=()
-
+      local -i i=$(($#parts - 1))
-            # Search for the folder marker in the parent directories and
+      for (( ; i > 1; --i )); do
-            # buildup a pattern that is removed from the current path
+        dir=${dir:h}
-            # later on.
+        [[ -e $dir/$POWERLEVEL9K_SHORTEN_FOLDER_MARKER ]] && m+=$i
-            for marked_folder in $(upsearch $POWERLEVEL9K_SHORTEN_FOLDER_MARKER); do
-              if [[ "$marked_folder" == "/" ]]; then
-                # If we reached root folder, stop upsearch.
-                trunc_path="/"
-              elif [[ "$marked_folder" == "$HOME" ]]; then
-                # If we reached home folder, stop upsearch.
-                trunc_path="~"
-              elif [[ "${marked_folder%/*}" == $last_marked_folder ]]; then
-                trunc_path="${trunc_path%/}/${marked_folder##*/}"
-              else
-                trunc_path="${trunc_path%/}/$POWERLEVEL9K_SHORTEN_DELIMITER/${marked_folder##*/}"
-              fi
-              last_marked_folder=$marked_folder
       done
-
+      m+=1
-            # Replace the shortest possible match of the marked folder from
+      for (( i=1; i < $#m; ++i )); do
-            # the current path.
+        (( m[i] - m[i+1] > 2 )) && parts[m[i+1]+1,m[i]-1]=($'\0')
-            current_path=$trunc_path${current_path#${last_marked_folder}*}
-          fi
-        ;;
-        truncate_with_package_name)
-          local name repo_path package_path current_dir zero
-
-          # Get the path of the Git repo, which should have the package.json file
-          if [[ $(git rev-parse --is-inside-work-tree 2> /dev/null) == "true" ]]; then
-            # Get path from the root of the git repository to the current dir
-            local gitPath=$(git rev-parse --show-prefix)
-            # Remove trailing slash from git path, so that we can
-            # remove that git path from the pwd.
-            gitPath=${gitPath%/}
-            package_path=${PWD%%$gitPath}
-            # Remove trailing slash
-            package_path=${package_path%/}
-          elif [[ $(git rev-parse --is-inside-git-dir 2> /dev/null) == "true" ]]; then
-            package_path=${PWD%%/.git*}
-          fi
-
-         [[ ${(L)POWERLEVEL9K_DIR_PATH_ABSOLUTE} != "true" ]] && package_path=${package_path/$HOME/"~"}
-
-          # Replace the shortest possible match of the marked folder from
-          # the current path. Remove the amount of characters up to the
-          # folder marker from the left. Count only the visible characters
-          # in the path (this is done by the "zero" pattern; see
-          # http://stackoverflow.com/a/40855342/5586433).
-          local zero='%([BSUbfksu]|([FB]|){*})'
-          trunc_path=$PWD
-          # Then, find the length of the package_path string, and save the
-          # subdirectory path as a substring of the current directory's path from 0
-          # to the length of the package path's string
-          subdirectory_path=$(truncatePath "${trunc_path:${#${(S%%)package_path//$~zero/}}}" $POWERLEVEL9K_SHORTEN_DIR_LENGTH $POWERLEVEL9K_SHORTEN_DELIMITER)
-          # Parse the 'name' from the package.json; if there are any problems, just
-          # print the file path
-
-          local pkgFile="unknown"
-          for file in "${POWERLEVEL9K_DIR_PACKAGE_FILES[@]}"; do
-            if [[ -f "${package_path}/${file}" ]]; then
-              pkgFile="${package_path}/${file}"
-              break;
-            fi
       done
-
-          local packageName=$(jq '.name' ${pkgFile} 2> /dev/null \
-            || node -e 'console.log(require(process.argv[1]).name);' ${pkgFile} 2>/dev/null \
-            || cat "${pkgFile}" 2> /dev/null | grep -m 1 "\"name\"" | awk -F ':' '{print $2}' | awk -F '"' '{print $2}' 2>/dev/null \
-            )
-          if [[ -n "${packageName}" ]]; then
-            # Instead of printing out the full path, print out the name of the package
-            # from the package.json and append the current subdirectory
-            current_path="`echo $packageName | tr -d '"'`$subdirectory_path"
-          fi
     ;;
     *)
-          if [[ $current_path != "~" ]]; then
+      if (( POWERLEVEL9K_SHORTEN_DIR_LENGTH > 0 )); then
-            current_path="%$((POWERLEVEL9K_SHORTEN_DIR_LENGTH+1))(c:$POWERLEVEL9K_SHORTEN_DELIMITER/:)%${POWERLEVEL9K_SHORTEN_DIR_LENGTH}c"
+        local -i len=$#parts
-            current_path="${(%)current_path}"
+        [[ -z $parts[1] ]] && (( --len ))
+        if (( len > POWERLEVEL9K_SHORTEN_DIR_LENGTH )); then
+          parts[1,-POWERLEVEL9K_SHORTEN_DIR_LENGTH-1]=($'\0')
+        fi
       fi
     ;;
   esac
-    fi
 
-    current_path=${current_path//\%/%%}
+  parts=("${(@)parts//\%/%%}")
 
-    local path_opt=$current_path
+  local state='' icon=''
-    local current_state icon
+  if [[ $POWERLEVEL9K_DIR_SHOW_WRITABLE == true && ! -w $PWD ]]; then
-    if (( ! writable )); then
+    state=NOT_WRITABLE
-      current_state=NOT_WRITABLE
     icon=LOCK_ICON
   else
     case $PWD in
-        /etc*)
+      /etc|/etc/*) state=ETC;            icon=ETC_ICON;;
-          current_state=ETC
+      ~)           state=HOME;           icon=HOME_ICON;;
-          icon=ETC_ICON
+      ~/*)         state=HOME_SUBFOLDER; icon=HOME_SUB_ICON;;
-          ;;
+      *)           state=DEFAULT;        icon=FOLDER_ICON;;
-        ~)
-          current_state=HOME
-          icon=HOME_ICON
-          ;;
-        ~/*)
-          current_state=HOME_SUBFOLDER
-          icon=HOME_SUB_ICON
-          ;;
-        *)
-          current_state=DEFAULT
-          icon=FOLDER_ICON
-          ;;
     esac
   fi
 
-    # This is not what Powerlevel9k does but I cannot imagine anyone wanting ~/foo to become /foo.
+  _p9k_color "$DEFAULT_COLOR" "$0_$state" FOREGROUND
-    if [[ $POWERLEVEL9K_DIR_OMIT_FIRST_CHARACTER == true ]]; then
+  _p9k_foreground $_P9K_RETVAL
-      if [[ $current_path == /?* ]]; then
+  local style=$_P9K_RETVAL'%b'
-        current_path=${current_path[2,-1]}
+
-      elif [[ $current_path == '~'/?* ]]; then
+  [[ $fake_first == 0 && $parts[1] == '~' ]] && parts[1]=$POWERLEVEL9K_HOME_FOLDER_ABBREVIATION$style
-        current_path=${current_path[3,-1]}
+  [[ $POWERLEVEL9K_DIR_OMIT_FIRST_CHARACTER == true && $#parts > 1 && -n $parts[2] ]] && parts[1]=()
-      fi
+  parts=("${(@)parts//$'\0'/$POWERLEVEL9K_SHORTEN_DELIMITER$style}")
+
+  if [[ -n $POWERLEVEL9K_DIR_PATH_HIGHLIGHT_FOREGROUND ]]; then
+    _p9k_translate_color $POWERLEVEL9K_DIR_PATH_HIGHLIGHT_FOREGROUND
+    _p9k_foreground $_P9K_RETVAL
+    parts[-1]=$_P9K_RETVAL$parts[-1]
   fi
 
-    if [[ $POWERLEVEL9K_HOME_FOLDER_ABBREVIATION != '~' &&
-          $POWERLEVEL9K_DIR_OMIT_FIRST_CHARACTER != true &&
-          $path_opt == '~'?* ]]; then
-      current_path=${POWERLEVEL9K_HOME_FOLDER_ABBREVIATION}${current_path[2,-1]}
-    fi
-
-    local bld_on bld_off dir_state_foreground dir_state_user_foreground
-    # test if user wants the last directory printed in bold
   if [[ $POWERLEVEL9K_DIR_PATH_HIGHLIGHT_BOLD == true ]]; then
-      bld_on="%B"
+    parts[-1]='%B'$parts[-1]'%b'
-      bld_off="%b"
-    else
-      bld_on=""
-      bld_off=""
-    fi
-    # determine is the user has set a last directory color
-    local dir_state_user_foreground=POWERLEVEL9K_DIR_${current_state}_FOREGROUND
-    local dir_state_foreground=${${(P)dir_state_user_foreground}:-$DEFAULT_COLOR}
-
-    local dir_name=${${current_path:h}%/}/
-    local base_name=${current_path:t}
-    if [[ $dir_name == ./ ]]; then
-      dir_name=''
-    fi
-    # if the user wants the last directory colored...
-    if [[ -n ${POWERLEVEL9K_DIR_PATH_HIGHLIGHT_FOREGROUND} ]]; then
-      if [[ -z $base_name ]]; then
-        current_path="${bld_on}%F{$POWERLEVEL9K_DIR_PATH_HIGHLIGHT_FOREGROUND}${current_path}${bld_off}"
-      else
-        current_path="${dir_name}${bld_on}%F{$POWERLEVEL9K_DIR_PATH_HIGHLIGHT_FOREGROUND}${base_name}${bld_off}"
-      fi
-    else # no coloring
-      if [[ -z $base_name ]]; then
-        current_path="${bld_on}${current_path}${bld_off}"
-      else
-        current_path="${dir_name}${bld_on}${base_name}${bld_off}"
-      fi
-    fi
-    # check if the user wants the separator colored.
-    if [[ -n ${POWERLEVEL9K_DIR_PATH_SEPARATOR_FOREGROUND} ]]; then
-      local repl="%F{$POWERLEVEL9K_DIR_PATH_SEPARATOR_FOREGROUND}/%F{$dir_state_foreground}"
-      current_path=${current_path//\//$repl}
-    fi
-    if [[ "${POWERLEVEL9K_DIR_PATH_SEPARATOR}" != "/" ]]; then
-      current_path=${current_path//\//$POWERLEVEL9K_DIR_PATH_SEPARATOR}
   fi
 
-    _p9k_cache_set "$current_state" "$icon" "$current_path"
+  local sep=$POWERLEVEL9K_DIR_PATH_SEPARATOR$style
+  if [[ -n $POWERLEVEL9K_DIR_PATH_SEPARATOR_FOREGROUND ]]; then
+    _p9k_translate_color $POWERLEVEL9K_DIR_PATH_SEPARATOR_FOREGROUND
+    _p9k_foreground $_P9K_RETVAL
+    sep=$_P9K_RETVAL$sep
   fi
 
-  "$1_prompt_segment" "$0_${_P9K_CACHE_VAL[1]}" "$2" blue "$DEFAULT_COLOR" "${_P9K_CACHE_VAL[2]}" 0 "" "${_P9K_CACHE_VAL[3]}"
+  "$1_prompt_segment" "$0_$state" "$2" blue "$DEFAULT_COLOR" "$icon" 0 "" "${(pj.$sep.)parts}"
 }
 
 ################################################################
@@ -2450,6 +2357,12 @@ _p9k_init() {
     fi
   fi
 
+  if segment_in_use dir &&
+     [[ $POWERLEVEL9K_SHORTEN_STRATEGY == truncate_with_package_name && $+commands[jq] == 0 ]]; then
+    >&2 print -P '%F{yellow}WARNING!%f %BPOWERLEVEL9K_SHORTEN_STRATEGY=truncate_with_package_name%b requires %F{green}jq%f.'
+    >&2 print -P 'Either install %F{green}jq%f or change the value of %BPOWERLEVEL9K_SHORTEN_STRATEGY%b.'
+  fi
+
   zle -N zle-keymap-select _p9k_zle_keymap_select
 
   _P9K_INITIALIZED=1