Add support for .vue files

matchers/matchers.go

@@ -10,6 +10,7 @@ import (
 	"github.com/preslavmihaylov/todocheck/matchers/scripts"
 	"github.com/preslavmihaylov/todocheck/matchers/standard"
 	"github.com/preslavmihaylov/todocheck/matchers/state"
+	"github.com/preslavmihaylov/todocheck/matchers/vue"
 )
 
 // TodoMatcher for todo comments
@@ -124,6 +125,23 @@ var (
 			return groovy.NewCommentMatcher(callback)
 		},
 	}
+
+	vueMatcherFactory = &matcherFactory{
+		func() func([]string) TodoMatcher {
+			var once sync.Once
+			var matcher TodoMatcher
+
+			return func(customTodos []string) TodoMatcher {
+				once.Do(func() {
+					matcher = vue.NewTodoMatcher(customTodos)
+				})
+				return matcher
+			}
+		}(),
+		func(callback state.CommentCallback) CommentMatcher {
+			return vue.NewCommentMatcher(callback)
+		},
+	}
 )
 
 var supportedMatchers = map[string]*matcherFactory{
@@ -159,6 +177,9 @@ var supportedMatchers = map[string]*matcherFactory{
 
 	// file types, supporting python comments
 	".py": pythonMatcherFactory,
+
+	// file types, supporting js, html and css comments
+	".vue": vueMatcherFactory,
 }
 
 // TodoMatcherForFile gets the correct todo matcher for the given filename

matchers/vue/comments.go

@@ -0,0 +1,138 @@
+package vue
+
+import (
+	"github.com/preslavmihaylov/todocheck/matchers/state"
+)
+
+// NewCommentMatcher for vue comments
+func NewCommentMatcher(callback state.CommentCallback) *CommentMatcher {
+	return &CommentMatcher{
+		callback: callback,
+	}
+}
+
+// CommentMatcher for vue comments
+type CommentMatcher struct {
+	callback                  state.CommentCallback
+	buffer                    string
+	lines                     []string
+	linecnt                   int
+	stringToken               rune
+	isExitingMultilineComment bool
+	commentType               string
+	isStartingHTML            bool
+}
+
+// NonCommentState for vue comments
+func (m *CommentMatcher) NonCommentState(
+	filename, line string, linecnt int, prevToken, currToken, nextToken rune,
+) (state.CommentState, error) {
+	if prevToken == '/' && currToken == '/' {
+		m.buffer += string(currToken)
+
+		return state.SingleLineComment, nil
+	} else if currToken == '"' || currToken == '\'' {
+		m.stringToken = currToken
+
+		return state.String, nil
+	} else if prevToken == '/' && currToken == '*' {
+		m.buffer += string(currToken)
+		m.commentType = "CSS"
+
+		return state.MultiLineComment, nil
+	} else if prevToken == '<' && currToken == '!' && nextToken == '-' {
+		m.isStartingHTML = true
+
+		return state.NonComment, nil
+	} else if m.isStartingHTML && nextToken == '-' {
+		m.buffer += "<!-"
+		m.commentType = "HTML"
+
+		return state.MultiLineComment, nil
+	} else if m.isStartingHTML && nextToken != '-' {
+		m.isStartingHTML = false
+	}
+
+	return state.NonComment, nil
+}
+
+// StringState for vue comments
+func (m *CommentMatcher) StringState(
+	filename, line string, linecnt int, prevToken, currToken, nextToken rune,
+) (state.CommentState, error) {
+	if prevToken != '\\' && currToken == m.stringToken {
+		return state.NonComment, nil
+	}
+
+	return state.String, nil
+}
+
+// SingleLineCommentState for vue comments
+func (m *CommentMatcher) SingleLineCommentState(
+	filename, line string, linecnt int, prevToken, currToken, nextToken rune,
+) (state.CommentState, error) {
+	if currToken == '\n' {
+		err := m.callback(m.buffer, filename, []string{line}, linecnt)
+		if err != nil {
+			return state.NonComment, err
+		}
+
+		m.resetState()
+		return state.NonComment, nil
+	}
+
+	m.buffer += string(currToken)
+	return state.SingleLineComment, nil
+}
+
+// MultiLineCommentState for vue comments
+func (m *CommentMatcher) MultiLineCommentState(
+	filename, line string, linecnt int, prevToken, currToken, nextToken rune,
+) (state.CommentState, error) {
+	if m.isExitingMultilineComment {
+		m.resetState()
+		return state.NonComment, nil
+	}
+
+	m.buffer += string(currToken)
+	if isEndOfMultilineComment(m.commentType, prevToken, currToken, nextToken) {
+		m.buffer += string(nextToken)
+		err := m.callback(m.buffer, filename, m.lines, m.linecnt)
+		if err != nil {
+			return state.NonComment, err
+		}
+
+		m.isExitingMultilineComment = true
+		return state.MultiLineComment, nil
+	}
+
+	if prevToken == '\n' {
+		m.lines = append(m.lines, line)
+	}
+
+	return state.MultiLineComment, nil
+}
+
+func (m *CommentMatcher) resetState() {
+	m.buffer = ""
+	m.lines = nil
+	m.linecnt = 0
+	m.stringToken = 0
+	m.isExitingMultilineComment = false
+	m.commentType = ""
+	m.isStartingHTML = false
+}
+
+func isEndOfMultilineComment(commentType string, prev, curr, next rune) bool {
+	if commentType == "CSS" {
+		if curr == '*' && next == '/' {
+			return true
+		}
+	}
+	if commentType == "HTML" {
+		if prev == '-' && curr == '-' && next == '>' {
+			return true
+		}
+	}
+	return false
+}

matchers/vue/doc.go

@@ -0,0 +1,3 @@
+// Package vue contains a todo matcher & comments matcher for vue comments.
+// Vue single-line comments use the '//' literal, and the multi-line comments use the CS&JS /**/ or the HTML <!-- --> literals.
+package vue

matchers/vue/todomatcher.go

@@ -0,0 +1,62 @@
+package vue
+
+import (
+	"regexp"
+
+	"github.com/preslavmihaylov/todocheck/common"
+	"github.com/preslavmihaylov/todocheck/matchers/errors"
+)
+
+// NewTodoMatcher for vue comments
+func NewTodoMatcher(todos []string) *TodoMatcher {
+	pattern := common.ArrayAsRegexAnyMatchExpression(todos)
+
+	singleLineTodoPattern := regexp.MustCompile(`^\s*//.*` + pattern)
+	singleLineValidTodoPattern := regexp.MustCompile(`^\s*// ` + pattern + ` (#?[a-zA-Z0-9\-]+):.*`)
+
+	multiLineTodoPattern := regexp.MustCompile(`(?s)^\s*(<\!--|/*).*` + pattern)
+	multiLineValidTodoPattern := regexp.MustCompile(`(?s)^\s*(<\!--|/*).*` + pattern + ` (#?[a-zA-Z0-9\-]+):.*`)
+
+	return &TodoMatcher{
+		singleLineTodoPattern:      singleLineTodoPattern,
+		singleLineValidTodoPattern: singleLineValidTodoPattern,
+		multiLineTodoPattern:       multiLineTodoPattern,
+		multiLineValidTodoPattern:  multiLineValidTodoPattern,
+	}
+}
+
+// TodoMatcher for vue comments
+type TodoMatcher struct {
+	singleLineTodoPattern      *regexp.Regexp
+	singleLineValidTodoPattern *regexp.Regexp
+	multiLineTodoPattern       *regexp.Regexp
+	multiLineValidTodoPattern  *regexp.Regexp
+}
+
+// IsMatch checks if the current expression matches a vue comment
+func (m *TodoMatcher) IsMatch(expr string) bool {
+	return m.singleLineTodoPattern.Match([]byte(expr)) || m.multiLineTodoPattern.Match([]byte(expr))
+}
+
+// IsValid checks if the expression is a valid todo comment
+func (m *TodoMatcher) IsValid(expr string) bool {
+	return m.singleLineValidTodoPattern.Match([]byte(expr)) || m.multiLineValidTodoPattern.Match([]byte(expr))
+}
+
+// ExtractIssueRef from the given expression.
+// If the expression is invalid, an ErrInvalidTODO is returned
+func (m *TodoMatcher) ExtractIssueRef(expr string) (string, error) {
+	if !m.IsValid(expr) {
+		return "", errors.ErrInvalidTODO
+	}
+
+	singleLineRes := m.singleLineValidTodoPattern.FindStringSubmatch(expr)
+	multiLineRes := m.multiLineValidTodoPattern.FindStringSubmatch(expr)
+	if len(singleLineRes) >= 2 {
+		return singleLineRes[1], nil
+	} else if len(multiLineRes) >= 3 {
+		return multiLineRes[2], nil
+	}
+
+	panic("Invariant violated. No issue reference found in valid TODO")
+}

testing/scenarios/vue/main.vue

@@ -0,0 +1,51 @@
+// oneline comment, malformed TODO
+// TODO 1: oneline comment wellformed
+// TODO 2: oneline comment with Issue closed
+
+<!-- TODO 3: wellformed HTML multiline entry -->
+<!-- TODO 2: wellformed HTML multiline entry, BUT issue closed -->
+<!-- TODO: missing number -->
+
+/* TODO 1: wellformed CS/JS multiline entry */
+/* TODO 2: wellformed CS/JS multiline entry, BUT issue closed */
+/*
+wellformed CS/JS multline entry
+*/
+
+/*
+TODO: malformed CS/JS multline entry, missing number
+*/
+
+<!--
+TODO 4: wellformed HTML multiline entry
+-->
+
+
+"this is a // TODO 2: valid comment in a string with issue closed"
+"this is a /* TODO 2: valid multiline comment in a string with issue closed */"
+'this is a <!-- TODO 2: valid HTML multiline comment in a string with issue closed -->'
+
+<template>
+  <div id="app">
+    {{ message }}
+  </div>
+</template> /* TODO 1: valid multiline comment in code */
+
+<script>
+export default {
+  data() {
+    return {
+      message: 'Hello World',
+    };
+  },
+};
+</script> <!-- TODO 1: 
+valid HTML multiline comment in code -->
+
+<style>
+#app {
+  font-size: 18px;
+  font-family: 'Roboto', sans-serif;
+  color: blue; // TODO 2: online comment wellformed in code, BUT issue closed
+}
+</style>

