split the huge the matherinfo.go file into smaller files

Author: nunnatsa

internal/expression/matcher/bematchers.go

@@ -0,0 +1,77 @@
+package matcher
+
+import "github.com/nunnatsa/ginkgolinter/internal/expression/value"
+
+type BeIdenticalToMatcher struct {
+	value.Value
+}
+
+func (BeIdenticalToMatcher) Type() Type {
+	return BeIdenticalToMatcherType
+}
+
+func (BeIdenticalToMatcher) MatcherName() string {
+	return beIdenticalTo
+}
+
+type BeEquivalentToMatcher struct {
+	value.Value
+}
+
+func (BeEquivalentToMatcher) Type() Type {
+	return BeEquivalentToMatcherType
+}
+
+func (BeEquivalentToMatcher) MatcherName() string {
+	return beEquivalentTo
+}
+
+type BeZeroMatcher struct{}
+
+func (BeZeroMatcher) Type() Type {
+	return BeZeroMatcherType
+}
+
+func (BeZeroMatcher) MatcherName() string {
+	return beZero
+}
+
+type BeEmptyMatcher struct{}
+
+func (BeEmptyMatcher) Type() Type {
+	return BeEmptyMatcherType
+}
+
+func (BeEmptyMatcher) MatcherName() string {
+	return beEmpty
+}
+
+type BeTrueMatcher struct{}
+
+func (BeTrueMatcher) Type() Type {
+	return BeTrueMatcherType | BoolValueTrue
+}
+
+func (BeTrueMatcher) MatcherName() string {
+	return beTrue
+}
+
+type BeFalseMatcher struct{}
+
+func (BeFalseMatcher) Type() Type {
+	return BeFalseMatcherType | BoolValueFalse
+}
+
+func (BeFalseMatcher) MatcherName() string {
+	return beFalse
+}
+
+type BeNilMatcher struct{}
+
+func (BeNilMatcher) Type() Type {
+	return BeNilMatcherType
+}
+
+func (BeNilMatcher) MatcherName() string {
+	return beNil
+}

internal/expression/matcher/benumericmatcher.go

@@ -0,0 +1,128 @@
+package matcher
+
+import (
+	"go/ast"
+	"go/constant"
+	"go/token"
+	gotypes "go/types"
+
+	"golang.org/x/tools/go/analysis"
+
+	"github.com/nunnatsa/ginkgolinter/internal/expression/value"
+)
+
+type BeNumericallyMatcher struct {
+	op      token.Token
+	value   value.Valuer
+	argType Type
+}
+
+var compareOps = map[string]token.Token{
+	`"=="`: token.EQL,
+	`"<"`:  token.LSS,
+	`">"`:  token.GTR,
+	`"="`:  token.ASSIGN,
+	`"!="`: token.NEQ,
+	`"<="`: token.LEQ,
+	`">="`: token.GEQ,
+}
+
+func getCompareOp(opExp ast.Expr) token.Token {
+	basic, ok := opExp.(*ast.BasicLit)
+	if !ok {
+		return token.ILLEGAL
+	}
+	if basic.Kind != token.STRING {
+		return token.ILLEGAL
+	}
+
+	if tk, ok := compareOps[basic.Value]; ok {
+		return tk
+	}
+
+	return token.ILLEGAL
+}
+
+func newBeNumericallyMatcher(opExp, orig, clone ast.Expr, pass *analysis.Pass) Info {
+	op := getCompareOp(opExp)
+	if op == token.ILLEGAL {
+		return &UnspecifiedMatcher{
+			matcherName: beNumerically,
+		}
+	}
+
+	val := value.GetValuer(orig, clone, pass)
+	argType := BeNumericallyMatcherType
+
+	if val.IsValueNumeric() {
+		if v := val.GetValue().String(); v == "0" {
+			switch op {
+			case token.EQL:
+				argType |= EqualZero
+
+			case token.NEQ, token.GTR:
+				argType |= GreaterThanZero
+			}
+		} else if v == "1" && op == token.GEQ {
+			argType |= GreaterThanZero
+		}
+	}
+
+	return &BeNumericallyMatcher{
+		op:      op,
+		value:   val,
+		argType: argType,
+	}
+}
+
+func (m BeNumericallyMatcher) Type() Type {
+	return m.argType
+}
+
+func (BeNumericallyMatcher) MatcherName() string {
+	return beNumerically
+}
+
+func (m BeNumericallyMatcher) GetValueExpr() ast.Expr {
+	return m.value.GetValueExpr()
+}
+
+func (m BeNumericallyMatcher) GetValue() constant.Value {
+	return m.value.GetValue()
+}
+
+func (m BeNumericallyMatcher) GetType() gotypes.Type {
+	return m.value.GetType()
+}
+
+func (m BeNumericallyMatcher) GetOp() token.Token {
+	return m.op
+}
+
+func (m BeNumericallyMatcher) IsValueZero() bool {
+	return m.value.IsValueZero()
+}
+
+func (m BeNumericallyMatcher) IsValueInt() bool {
+	return m.value.IsValueInt()
+}
+
+func (m BeNumericallyMatcher) IsValueNumeric() bool {
+	return m.value.IsValueNumeric()
+}
+
+func (m BeNumericallyMatcher) IsError() bool {
+	return m.value.IsError()
+}
+
+func (m BeNumericallyMatcher) IsFunc() bool {
+	return m.value.IsFunc()
+}
+
+func (m BeNumericallyMatcher) IsInterface() bool {
+	return m.value.IsInterface()
+}
+
+func (m BeNumericallyMatcher) IsPointer() bool {
+	return m.value.IsPointer()
+}

