Fix failing tests and path parsing on Windows

commands/completion_command.go

@@ -56,7 +56,7 @@ func (c *CompletionCommand) Run(args []string) int {
 		return 1
 	}
 
-	lspUri := lsp.DocumentURI("file://" + path)
+	lspUri := ilsp.FileHandlerFromPath(path).DocumentURI()
 	parts := strings.Split(c.atPos, ":")
 	if len(parts) != 2 {
 		c.Ui.Error(fmt.Sprintf("Error parsing at-pos argument: %q (expected line:col format)\n", c.atPos))

internal/filesystem/errors.go

@@ -9,5 +9,5 @@ type FileNotOpenErr struct {
 }
 
 func (e *FileNotOpenErr) Error() string {
-	return fmt.Sprintf("file is not open: %s", e.FileHandler.DocumentURI())
+	return fmt.Sprintf("file is not open: %s", e.FileHandler.URI())
 }

internal/filesystem/file.go

@@ -24,8 +24,6 @@ func NewFile(fullPath string, content []byte) *file {
 	return &file{fullPath: fullPath, content: content}
 }
 
-const uriPrefix = "file://"
-
 func (f *file) FullPath() string {
 	return f.fullPath
 }
@@ -38,8 +36,8 @@ func (f *file) Filename() string {
 	return filepath.Base(f.FullPath())
 }
 
-func (f *file) DocumentURI() string {
-	return uriPrefix + f.fullPath
+func (f *file) URI() string {
+	return URIFromPath(f.fullPath)
 }
 
 func (f *file) Lines() source.Lines {

internal/filesystem/filesystem_test.go

@@ -178,7 +178,7 @@ type testHandler struct {
 	uri string
 }
 
-func (fh *testHandler) DocumentURI() string {
+func (fh *testHandler) URI() string {
 	return fh.uri
 }
 

internal/filesystem/types.go

@@ -27,7 +27,7 @@ type VersionedFileHandler interface {
 }
 
 type FileHandler interface {
-	DocumentURI() string
+	URI() string
 	FullPath() string
 	Dir() string
 	Filename() string

internal/filesystem/uri.go

@@ -0,0 +1,17 @@
+package filesystem
+
+import (
+	"net/url"
+	"path/filepath"
+)
+
+func URIFromPath(path string) string {
+	p := filepath.ToSlash(path)
+	p = wrapPath(p)
+
+	u := &url.URL{
+		Scheme: "file",
+		Path:   p,
+	}
+	return u.String()
+}

internal/filesystem/uri_unix.go

@@ -0,0 +1,8 @@
+// +build !windows
+
+package filesystem
+
+// wrapPath is no-op for unix-style paths
+func wrapPath(path string) string {
+	return path
+}

internal/filesystem/uri_unix_test.go

@@ -0,0 +1,18 @@
+// +build !windows
+
+package filesystem
+
+import (
+	"testing"
+)
+
+func TestURIFromPath(t *testing.T) {
+	path := "/random/path"
+	uri := URIFromPath(path)
+
+	expectedURI := "file:///random/path"
+	if uri != expectedURI {
+		t.Fatalf("URI doesn't match.\nExpected: %q\nGiven: %q",
+			expectedURI, uri)
+	}
+}

internal/filesystem/uri_windows.go

@@ -0,0 +1,8 @@
+package filesystem
+
+// wrapPath prepends Windows-style paths (C:\path)
+// with an additional slash to account for an empty hostname
+// in a valid file-scheme URI per RFC 8089
+func wrapPath(path string) string {
+	return "/" + path
+}

internal/filesystem/uri_windows_test.go

@@ -0,0 +1,16 @@
+package filesystem
+
+import (
+	"testing"
+)
+
+func TestURIFromPath(t *testing.T) {
+	path := `C:\Users\With Space\file.tf`
+	uri := URIFromPath(path)
+
+	expectedURI := "file:///C:/Users/With%20Space/file.tf"
+	if uri != expectedURI {
+		t.Fatalf("URI doesn't match.\nExpected: %q\nGiven: %q",
+			expectedURI, uri)
+	}
+}

internal/lsp/file.go

@@ -6,7 +6,7 @@ import (
 )
 
 type File interface {
-	DocumentURI() string
+	URI() string
 	FullPath() string
 	Dir() string
 	Filename() string
@@ -19,8 +19,8 @@ type file struct {
 	text []byte
 }
 
-func (f *file) DocumentURI() string {
-	return f.fh.DocumentURI()
+func (f *file) URI() string {
+	return f.fh.URI()
 }
 
 func (f *file) FullPath() string {

internal/lsp/file_handler.go

@@ -3,34 +3,29 @@ package lsp
 import (
 	"net/url"
 	"path/filepath"
-	"strings"
 
+	"github.com/hashicorp/terraform-ls/internal/filesystem"
 	"github.com/sourcegraph/go-lsp"
 )
 
-const uriPrefix = "file://"
-
 type FileHandler string
 
 func (fh FileHandler) Valid() bool {
-	if !strings.HasPrefix(string(fh), uriPrefix) {
-		return false
-	}
-	p := string(fh[len(uriPrefix):])
-	_, err := url.PathUnescape(p)
+	_, err := fh.parsePath()
 	if err != nil {
 		return false
 	}
+
 	return true
 }
 
-func (fh FileHandler) FullPath() string {
-	if !fh.Valid() {
-		panic("invalid uri")
+func (fh FileHandler) parsePath() (string, error) {
+	u, err := url.ParseRequestURI(string(fh))
+	if err != nil {
+		return "", err
 	}
-	p := string(fh[len(uriPrefix):])
-	p, _ = url.PathUnescape(p)
-	return filepath.FromSlash(p)
+
+	return url.PathUnescape(u.Path)
 }
 
 func (fh FileHandler) Dir() string {
@@ -41,7 +36,11 @@ func (fh FileHandler) Filename() string {
 	return filepath.Base(fh.FullPath())
 }
 
-func (fh FileHandler) DocumentURI() string {
+func (fh FileHandler) DocumentURI() lsp.DocumentURI {
+	return lsp.DocumentURI(fh)
+}
+
+func (fh FileHandler) URI() string {
 	return string(fh)
 }
 
@@ -60,3 +59,7 @@ func VersionedFileHandler(doc lsp.VersionedTextDocumentIdentifier) *versionedFil
 func (fh *versionedFileHandler) Version() int {
 	return fh.v
 }
+
+func FileHandlerFromPath(path string) FileHandler {
+	return FileHandler(filesystem.URIFromPath(path))
+}

internal/lsp/file_handler_test.go

@@ -4,42 +4,15 @@ import (
 	"testing"
 )
 
+var (
+	validUnixPath    = "file:///valid/path/to/file.tf"
+	validWindowsPath = "file:///C:/Users/With%20Space/tf-test/file.tf"
+)
+
 func TestFileHandler_invalid(t *testing.T) {
 	path := "invalidpath"
 	fh := FileHandler(path)
 	if fh.Valid() {
 		t.Fatalf("Expected %q to be invalid", path)
 	}
 }
-
-func TestFileHandler_valid(t *testing.T) {
-	path := "file://valid/path/to/file.tf"
-	fh := FileHandler(path)
-	if !fh.Valid() {
-		t.Fatalf("Expected %q to be valid", path)
-	}
-
-	expectedDir := "valid/path/to"
-	if fh.Dir() != expectedDir {
-		t.Fatalf("Expected dir: %q, given: %q",
-			expectedDir, fh.Dir())
-	}
-
-	expectedFilename := "file.tf"
-	if fh.Filename() != expectedFilename {
-		t.Fatalf("Expected filename: %q, given: %q",
-			expectedFilename, fh.Filename())
-	}
-
-	expectedFullPath := "valid/path/to/file.tf"
-	if fh.FullPath() != expectedFullPath {
-		t.Fatalf("Expected full path: %q, given: %q",
-			expectedFullPath, fh.FullPath())
-	}
-
-	expectedDocumentURI := "file://valid/path/to/file.tf"
-	if fh.DocumentURI() != expectedDocumentURI {
-		t.Fatalf("Expected document URI: %q, given: %q",
-			expectedDocumentURI, fh.DocumentURI())
-	}
-}

internal/lsp/file_handler_unix.go

@@ -0,0 +1,16 @@
+// +build !windows
+
+package lsp
+
+import (
+	"path/filepath"
+)
+
+func (fh FileHandler) FullPath() string {
+	p, err := fh.parsePath()
+	if err != nil {
+		panic("invalid uri")
+	}
+
+	return filepath.FromSlash(p)
+}

internal/lsp/file_handler_unix_test.go

@@ -0,0 +1,37 @@
+// +build !windows
+
+package lsp
+
+import (
+	"testing"
+)
+
+func TestFileHandler_valid_unix(t *testing.T) {
+	fh := FileHandler(validUnixPath)
+	if !fh.Valid() {
+		t.Fatalf("Expected %q to be valid", validUnixPath)
+	}
+
+	expectedDir := "/valid/path/to"
+	if fh.Dir() != expectedDir {
+		t.Fatalf("Expected dir: %q, given: %q",
+			expectedDir, fh.Dir())
+	}
+
+	expectedFilename := "file.tf"
+	if fh.Filename() != expectedFilename {
+		t.Fatalf("Expected filename: %q, given: %q",
+			expectedFilename, fh.Filename())
+	}
+
+	expectedFullPath := "/valid/path/to/file.tf"
+	if fh.FullPath() != expectedFullPath {
+		t.Fatalf("Expected full path: %q, given: %q",
+			expectedFullPath, fh.FullPath())
+	}
+
+	if fh.URI() != validUnixPath {
+		t.Fatalf("Expected document URI: %q, given: %q",
+			validUnixPath, fh.URI())
+	}
+}

internal/lsp/file_handler_windows.go

@@ -0,0 +1,21 @@
+package lsp
+
+import (
+	"path/filepath"
+	"strings"
+)
+
+// FullPath on Windows strips the leading '/'
+// which occurs in Windows-style paths (e.g. file:///C:/)
+// as url.URL methods don't account for that
+// (see golang/go#6027).
+func (fh FileHandler) FullPath() string {
+	p, err := fh.parsePath()
+	if err != nil {
+		panic("invalid uri")
+	}
+
+	p = strings.TrimPrefix(p, "/")
+
+	return filepath.FromSlash(p)
+}

internal/lsp/file_handler_windows_test.go

@@ -0,0 +1,36 @@
+package lsp
+
+import (
+	"testing"
+)
+
+func TestFileHandler_valid_windows(t *testing.T) {
+	path := "file:///C:/Users/With%20Space/tf-test/file.tf"
+	fh := FileHandler(path)
+	if !fh.Valid() {
+		t.Fatalf("Expected %q to be valid", path)
+	}
+
+	expectedDir := `C:\Users\With Space\tf-test`
+	if fh.Dir() != expectedDir {
+		t.Fatalf("Expected dir: %q, given: %q",
+			expectedDir, fh.Dir())
+	}
+
+	expectedFilename := "file.tf"
+	if fh.Filename() != expectedFilename {
+		t.Fatalf("Expected filename: %q, given: %q",
+			expectedFilename, fh.Filename())
+	}
+
+	expectedFullPath := `C:\Users\With Space\tf-test\file.tf`
+	if fh.FullPath() != expectedFullPath {
+		t.Fatalf("Expected full path: %q, given: %q",
+			expectedFullPath, fh.FullPath())
+	}
+
+	if fh.URI() != validWindowsPath {
+		t.Fatalf("Expected document URI: %q, given: %q",
+			validWindowsPath, fh.URI())
+	}
+}

internal/lsp/position.go

@@ -19,8 +19,8 @@ func (p *filePosition) Position() hcl.Pos {
 	return p.pos
 }
 
-func (p *filePosition) DocumentURI() string {
-	return p.fh.DocumentURI()
+func (p *filePosition) URI() string {
+	return p.fh.URI()
 }
 
 func (p *filePosition) FullPath() string {