Rename functions and reorder params

Author: maxmousee

expression.go

@@ -7,24 +7,24 @@ type Expression struct {
 	Text string // words to be matched with a token (empty for any)
 }
 
-// FindExpressionsInTokens checks if a given Expression is present in a list of tokens
-func FindExpressionsInTokens(tokens []Token, expressions []Expression) bool {
+// ContainsExpressionsInTokens checks if a given Expression is present in a list of tokens
+func ContainsExpressionsInTokens(expressions []Expression, tokens []Token) bool {
 	if len(expressions) > len(tokens) {
 		return false
 	}
 	if len(expressions) > 1 {
-		return FindExpressionsInTokens(tokens[1:], expressions[1:])
+		return ContainsExpressionsInTokens(expressions[1:], tokens[1:])
 	} else if len(expressions) == 1 {
 		if len(tokens) > 1 {
-			return FindExpressionInTokens(tokens[1:], expressions[0])
+			return ContainsExpressionInTokens(expressions[0], tokens[1:])
 		}
-		return FindExpressionInTokens(tokens, expressions[0])
+		return ContainsExpressionInTokens(expressions[0], tokens)
 	}
 	return false
 }
 
-// FindExpressionInTokens checks if a given Expression is present in a list of tokens
-func FindExpressionInTokens(tokens []Token, expression Expression) bool {
+// ContainsExpressionInTokens checks if a given Expression is present in a list of tokens
+func ContainsExpressionInTokens(expression Expression, tokens []Token) bool {
 	for _, token := range tokens {
 		if MatchToken(token, expression) {
 			return true

expression_test.go

@@ -5,7 +5,7 @@ import (
 	"testing"
 )
 
-func TestFindExpressionInTokens(t *testing.T) {
+func TestContainsExpressionInTokens(t *testing.T) {
 	assertions := assert.New(t)
 
 	token := Token{
@@ -18,7 +18,7 @@ func TestFindExpressionInTokens(t *testing.T) {
 		Type: "keyword",
 		Text: "if",
 	}
-	assertions.True(FindExpressionInTokens([]Token{token}, expression))
+	assertions.True(ContainsExpressionInTokens(expression, []Token{token}))
 
 	token = Token{
 		Type:     "bracket",
@@ -30,10 +30,10 @@ func TestFindExpressionInTokens(t *testing.T) {
 		Type: "keyword",
 		Text: "if",
 	}
-	assertions.False(FindExpressionInTokens([]Token{token}, expression))
+	assertions.False(ContainsExpressionInTokens(expression, []Token{token}))
 }
 
-func TestFindExpressionsInTokens(t *testing.T) {
+func TestContainsExpressionsInTokens(t *testing.T) {
 	assertions := assert.New(t)
 
 	token := Token{
@@ -46,7 +46,7 @@ func TestFindExpressionsInTokens(t *testing.T) {
 		Type: "keyword",
 		Text: "if",
 	}
-	assertions.True(FindExpressionsInTokens([]Token{token}, []Expression{expression}))
+	assertions.True(ContainsExpressionsInTokens([]Expression{expression}, []Token{token}))
 
 	token2 := Token{
 		Type:     "bracket",
@@ -58,13 +58,13 @@ func TestFindExpressionsInTokens(t *testing.T) {
 		Type: "bracket",
 		Text: "(",
 	}
-	assertions.True(FindExpressionsInTokens([]Token{token, token2}, []Expression{expression, expression2}))
+	assertions.True(ContainsExpressionsInTokens([]Expression{expression, expression2}, []Token{token, token2}))
 
 	expression2 = Expression{
 		Type: "keyword",
 		Text: "for",
 	}
-	assertions.False(FindExpressionsInTokens([]Token{token, token2}, []Expression{expression, expression2}))
+	assertions.False(ContainsExpressionsInTokens([]Expression{expression, expression2}, []Token{token, token2}))
 
 	token = Token{
 		Type:     "bracket",
@@ -76,22 +76,22 @@ func TestFindExpressionsInTokens(t *testing.T) {
 		Type: "keyword",
 		Text: "if",
 	}
-	assertions.False(FindExpressionsInTokens([]Token{token}, []Expression{expression}))
+	assertions.False(ContainsExpressionsInTokens([]Expression{expression}, []Token{token}))
 
 	token2 = Token{
 		Type:     "bracket",
 		Position: 2,
 		Text:     ")",
 	}
 
-	assertions.False(FindExpressionsInTokens([]Token{token, token2}, []Expression{expression}))
+	assertions.False(ContainsExpressionsInTokens([]Expression{expression}, []Token{token, token2}))
 
-	assertions.False(FindExpressionsInTokens([]Token{token}, []Expression{expression, expression2}))
+	assertions.False(ContainsExpressionsInTokens([]Expression{expression, expression2}, []Token{token}))
 
-	assertions.False(FindExpressionsInTokens([]Token{token}, []Expression{}))
+	assertions.False(ContainsExpressionsInTokens([]Expression{}, []Token{token}))
 }
 
-func TestFindComplexExpressionsInTokens(t *testing.T) {
+func TestContainsComplexExpressionsInTokens(t *testing.T) {
 	assertions := assert.New(t)
 	expression := Expression{
 		Type: "bracket",
@@ -124,10 +124,10 @@ func TestFindComplexExpressionsInTokens(t *testing.T) {
 		Text:     "{",
 	}
 
-	assertions.True(FindExpressionsInTokens([]Token{token, token2, token3, token4}, []Expression{expression, expression2}))
+	assertions.True(ContainsExpressionsInTokens([]Expression{expression, expression2}, []Token{token, token2, token3, token4}))
 }
 
-func TestFindComplexExpressionsInTokensOnSecondTime(t *testing.T) {
+func TestContainsComplexExpressionsInTokensOnSecondTime(t *testing.T) {
 	assertions := assert.New(t)
 	expression := Expression{
 		Type: "bracket",
@@ -160,10 +160,10 @@ func TestFindComplexExpressionsInTokensOnSecondTime(t *testing.T) {
 		Text:     "{",
 	}
 
-	assertions.True(FindExpressionsInTokens([]Token{token, token2, token3, token4}, []Expression{expression, expression2}))
+	assertions.True(ContainsExpressionsInTokens([]Expression{expression, expression2}, []Token{token, token2, token3, token4}))
 }
 
-func TestDoNotFindComplexExpressionsInTokens(t *testing.T) {
+func TestNotContainsComplexExpressionsInTokens(t *testing.T) {
 	assertions := assert.New(t)
 	expression := Expression{
 		Type: "bracket",
@@ -196,7 +196,7 @@ func TestDoNotFindComplexExpressionsInTokens(t *testing.T) {
 		Text:     "{",
 	}
 
-	assertions.False(FindExpressionsInTokens([]Token{token, token2, token3, token4}, []Expression{expression, expression2}))
+	assertions.False(ContainsExpressionsInTokens([]Expression{expression, expression2}, []Token{token, token2, token3, token4}))
 }
 
 func TestMatchToken(t *testing.T) {