Show HN: tere – A Faster Alternative to cd+ls (github.com)

crossterm = "0.24.0"

dirs = "4.0.0"

regex = "1.5.4"

serde_json = "1.0"

serde = { version = "1.0", features = ["rc"] }

textwrap = "0.14"

unicode-segmentation = "1.7"

I guess one could write their own textwrap and probably also dirs, but other than that they all are probably vital to this tool.

The only reason this wouldn't be a problem in another language would be because that language already includes the functionality of such libraries

  tere v1.0.0
  ├── clap v3.0.10
  │   ├── bitflags v1.3.2
  │   ├── indexmap v1.8.0
  │   │   └── hashbrown v0.11.2
  │   │   [build-dependencies]
  │   │   └── autocfg v1.1.0
  │   ├── os_str_bytes v6.0.0
  │   │   └── memchr v2.4.1
  │   ├── strsim v0.10.0
  │   ├── terminal_size v0.1.17
  │   │   └── libc v0.2.126
  │   └── textwrap v0.14.2
  │       ├── smawk v0.3.1
  │       ├── terminal_size v0.1.17 (*)
  │       ├── unicode-linebreak v0.1.2
  │       │   [build-dependencies]
  │       │   └── regex v1.5.4
  │       │       ├── aho-corasick v0.7.18
  │       │       │   └── memchr v2.4.1
  │       │       ├── memchr v2.4.1
  │       │       └── regex-syntax v0.6.25
  │       └── unicode-width v0.1.9
  ├── crossterm v0.24.0
  │   ├── bitflags v1.3.2
  │   ├── libc v0.2.126
  │   ├── mio v0.8.4
  │   │   ├── libc v0.2.126
  │   │   └── log v0.4.14
  │   │       └── cfg-if v1.0.0
  │   ├── parking_lot v0.12.1
  │   │   ├── lock_api v0.4.7
  │   │   │   └── scopeguard v1.1.0
  │   │   │   [build-dependencies]
  │   │   │   └── autocfg v1.1.0
  │   │   └── parking_lot_core v0.9.3
  │   │       ├── cfg-if v1.0.0
  │   │       ├── libc v0.2.126
  │   │       └── smallvec v1.8.0
  │   ├── signal-hook v0.3.13
  │   │   ├── libc v0.2.126
  │   │   └── signal-hook-registry v1.4.0
  │   │       └── libc v0.2.126
  │   └── signal-hook-mio v0.2.3
  │       ├── libc v0.2.126
  │       ├── mio v0.8.4 (*)
  │       └── signal-hook v0.3.13 (*)
  ├── dirs v4.0.0
  │   └── dirs-sys v0.3.6
  │       └── libc v0.2.126
  ├── regex v1.5.4 (*)
  ├── serde v1.0.134
  ├── serde_json v1.0.75
  │   ├── itoa v1.0.1
  │   ├── ryu v1.0.9
  │   └── serde v1.0.134
  ├── textwrap v0.14.2 (*)
  └── unicode-segmentation v1.8.0

Having over fifty dependencies for something like this is not in any way terrifying—you’re just starting with a different set of expectations and understandings of how things are done. It’s a natural and reasonable outworking of (a) using the right tools for the job, (b) doing things properly rather than half-heartedly (most obviously where terminal interactions are involved), and (c) Rust’s deliberately thin standard library.

But you're right that it could always be simpler, in fact I wrote tere originally in C with curses as the only dependency, and it compiles >10x faster. But there I had to manually write some (pretty certainly buggy) unicode handling, and I think adding extra features (proper arg parsing, json for history file etc) would be way more painful.

The answer to your question "How come a simple thing is more complex than I first thought?" is: "Because you've spent less time thinking about it than the author".

I recommend either CBT or writing your own version with fewer dependencies to ease your terror.

The deps for each of these packages is really out of the authors hands, this is really the same for any programming language though which need to pull in dependencies of their own.

Also netrw is a bit of a mess; I once found a bug and thought "I'll write a patch". After five minutes of browsing through the code ([insert Eddie Murphy meme]): "yeah, never mind".

”Tere” is also, perhaps unsurprisingly, used in Finnish.

I used screenkey to display the keystrokes and Peek to record the gif. I actually wrote some instructions for myself so I remember how I did it if I want to update the gif: https://github.com/mgunyho/tere/blob/master/demo/README.md

Very well executed.

I'm not sure there's a level between fifth and "being obnoxiously pushy," but if there's such a thing, I'd be interested to know. :)

I'll add ~ as a shortcut for the home directory, thanks for the good idea! (It conflicts with type-to-search for folders starting with '~', but I think that's much less common than cding to home.)

The auto-cd can also be turned off with a CLI option.

I think the word you are looking for is “indirectly”.

I think you're underestimating how efficient your brain can get at guesstimating how many characters are required to navigate to a directory, especially when the directory structure is familiar (at which point I virtually never overshoot).

And, I still find value in this feature despite being a fast typist (90 WPM).

[1]: https://github.com/junegunn/fzf#key-bindings-for-command-lin...

While digging up alternatives (of course after I had already written most of the functionality), I briefly tried out fzf. I think at that time I couldn't find an example snippet like yours to do the cding, so I didn't look into it much more. With some basic settings, it was also not easy (or even possible?) to go up in the folder tree, but I see that your example handles that.

If you're unfamiliar with a big folder tree, fzf (or another very similar tool that is designed for this purpose, broot) can be more efficient. But it might take a while for it to scan all subfolders.

I've been sporting this alias for a while now:

    alias pf="fzf --preview='less {}' --bind shift-up:preview-page-up,shift-down:preview-page-down"

fzf is great.

  function fcd() {
    local dir;
  
    while true; do
      # exit with ^D
      dir="$(ls -a1F | grep '[/@]$' | grep -v '^./$' | sed 's/@$//' | fzf --height 40% --reverse --no-multi --preview 'pwd' --preview-window=up,1,border-none --no-info)"
      if [[ -z "${dir}" ]]; then
        break
      elif [[ -d "${dir}" ]]; then
        cd "${dir}"
      fi
    done
  }

    # For fuzzy-jumping down your home directory.
    # See http://richardmavis.info/fuzzy-jumping
    function fcd {
        cache=~/.config/home-dirs-list
        if (( $# == 0 )); then
            if [ -e $cache ]; then
                cd "`fzf --height=10 < ${cache}`"
            else
                echo "No directory cache."
                cd `find ~ -type d | fzf --height=10`
            fi
        elif (( $# == 1 )); then
            if [[ $1 == "--cache" ]]; then
                echo "Making home directory cache."
                find ~ -type d | sort > $cache
            elif [ -e $cache ]; then
                cd "`cat ${cache} | grep $1 | fzf --height=10`"
            else
                echo "No directory cache."
                cd `find $1 -type d | fzf --height=10`
            fi
        else
            echo "Usage: fcd [DIR]|--cache"
        fi
    }

bind -x '"\C-p": cd "$(dirname "$(fd | fzf )")"'

To compile it, I had to sudo apt-get install libacl1-dev, which was not mentioned in the instructions.

https://github.com/gokcehan/lf