feat(server): ignore error in production (#58)

Signed-off-by: Vasek - Tom C <[email protected]>

main.go

@@ -7,7 +7,7 @@ import (
 )
 
 func main() {
-	s := server.New()
+	s := server.New(server.DEV)
 
 	if err := s.Run(); err != nil {
 		panic(err)

server/handler/documentDefinition.go

@@ -20,12 +20,12 @@ func (h *Handler) documentDefinition(_ *glsp.Context, params *protocol.Definitio
 
 	_uri, err := uri.Parse(params.TextDocument.URI)
 	if err != nil {
-		return nil, err
+		return nil, h.wrapError(err)
 	}
 
 	p := h.workspace.GetPlan(_uri.Filename())
 	if p == nil {
-		return nil, fmt.Errorf("plan not found")
+		return nil, h.wrapError(fmt.Errorf("plan not found"))
 	}
 
 	h.log.Debugf("Pos {%x, %x}", params.Position.Line, params.Position.Character)
@@ -36,7 +36,7 @@ func (h *Handler) documentDefinition(_ *glsp.Context, params *protocol.Definitio
 		utils.UIntToInt(params.Position.Character),
 	)
 	if err != nil {
-		return nil, err
+		return nil, h.wrapError(err)
 	}
 
 	h.log.Debugf("Position: %#v", location.Pos().Position())

server/handler/documentDidOpen.go

@@ -14,11 +14,11 @@ func (h *Handler) documentDidOpen(_ *glsp.Context, params *protocol.DidOpenTextD
 
 	_uri, err := uri.Parse(params.TextDocument.URI)
 	if err != nil {
-		return err
+		return h.wrapError(err)
 	}
 
 	if err := h.workspace.AddPlan(_uri.Filename()); err != nil {
-		return err
+		return h.wrapError(err)
 	}
 
 	return nil

server/handler/documentDidSave.go

@@ -19,16 +19,16 @@ func (h *Handler) documentDidSave(context *glsp.Context, params *protocol.DidSav
 
 	_uri, err := uri.Parse(params.TextDocument.URI)
 	if err != nil {
-		return err
+		return h.wrapError(err)
 	}
 
 	p := h.workspace.GetPlan(_uri.Filename())
 	if p == nil {
-		return fmt.Errorf("plan not found")
+		return h.wrapError(fmt.Errorf("plan not found"))
 	}
 
 	if err := p.Reload(); err != nil {
-		return err
+		return h.wrapError(err)
 	}
 
 	return nil

server/handler/documentHover.go

@@ -18,12 +18,12 @@ func (h *Handler) documentHover(_ *glsp.Context, params *protocol.HoverParams) (
 
 	_uri, err := uri.Parse(params.TextDocument.URI)
 	if err != nil {
-		return nil, err
+		return nil, h.wrapError(err)
 	}
 
 	p := h.workspace.GetPlan(_uri.Filename())
 	if p == nil {
-		return nil, fmt.Errorf("plan not found")
+		return nil, h.wrapError(fmt.Errorf("plan not found"))
 	}
 
 	h.log.Debugf("Pos {%x, %x}", params.Position.Line, params.Position.Character)
@@ -34,7 +34,7 @@ func (h *Handler) documentHover(_ *glsp.Context, params *protocol.HoverParams) (
 		utils.UIntToInt(params.Position.Character),
 	)
 	if err != nil {
-		return nil, err
+		return nil, h.wrapError(err)
 	}
 
 	return &protocol.Hover{

server/handler/documentSemanticTokensFull.go

@@ -9,13 +9,13 @@ import (
 
 // documentDidOpen register a new plan in the workspace
 // Spec: https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_didOpen
-func (h *Handler) documentSemanticTokensFull(context *glsp.Context, params *protocol.SemanticTokensParams) (*protocol.SemanticTokens, error) {
+func (h *Handler) documentSemanticTokensFull(_ *glsp.Context, params *protocol.SemanticTokensParams) (*protocol.SemanticTokens, error) {
 	h.log.Debugf("Semantic Tokens: %s", params.TextDocument.URI)
 	h.log.Debugf("params: %#v", params)
 
 	_uri, err := uri.Parse(params.TextDocument.URI)
 	if err != nil {
-		return nil, err
+		return nil, h.wrapError(err)
 	}
 
 	// TODO: Hightlight errors

server/handler/error.go

@@ -0,0 +1,12 @@
+package handler
+
+// wrapError is a utility function to manage any error returned by a handler
+// depending on a context
+// For now, it ignores error on production mode to do not annoying users
+func (h *Handler) wrapError(err error) error {
+	if h.mode == PROD {
+		return nil
+	}
+
+	return err
+}

server/handler/handler.go

@@ -9,6 +9,13 @@ import (
 	"github.com/tliron/kutil/logging"
 )
 
+type Mode int
+
+const (
+	DEV Mode = iota
+	PROD
+)
+
 // Handler is the storage for any handler of the server.LSP.
 // It also handles a single workspace for now which represent a VSCode project
 type Handler struct {
@@ -21,15 +28,18 @@ type Handler struct {
 	lsName string
 
 	lsVersion string
+
+	mode Mode
 }
 
 // New creates a Handler instance that contains all methods supported by
 // the LSP
-func New(lsName, lsVersion string, log logging.Logger) *Handler {
+func New(lsName, lsVersion string, log logging.Logger, mode Mode) *Handler {
 	h := &Handler{
 		lsName:    lsName,
 		lsVersion: lsVersion,
 		log:       logging.NewScopeLogger(log, "workspace"),
+		mode:      mode,
 	}
 
 	h.handler = &protocol.Handler{

server/handler/initialize.go

@@ -22,7 +22,7 @@ func (h *Handler) initialize(_ *glsp.Context, params *protocol.InitializeParams)
 	}
 
 	if err := h.initWorkspace(params.WorkspaceFolders, params.RootURI, params.RootPath); err != nil {
-		return nil, err
+		return nil, h.wrapError(err)
 	}
 
 	return protocol.InitializeResult{

server/server.go

@@ -23,16 +23,23 @@ const (
 	Version = "0.0.1"
 )
 
+type Mode handler.Mode
+
+const (
+	DEV Mode = iota
+	PROD
+)
+
 // New initializes a new language protocol server that contains his logger
 // and his handler
-func New() *LSP {
+func New(mode Mode) *LSP {
 	// This increases logging verbosity (optional)
 	// logTo := "/tmp/daggerlsp.log"
 	// logging.Configure(2, &logTo)
-	logging.Configure(2, nil)
+	logging.Configure(0, nil)
 	log := logging.GetLogger(Name)
 
-	h := handler.New(Name, Version, log)
+	h := handler.New(Name, Version, log, handler.Mode(mode))
 	return &LSP{
 		log:     log,
 		handler: h,