internal/expression/matcher/equalmatcher.go

@@ -0,0 +1,124 @@
+package matcher
+
+import (
+	"go/ast"
+	"go/constant"
+	gotypes "go/types"
+
+	"golang.org/x/tools/go/analysis"
+
+	"github.com/nunnatsa/ginkgolinter/internal/expression/value"
+)
+
+func newEqualMatcher(orig, clone ast.Expr, pass *analysis.Pass) Info {
+	t := pass.TypesInfo.Types[orig]
+
+	if t.Value != nil {
+		if t.Value.Kind() == constant.Bool {
+			if t.Value.String() == "true" {
+				return &EqualTrueMatcher{}
+			}
+			return &EqualFalseMatcher{}
+		}
+	}
+
+	if value.IsNil(orig, pass) {
+		return &EqualNilMatcher{
+			gotype: pass.TypesInfo.TypeOf(orig),
+		}
+	}
+
+	val := value.GetValuer(orig, clone, pass)
+
+	return &EqualMatcher{
+		val: val,
+	}
+}
+
+type EqualMatcher struct {
+	val value.Valuer
+}
+
+func (EqualMatcher) Type() Type {
+	return EqualMatcherType
+}
+
+func (EqualMatcher) MatcherName() string {
+	return equal
+}
+
+func (m EqualMatcher) GetValue() constant.Value {
+	return m.val.GetValue()
+}
+
+func (m EqualMatcher) GetType() gotypes.Type {
+	return m.val.GetType()
+}
+
+func (m EqualMatcher) GetValueExpr() ast.Expr {
+	return m.val.GetValueExpr()
+}
+
+func (m EqualMatcher) IsValueZero() bool {
+	return m.val.IsValueZero()
+}
+
+func (m EqualMatcher) IsValueInt() bool {
+	return m.val.IsValueInt()
+}
+
+func (m EqualMatcher) IsValueNumeric() bool {
+	return m.val.IsValueNumeric()
+}
+
+func (m EqualMatcher) IsError() bool {
+	return m.val.IsError()
+}
+
+func (m EqualMatcher) IsFunc() bool {
+	return m.val.IsFunc()
+}
+
+func (m EqualMatcher) IsInterface() bool {
+	return m.val.IsInterface()
+}
+
+func (m EqualMatcher) IsPointer() bool {
+	return m.val.IsPointer()
+}
+
+type EqualNilMatcher struct {
+	gotype gotypes.Type
+}
+
+func (EqualNilMatcher) Type() Type {
+	return EqualNilMatcherType | EqualMatcherType | EqualValueMatcherType
+}
+
+func (EqualNilMatcher) MatcherName() string {
+	return equal
+}
+
+func (n EqualNilMatcher) GetType() gotypes.Type {
+	return n.gotype
+}
+
+type EqualTrueMatcher struct{}
+
+func (EqualTrueMatcher) Type() Type {
+	return EqualMatcherType | EqualBoolValueMatcherType | BoolValueTrue
+}
+
+func (EqualTrueMatcher) MatcherName() string {
+	return equal
+}
+
+type EqualFalseMatcher struct{}
+
+func (EqualFalseMatcher) Type() Type {
+	return EqualMatcherType | EqualBoolValueMatcherType | BoolValueFalse
+}
+
+func (EqualFalseMatcher) MatcherName() string {
+	return equal
+}