testing/todocheck_test.go

@@ -742,6 +742,55 @@ func TestPrintingVersionFlagStopsProgram(t *testing.T) {
 	}
 }
 
+func TestVueTodos(t *testing.T) {
+	err := scenariobuilder.NewScenario().
+		WithBinary("../todocheck").
+		WithBasepath("./scenarios/vue").
+		WithConfig("./test_configs/no_issue_tracker.yaml").
+		WithIssueTracker(issuetracker.Jira).
+		WithIssue("1", issuetracker.StatusOpen).
+		WithIssue("2", issuetracker.StatusClosed).
+		WithIssue("3", issuetracker.StatusOpen).
+		WithIssue("4", issuetracker.StatusOpen).
+		ExpectTodoErr(
+			scenariobuilder.NewTodoErr().
+				WithType(errors.TODOErrTypeMalformed).
+				WithLocation("scenarios/vue/main.vue", 1).
+				ExpectLine("// oneline comment, malformed TODO")).
+		ExpectTodoErr(
+			scenariobuilder.NewTodoErr().
+				WithType(errors.TODOErrTypeIssueClosed).
+				WithLocation("scenarios/vue/main.vue", 3).
+				ExpectLine("// TODO 2: oneline comment with Issue closed")).
+		ExpectTodoErr(
+			scenariobuilder.NewTodoErr().
+				WithType(errors.TODOErrTypeIssueClosed).
+				WithLocation("scenarios/vue/main.vue", 6)).
+		ExpectTodoErr(
+			scenariobuilder.NewTodoErr().
+				WithType(errors.TODOErrTypeMalformed).
+				WithLocation("scenarios/vue/main.vue", 7)).
+		ExpectTodoErr(
+			scenariobuilder.NewTodoErr().
+				WithType(errors.TODOErrTypeIssueClosed).
+				WithLocation("scenarios/vue/main.vue", 10)).
+		ExpectTodoErr(
+			scenariobuilder.NewTodoErr().
+				WithType(errors.TODOErrTypeMalformed).
+				WithLocation("scenarios/vue/main.vue", 0).
+				ExpectLine("TODO: malformed CS/JS multline entry, missing number").
+				ExpectLine("*/")).
+		ExpectTodoErr(
+			scenariobuilder.NewTodoErr().
+				WithType(errors.TODOErrTypeIssueClosed).
+				WithLocation("scenarios/vue/main.vue", 49).
+				ExpectLine("  color: blue; // TODO 2: online comment wellformed in code, BUT issue closed")).
+		Run()
+	if err != nil {
+		t.Errorf("%s", err)
+	}
+}
+
 // Testing multiple todo matchers created for different file types
 func TestMultipleTodoMatchers(t *testing.T) {
 	err := scenariobuilder.NewScenario().