Merge pull request #4 from nimblebun/feature/loose-checking

jozsefsallai · web-flow · commit 8b9b1de7b496 · 2021-04-06T13:22:48.000+03:00
add loose checking option for events and args
diff --git a/config/.tscrc.json b/config/.tscrc.json
@@ -3,6 +3,11 @@
     "maxMessageLineLength": {
       "plain": 35,
       "portrait": 28
+    },
+
+    "looseChecking": {
+      "events": false,
+      "arguments": false
     }
   },
 
diff --git a/config/config_test.go b/config/config_test.go
@@ -223,6 +223,10 @@ func TestUpdate(t *testing.T) {
 	"setup": {
 		"maxMessageLineLength": {
 			"portrait": 30
+		},
+
+		"looseChecking": {
+			"arguments": true
 		}
 	},
 
@@ -279,6 +283,14 @@ func TestUpdate(t *testing.T) {
 			)
 		}
 
+		if conf.Setup.LooseChecking.Arguments != true {
+			t.Errorf(
+				"config.Config#Update() -> Setup.LooseChecking.Arguments got %v, want %v",
+				conf.Setup.LooseChecking.Arguments,
+				true,
+			)
+		}
+
 		mim, found := conf.GetTSCDefinition("<MIM")
 
 		if !found {
diff --git a/config/config_types.go b/config/config_types.go
@@ -12,9 +12,18 @@ type MaxMessageLineLength struct {
 	Portrait int `json:"portrait,omitempty"`
 }
 
+// LooseChecking specifies whether the language server should perform checks on
+// event IDs and arguments in a loosely fashion. For more information, see:
+// https://docs.nimblebun.works/tscrc-json#setup-loose-checking
+type LooseChecking struct {
+	Events    bool `json:"events,omitempty"`
+	Arguments bool `json:"arguments,omitempty"`
+}
+
 // SetupConfig contains options for the TSC diagnostics
 type SetupConfig struct {
-	MaxMessageLineLength `json:"maxMessageLineLength,omitempty"`
+	MaxMessageLineLength MaxMessageLineLength `json:"maxMessageLineLength,omitempty"`
+	LooseChecking        LooseChecking        `json:"looseChecking,omitempty"`
 }
 
 // TSCDefinition is the definition of a TSC command
diff --git a/config/default.go b/config/default.go
@@ -10,6 +10,11 @@ var DefaultConfig = []byte(`{
     "maxMessageLineLength": {
       "plain": 35,
       "portrait": 28
+    },
+
+    "looseChecking": {
+      "events": false,
+      "arguments": false
     }
   },
 
diff --git a/langserver/handlers/document_symbol.go b/langserver/handlers/document_symbol.go
@@ -26,6 +26,8 @@ func (mh *MethodHandler) TextDocumentSymbol(ctx context.Context, req *jrpc2.Requ
 		return symbols, err
 	}
 
+	config, err := lsctx.Config(ctx)
+
 	handler := filehandler.FromDocumentURI(params.TextDocument.URI)
 
 	path, err := handler.FullPath()
@@ -46,7 +48,7 @@ func (mh *MethodHandler) TextDocumentSymbol(ctx context.Context, req *jrpc2.Requ
 		Text:       contents,
 	}
 
-	symbols = tsc.GetEventSymbols(contents, doc)
+	symbols = tsc.GetEventSymbols(contents, doc, config)
 
 	return symbols, nil
 }
diff --git a/langserver/handlers/folding.go b/langserver/handlers/folding.go
@@ -24,6 +24,11 @@ func (mh *MethodHandler) TextDocumentFoldingRange(ctx context.Context, req *jrpc
 		return []lsp.FoldingRange{}, err
 	}
 
+	config, err := lsctx.Config(ctx)
+	if err != nil {
+		return []lsp.FoldingRange{}, err
+	}
+
 	handler := filehandler.FromDocumentURI(params.TextDocument.URI)
 	path, err := handler.FullPath()
 	if err != nil {
@@ -41,6 +46,6 @@ func (mh *MethodHandler) TextDocumentFoldingRange(ctx context.Context, req *jrpc
 		Text:       string(contents),
 	}
 
-	ranges := tsc.GetFoldingRanges(doc)
+	ranges := tsc.GetFoldingRanges(doc, config)
 	return ranges, nil
 }
diff --git a/langserver/handlers/service.go b/langserver/handlers/service.go
@@ -151,6 +151,7 @@ func (service *Service) Assigner() (jrpc2.Assigner, error) {
 			}
 
 			ctx = lsctx.WithFileSystem(ctx, fs)
+			ctx = lsctx.WithConfig(ctx, &conf)
 
 			return handle(ctx, req, mh.TextDocumentSymbol)
 		},
@@ -162,6 +163,7 @@ func (service *Service) Assigner() (jrpc2.Assigner, error) {
 			}
 
 			ctx = lsctx.WithFileSystem(ctx, fs)
+			ctx = lsctx.WithConfig(ctx, &conf)
 
 			return handle(ctx, req, mh.TextDocumentFoldingRange)
 		},
diff --git a/main.go b/main.go
@@ -12,7 +12,7 @@ func main() {
 	app := cli.NewApp()
 	app.Name = "tsc-ls"
 	app.Usage = "language Server for the TSC scripting language"
-	app.Version = "0.1.4"
+	app.Version = "0.1.5"
 
 	app.Commands = []*cli.Command{
 		{
diff --git a/tsc/event_symbols.go b/tsc/event_symbols.go
@@ -4,16 +4,22 @@ import (
 	"regexp"
 
 	"pkg.nimblebun.works/go-lsp"
+	"pkg.nimblebun.works/tsc-language-server/config"
 	"pkg.nimblebun.works/tsc-language-server/langserver/textdocument"
 )
 
 // GetEventSymbols will return a list of events as LSP-compatible symbols.
-func GetEventSymbols(text string, textDocumentItem lsp.TextDocumentItem) []lsp.DocumentSymbol {
+func GetEventSymbols(text string, textDocumentItem lsp.TextDocumentItem, conf *config.Config) []lsp.DocumentSymbol {
 	document := textdocument.From(textDocumentItem)
 
 	// this will match #0000 until the end of the line
 	re := regexp.MustCompile("#(?:[0-9]{4}).*")
 
+	if conf.Setup.LooseChecking.Events {
+		// this will match #0000, #0ABC
+		re = regexp.MustCompile("#(?:.{4})")
+	}
+
 	symbols := make([]lsp.DocumentSymbol, 0)
 
 	for _, match := range re.FindAllStringIndex(text, -1) {
diff --git a/tsc/event_symbols_test.go b/tsc/event_symbols_test.go
@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"pkg.nimblebun.works/go-lsp"
+	"pkg.nimblebun.works/tsc-language-server/config"
 	"pkg.nimblebun.works/tsc-language-server/tsc"
 )
 
@@ -23,7 +24,9 @@ func TestGetEventSymbols(t *testing.T) {
 		Text: text,
 	}
 
-	symbols := tsc.GetEventSymbols(text, document)
+	conf := config.New()
+
+	symbols := tsc.GetEventSymbols(text, document, &conf)
 
 	t.Run("should return correct number of symbols", func(t *testing.T) {
 		if len(symbols) != 5 {
diff --git a/tsc/folding.go b/tsc/folding.go
@@ -2,6 +2,7 @@ package tsc
 
 import (
 	"pkg.nimblebun.works/go-lsp"
+	"pkg.nimblebun.works/tsc-language-server/config"
 	"pkg.nimblebun.works/tsc-language-server/langserver/textdocument"
 	"pkg.nimblebun.works/tsc-language-server/utils"
 )
@@ -22,7 +23,7 @@ func createFoldingRange(start int, end int, document textdocument.TextDocument)
 }
 
 // GetFoldingRanges will return all foldable ranges from a given document.
-func GetFoldingRanges(textDocumentItem lsp.TextDocumentItem) []lsp.FoldingRange {
+func GetFoldingRanges(textDocumentItem lsp.TextDocumentItem, conf *config.Config) []lsp.FoldingRange {
 	text := textDocumentItem.Text
 
 	document := textdocument.From(textDocumentItem)
@@ -32,7 +33,7 @@ func GetFoldingRanges(textDocumentItem lsp.TextDocumentItem) []lsp.FoldingRange
 	end := -1
 
 	for idx, letter := range text {
-		if letter == '#' && IsEvent(utils.Substring(text, idx, 5)) {
+		if letter == '#' && IsEvent(utils.Substring(text, idx, 5), conf.Setup.LooseChecking.Events) {
 			if end-start > 4 {
 				foldingRange := createFoldingRange(start, end, document)
 				ranges = append(ranges, foldingRange)
diff --git a/tsc/folding_test.go b/tsc/folding_test.go
@@ -4,10 +4,13 @@ import (
 	"testing"
 
 	"pkg.nimblebun.works/go-lsp"
+	"pkg.nimblebun.works/tsc-language-server/config"
 	"pkg.nimblebun.works/tsc-language-server/tsc"
 )
 
 func TestGetFoldingRanges(t *testing.T) {
+	conf := config.New()
+
 	dummyData := `#0098
 <CNP0306:0117:0000<ANP0306:0032:0002<END
 
@@ -45,7 +48,7 @@ SHUTTER NO. 4<NOD<END`
 	}
 
 	t.Run("should return correct number of folding ranges", func(t *testing.T) {
-		ranges := tsc.GetFoldingRanges(dummyDocument)
+		ranges := tsc.GetFoldingRanges(dummyDocument, &conf)
 		actual := len(ranges)
 		expected := 4
 
@@ -55,7 +58,7 @@ SHUTTER NO. 4<NOD<END`
 	})
 
 	t.Run("should return correct ranges", func(t *testing.T) {
-		ranges := tsc.GetFoldingRanges(dummyDocument)
+		ranges := tsc.GetFoldingRanges(dummyDocument, &conf)
 		expectedRanges := []lsp.FoldingRange{
 			{
 				StartLine:      0,
diff --git a/tsc/hover_info.go b/tsc/hover_info.go
@@ -11,7 +11,7 @@ import (
 // GetHoverInfo will retrieve information about an event or a command starting
 // from a given position
 func GetHoverInfo(str string, to int, conf *config.Config) string {
-	if IsEvent(str) {
+	if IsEvent(str, conf.Setup.LooseChecking.Events) {
 		return fmt.Sprintf("Event **%s**", str[:5])
 	}
 
@@ -37,7 +37,7 @@ func GetHoverInfo(str string, to int, conf *config.Config) string {
 		for i := 0; i < command.Nargs(); i++ {
 			arg := utils.Substring(strWithoutCommand, i*5, 4)
 
-			if IsValidArgument(arg) {
+			if IsValidArgument(arg, conf.Setup.LooseChecking.Arguments) {
 				args = append(args, arg)
 			}
 		}
diff --git a/tsc/utils.go b/tsc/utils.go
@@ -3,7 +3,7 @@ package tsc
 import "strconv"
 
 // IsEvent checks whether the text hovered over is an event (#0000, #1234, etc.)
-func IsEvent(str string) bool {
+func IsEvent(str string, loose bool) bool {
 	// Events are 5 characters long (# and 4 digits)
 	if len(str) < 5 {
 		return false
@@ -14,19 +14,27 @@ func IsEvent(str string) bool {
 		return false
 	}
 
+	if loose {
+		return true
+	}
+
 	// The 4 characters after the # must be valid integers
 	_, err := strconv.Atoi(str[1:5])
 	return err == nil
 }
 
 // IsValidArgument checks whether the provided argument is valid (4 digits or
 // 'V' and 3 digits)
-func IsValidArgument(arg string) bool {
+func IsValidArgument(arg string, loose bool) bool {
 	// Arguments are always 4 characters long
 	if len(arg) != 4 {
 		return false
 	}
 
+	if loose {
+		return true
+	}
+
 	// Arguments are either valid integers or start with V
 	_, err := strconv.Atoi(arg)
 	if err != nil && arg[0] != 'V' {
diff --git a/tsc/utils_test.go b/tsc/utils_test.go
@@ -8,19 +8,21 @@ import (
 
 func TestIsEvent(t *testing.T) {
 	var tests = []struct {
-		name string
-		str  string
-		want bool
+		name  string
+		str   string
+		want  bool
+		loose bool
 	}{
-		{"should return true on valid event", "#1234", true},
-		{"should return false on invalid length", "#20", false},
-		{"should return false if string doesn't start with #", "a", false},
-		{"should return false if event # is invalid", "#3ab1", false},
+		{"should return true on valid event", "#1234", true, false},
+		{"should return false on invalid length", "#20", false, false},
+		{"should return false if string doesn't start with #", "a", false, false},
+		{"should return false if event # is invalid", "#3ab1", false, false},
+		{"should return true on non-numerical event # with loose setting", "#3ab1", true, true},
 	}
 
 	for _, testcase := range tests {
 		t.Run(testcase.name, func(t *testing.T) {
-			got := tsc.IsEvent(testcase.str)
+			got := tsc.IsEvent(testcase.str, testcase.loose)
 			if got != testcase.want {
 				t.Errorf(
 					"IsEvent(%s) got %v, want %v",
@@ -35,20 +37,22 @@ func TestIsEvent(t *testing.T) {
 
 func TestIsValidArgument(t *testing.T) {
 	var tests = []struct {
-		name string
-		str  string
-		want bool
+		name  string
+		str   string
+		want  bool
+		loose bool
 	}{
-		{"should return true on valid argument", "0012", true},
-		{"should return true on valid argument with variable", "V008", true},
-		{"should return false on invalid length", "012", false},
-		{"should return false on invalid argument", "3a1b", false},
-		{"should return false on invalid argument with variable", "V0AB", false},
+		{"should return true on valid argument", "0012", true, false},
+		{"should return true on valid argument with variable", "V008", true, false},
+		{"should return false on invalid length", "012", false, false},
+		{"should return false on invalid argument", "3a1b", false, false},
+		{"should return false on invalid argument with variable", "V0AB", false, false},
+		{"should return true on non-numerical argument with loose setting", "0-12", true, true},
 	}
 
 	for _, testcase := range tests {
 		t.Run(testcase.name, func(t *testing.T) {
-			got := tsc.IsValidArgument(testcase.str)
+			got := tsc.IsValidArgument(testcase.str, testcase.loose)
 			if got != testcase.want {
 				t.Errorf(
 					"IsValidArgument(%s) got %v, want %v",
diff --git a/tsc/validators/command_validator.go b/tsc/validators/command_validator.go
@@ -22,6 +22,12 @@ func ValidateCommands(text string, textDocumentItem lsp.TextDocumentItem, conf *
 	// <ABC0000?0001, <ABC0000 0001b0002, <ABC0000$0001\0002^0003, <FAOV100, <FLJV020:V102
 	re := regexp.MustCompile("<(([A-Z0-9+-]){3}(([0-9V])([0-9]){3})?)((.([0-9V])([0-9]){3})?){0,3}")
 
+	if conf.Setup.LooseChecking.Arguments {
+		// this will match <ABC, <ABC04BQ, <ABC04KB:0-32, etc. The separator is
+		// strictly : in this scenario.
+		re = regexp.MustCompile("<(([A-Z0-9+-]){3}((.){4})?)((:(.){4})?){0,3}")
+	}
+
 	diagnostics := []lsp.Diagnostic{}
 
 	for _, match := range re.FindAllStringIndex(text, -1) {
@@ -41,12 +47,12 @@ func ValidateCommands(text string, textDocumentItem lsp.TextDocumentItem, conf *
 		for i := 0; i < len(inputWithoutCommand); i++ {
 			arg := utils.Substring(inputWithoutCommand, i*5, 4)
 
-			if tsc.IsValidArgument(arg) {
+			if tsc.IsValidArgument(arg, conf.Setup.LooseChecking.Arguments) {
 				argc++
 			}
 		}
 
-		if argc != command.Nargs() {
+		if argc < command.Nargs() || (!conf.Setup.LooseChecking.Arguments && argc > command.Nargs()) {
 			quantity := "few"
 			if argc > command.Nargs() {
 				quantity = "many"
diff --git a/tsc/validators/command_validator_test.go b/tsc/validators/command_validator_test.go
diff --git a/tsc/validators/event_validator.go b/tsc/validators/event_validator.go
diff --git a/tsc/validators/event_validator_test.go b/tsc/validators/event_validator_test.go
diff --git a/tsc/validators/validators.go b/tsc/validators/validators.go

Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,8 @@ func (mh MethodHandler) TextDocumentSymbol(ctx context.Context, req jrpc2.Requ`
`26`	`26`	`return symbols, err`
`27`	`27`	`}`
`28`	`28`
	`29`	`+ config, err := lsctx.Config(ctx)`
	`30`	`+`
`29`	`31`	`handler := filehandler.FromDocumentURI(params.TextDocument.URI)`
`30`	`32`
`31`	`33`	`path, err := handler.FullPath()`
`@@ -46,7 +48,7 @@ func (mh MethodHandler) TextDocumentSymbol(ctx context.Context, req jrpc2.Requ`
`46`	`48`	`Text: contents,`
`47`	`49`	`}`
`48`	`50`
`49`		`- symbols = tsc.GetEventSymbols(contents, doc)`
	`51`	`+ symbols = tsc.GetEventSymbols(contents, doc, config)`
`50`	`52`
`51`	`53`	`return symbols, nil`
`52`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,11 @@ func (mh MethodHandler) TextDocumentFoldingRange(ctx context.Context, req jrpc`
`24`	`24`	`return []lsp.FoldingRange{}, err`
`25`	`25`	`}`
`26`	`26`
	`27`	`+ config, err := lsctx.Config(ctx)`
	`28`	`+ if err != nil {`
	`29`	`+ return []lsp.FoldingRange{}, err`
	`30`	`+ }`
	`31`	`+`
`27`	`32`	`handler := filehandler.FromDocumentURI(params.TextDocument.URI)`
`28`	`33`	`path, err := handler.FullPath()`
`29`	`34`	`if err != nil {`
`@@ -41,6 +46,6 @@ func (mh MethodHandler) TextDocumentFoldingRange(ctx context.Context, req jrpc`
`41`	`46`	`Text: string(contents),`
`42`	`47`	`}`
`43`	`48`
`44`		`- ranges := tsc.GetFoldingRanges(doc)`
	`49`	`+ ranges := tsc.GetFoldingRanges(doc, config)`
`45`	`50`	`return ranges, nil`
`46`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -151,6 +151,7 @@ func (service *Service) Assigner() (jrpc2.Assigner, error) {`
`151`	`151`	`}`
`152`	`152`
`153`	`153`	`ctx = lsctx.WithFileSystem(ctx, fs)`
	`154`	`+ ctx = lsctx.WithConfig(ctx, &conf)`
`154`	`155`
`155`	`156`	`return handle(ctx, req, mh.TextDocumentSymbol)`
`156`	`157`	`},`
`@@ -162,6 +163,7 @@ func (service *Service) Assigner() (jrpc2.Assigner, error) {`
`162`	`163`	`}`
`163`	`164`
`164`	`165`	`ctx = lsctx.WithFileSystem(ctx, fs)`
	`166`	`+ ctx = lsctx.WithConfig(ctx, &conf)`
`165`	`167`
`166`	`168`	`return handle(ctx, req, mh.TextDocumentFoldingRange)`
`167`	`169`	`},`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ func main() {`
`12`	`12`	`app := cli.NewApp()`
`13`	`13`	`app.Name = "tsc-ls"`
`14`	`14`	`app.Usage = "language Server for the TSC scripting language"`
`15`		`- app.Version = "0.1.4"`
	`15`	`+ app.Version = "0.1.5"`
`16`	`16`
`17`	`17`	`app.Commands = []*cli.Command{`
`18`	`18`	`{`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@ import (`
`4`	`4`	`"testing"`
`5`	`5`
`6`	`6`	`"pkg.nimblebun.works/go-lsp"`
	`7`	`+ "pkg.nimblebun.works/tsc-language-server/config"`
`7`	`8`	`"pkg.nimblebun.works/tsc-language-server/tsc"`
`8`	`9`	`)`
`9`	`10`
`@@ -23,7 +24,9 @@ func TestGetEventSymbols(t *testing.T) {`
`23`	`24`	`Text: text,`
`24`	`25`	`}`
`25`	`26`
`26`		`- symbols := tsc.GetEventSymbols(text, document)`
	`27`	`+ conf := config.New()`
	`28`	`+`
	`29`	`+ symbols := tsc.GetEventSymbols(text, document, &conf)`
`27`	`30`
`28`	`31`	`t.Run("should return correct number of symbols", func(t *testing.T) {`
`29`	`32`	`if len(symbols) != 5 {`