Finding file paths in a string

I modified gnome-terminal and added support for a custom url handler: src://
It lets you jump directly to line number in a file when you ctrl-click.

example src:///path/to/file:43

This is all good, but now I need some type of filter which converts all relative and absolute paths to absolute src links. Then I'd be able to pipe another programs output through it.

example

$ go build

# command-line-arguments
./test.go:3931: undefined: erre

I want something like this

$ go build | src-links

# command-line-arguments
src:///home/icholy/gocode/src/test/test.go:3931: undefined: erre

My first thought was to use a regex, but the only examples I found were paths already prefixed with a scheme/prototcol.

I'm stuck, so ideas/suggestions would be greatly appreciated. I'll be implementing it in go, but that's of little importance.

Very cool idea. File names however have a fairly general format, so I suspect you should only aim to cover a significant fraction of them, not all.

If you intend using this for programming work, then you might consider it acceptable to only match the sort of file names that many programmers consider good practice. ie the character set in the paths matches [A-Za-z0-9/_.-] . You also expect that what you are looking for is a filename followed by ':\d+', and that the line spec is not contiguous with other characters that look like they might be part of a line spec. That last bit can be done with forward and backward look-around assertions.

If you combine that with tests for file existence (relative to current or a specified directory), then you've got a pretty manageable scope, and a robust test.

So your file spec regex is something like this:

(?<![A-Za-z0-9/_.-])([A-Za-z0-9_.-]):(\d+)(?![A-Za-z0-9/_.-])

You should be able to convert most such file specs to absolute format by just appending them to the desired path, unless they start with a /.

$PATH/$file_path

It doesn't matter if the path starts with ./. The above works anyway, since /foo/./bar/baz is an acceptable path. Same with /foo/bar/../../bar/baz/xyz'\.

You should try to be sure that the spec you use here lines up with what your gnome terminal considers as part of the link.

Details on how you did the gnome terminal bit would be nice to see. It'd make this page more useful to others in future.

In addition to the regexp solution provided by mc0e, once you've found the strings with file names, you can pipe them through something like:

package main

import (
	"bufio"
	"fmt"
	"os"
	"path/filepath"
)

func checkLine(s string) bool {
	// Insert regex checking logic here. Just checking for blank line now.
	if s == "" {
		return false
	}
	return true
}

func srcerer(s string) (string, error) {
	p, err := filepath.Abs(s)
	if err != nil {
		return "", err
	}
	return "src:///" + p, nil
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	for scanner.Scan() {
		v := scanner.Text()
		if checkLine(v) {
			link, err := srcerer(v)
			if err != nil {
		        fmt.Fprintln(os.Stderr, "Error:", err)
				return
			}
			fmt.Println(link)
		}
	}
	if err := scanner.Err(); err != nil {
		fmt.Fprintln(os.Stderr, "reading standard input:", err)
	}
	return
}

Which, compiling the above code to a binary called src-links, and given a file called testlines.txt with the contents:

./test.go:14: undefined: erre
./test.go:16: undefined: erre
./test.go:21: undefined: erre
./test.go:27: undefined: erre

the command cat testlines.txt | src-links would output:

src:///home/icholy/gocode/src/test/test.go:14: undefined: erre
src:///home/icholy/gocode/src/test/test.go:16: undefined: erre
src:///home/icholy/gocode/src/test/test.go:21: undefined: erre
src:///home/icholy/gocode/src/test/test.go:27: undefined: erre