perl user input "dynamic/auto-tab expansion"

Question

I have an idea for a little command-line tool that would hopefully let me navigate directories quicker and I need to know if given a character from < STDIN > it is possible, from within perl, to automatically inject characters into < STDIN > dependent on the context (so it would look like an unsolicited tab-expansion if the circumstances are correct).

For example, supposing I had the following directories in some directory somewhere:

dir1 directory_2 test testing tested experiments

and contained in testing was the directories

fully_tested partially_tested 

then invocation of the script would first list all directories cd-able from where I called and wait for input. If the first character I entered was a 't' I would like to automatically inject 'est' into STDIN (since "test" is in the union of test, testing, and tested), list all directories beginning with "test" and wait for further input.

if the next char was either 'e' or 'i' it would cd automatically into tested or testing respectively (since these directories are then uniquely determined), if it was some yet to be decided "easy to reach key" like * I would cd into test, hitting '.' would do a cd .., and hitting any other alphabetic character would have no effect (and perhaps some other easy to reach key might list everything).

Getting back to the example, typing the chars 'tef' means I would cd into testing/fully_tested (since 'te' uniquely matches testing and the 'f' uniquely matches fully_tested)

As for actually coding this up I would like it to be my own problem (I believe it is possible to process input on a char by char basis) so to reiterate, all I'm asking here is:

---

Does perl provide some mechanism via which STDIN can be modified without user interaction (such that I can emulate tab-expand on the commandline, but with this expansion happening behind the scenes)? Or in other words, on evaluation of the last input I want to silently do the tab expansion (with it "looking like a tab expansion" wrt to my input stream, as per the commandline) without explicitly hitting a < TAB >

---

More detail: as far as I know what I am doing presently what I would end up with once coded up is something that would look like the following at runtime (suppose my home directory has the folders Desktop, Documents, Documents_bak, Downloads, Music)

Desktop/ Documents/ Documents_bak/ Downloads/ Music
D
Desktop/ Documents/ Documents_bak/ Downloads
o
Documents/ Documents_bak/ Downloads
c
Documents/ Documents_bak
_
programming/ books/ ...(other directories)

which doesn't look very nice... What I would actually like is something that resembled

Desktop/ Documents/ Documents_bak/ Downloads/ Music
D
Desktop/ Documents/ Documents_bak/ Downloads
Do
Documents/ Documents_bak/ Downloads
Documents
Documents/ Documents_bak
Documents_bak/
programming/ books/ ...(other directories)
Documents_bak/

where the last line "Documents_bak/" is actually the input stream as though I had typed it all (so I could delete some of it if I wanted). It is only how to achieve this little bit that presents a problem to me

EDIT* I am not (as far as I'm aware) trying to reinvent the wheel here - I'm just trying to cut out the < TAB >, < RET >, retype 'cd ' steps when changing directories. I.e. with my scheme it would take just "tef" to cd into testing/fully_tested yet just in bash I need "t< TAB >i< TAB >< RET >cd< SPACE >f< TAB >< RET >" to do the same.

Answer 1

Term::ReadKey may be the answer to your question. It is not guaranteed to work on all systems but it gives the control you asked for.

Here's an example that works nicely on my Ubuntu machine.

#!/usr/bin/perl
use strict;
use Term::ReadKey;

#a simple sub to return directories in supplied path 
sub list_dirs {
    my $path = shift;
    my @dirs;
    opendir DIR, $path or die "can't opendir '$path' : $!";
    my @dirs = grep {-d $path.'/'.$_} grep {$_ !~ m/^\.+$/} readdir DIR;
    closedir DIR;
    return @dirs;
}
#my start directory
my $home = '/path/to/startdir'; 
#my current directory, this will change
my $curdir = $home; 
#fetch the first list
my @dirs = list_dirs($curdir);

#read chars without pressing Enter
ReadMode 'cbreak'; 

#since we only need a char at a time
#we should remember our previous input
my $input;
#this var holds the real user input (without the autocomplete)
my $realinput;
#all the processing happens here, in the while loop, char by char
while (my $key = ReadKey(0)) {
    #validate input by allowed chars.
    #special chars like backspace, tab and enter can be handled separately
    if (ord($key) == 127) { #backspace
        chop $realinput;
        $input = $realinput;
        $key = '';
    #other special char checks can be added here
    } elsif ($key =~ m/^[\w\d\.\/\-]$/) { #allowed chars (more should be added)
        $realinput = $realinput.$key;
    } else {
        print "\ninvalid input\n$input";
        next; #ignore this char and ask for another
    }

    my @found = grep {$_ =~ m/^$input$key/} @dirs;
    #if we added a trailing slash or pressed enter, 
    #then limit our search to find one dir that exactly matches
    @found = grep {$_ =~ m/^$input$/} @dirs if ($key eq '/' || ord($key)==10);

    if  (scalar(@found) == 0) {
        #not dir matching, do nothing
        print "\nNo match\n$input";
    } elsif (scalar(@found) == 1) {
        #only one dir found
        #cd and reset input
        $curdir .= '/'.$found[0];
        my @dirs = list_dirs($curdir);
        $input = '';
        $realinput = '';
        print "\ncd to $curdir\n";
    } elsif (scalar(@found) > 1){
        print "\n".join(' ',map {$_.'/'} @found);
        $input .= $key;
        #find least match of matching dirs and autocomplete as much as possible 
        #assign the smallest matching string to $input and go to next loop
        for (my $i = length($input); $i <= length($found[0]); $i++) {
            my $matchcount = 0;
            my $tmpstr = substr($found[0], 0, $i);
            foreach my $d(@found) {
                $matchcount++ if ($d =~ m/^$tmpstr/);
            }
            if ($matchcount == scalar(@found)) {
                $input = $tmpstr;
            } else {
                last;
            }
        }
        print "\n$input";
    }
}

EDIT:

I've updated my script. Added autocomplete support like when pressing TAB in bash, and backspace support and checks for certain characters. Also I've added a trailing slash for listing the directories and another check for exact matches. So if you have directories Documents/ and Documents_bak/, pressing D in the input will autocomplete to Documents and you have to press / or Enter to cd to Documents/.

I think this script is a good way to show that everything is possible. However each goal requires certain amount of work. Replacing bash which is almost 1MB compiled with a perl script, is not a realistic goal. But the behavior you asked for is demonstrated exactly in this script. It can be enriched with more checks, more special keys handling and more code cleaning/optimising.