shithub: plumb-complete

Clone

Last commit

fixed doublefree and refactored. turns out duplicates werent a code issue but because i wasnt quote-escaping a variable name storing file data (ie using $c instead of $"c)

About

According to the complete manpage: 

     BUGS
          The behavior of file name completion should be controlled by
          the plumber.

This is an experiment in implementing this. It turns the singular file in libcomplete
into a standalone process that when daemonized listens for completion requests and 
fulfills them. Additionally, it also adds arbitrary prefix matching on text files.

This could hypothetically be used to simplify completion code in existing applications
and centralize it in the plumber. Prefixes can be plumbed to the completion port with 
a suffix response in the case of filenames and complete identifiers in the case of files
(identifier in the C sense). 

To set it up: 
1. Build the project (mkfile to come soon hopefully):
	% 6c complete.c && tl -o complete complete.6 # For amd64, see 2c(1) for other compilers
	% complete & # to daemonize the process

2. Set up your plumbing file ($home/lib/plumbing):
	type is text
	dst is completion
	plumb to completion
	plumb to completion-response
Note that completion-response is just for demonstration, in reality you dont need it
and would set up your application to listen for a response.

3. Listen for completions:
	# in one window
	% cat /mnt/plumb/completion-response

	# in another, to see dir completions
	% plumb -d completion -a 'prefix=my-prefix' -w $home ''

	# or, for text completions from a file
	% c=`{cat myfile.txt}
	% plumb -d completion -a 'prefix=my-prefix' -a 'type=file' -w /usr/glenda $"c # quote is important!

Currently, completions within a file are handled by sending the entire text through the plumber. I
am not sure yet if this is the best approach, but it's the simplest and allows me to sidestep
namespacing problems. The alternative is to plumb the filename and allow complete to handle opening
and reading it, but this introduces issues if the plumber's namespace differs from the source proc's.

This approach benefits from centralizing completion in one place, freeing client applications from
the responsibility of having to implement completion logic. It also provides a consistent interface
for completions. With a more thorough implementation, it can also be more extensible, allowing
applications to specify what to mark as an identifier for completion. It's a starting point for
some interesting experimentation.

TODO
 * Write a mkfile
 * Add example support patches for Rio, Acme, etc.
 * Let the plumber decide what's an identifier
 * Make in-file completions return just the suffix (D'oh!)
 * Potentially migrate filename completion to work the same way as in-file completion,
   allowing for namespace-independant operation.