fix: reorient name scheme around maven spec

Signed-off-by: Christopher Phillips <christopher.phillips@anchore.com>

grype/version/constraint.go

@@ -17,8 +17,8 @@ func GetConstraint(constStr string, format Format) (Constraint, error) {
 		return newSemanticConstraint(constStr)
 	case DebFormat:
 		return newDebConstraint(constStr)
-	case JavaFormat:
-		return newJavaConstraint(constStr)
+	case MavenFormat:
+		return newMavenConstraint(constStr)
 	case RpmFormat:
 		return newRpmConstraint(constStr)
 	case PythonFormat:

grype/version/format.go

@@ -11,7 +11,7 @@ const (
 	SemanticFormat
 	ApkFormat
 	DebFormat
-	JavaFormat
+	MavenFormat
 	RpmFormat
 	PythonFormat
 	KBFormat
@@ -26,7 +26,7 @@ var formatStr = []string{
 	"Semantic",
 	"Apk",
 	"Deb",
-	"Java",
+	"Maven",
 	"RPM",
 	"Python",
 	"KB",
@@ -38,7 +38,7 @@ var Formats = []Format{
 	SemanticFormat,
 	ApkFormat,
 	DebFormat,
-	JavaFormat,
+	MavenFormat,
 	RpmFormat,
 	PythonFormat,
 	KBFormat,
@@ -54,8 +54,8 @@ func ParseFormat(userStr string) Format {
 		return ApkFormat
 	case strings.ToLower(DebFormat.String()), "dpkg":
 		return DebFormat
-	case strings.ToLower(JavaFormat.String()), "java":
-		return JavaFormat
+	case strings.ToLower(MavenFormat.String()), "maven":
+		return MavenFormat
 	case strings.ToLower(RpmFormat.String()), "rpm":
 		return RpmFormat
 	case strings.ToLower(PythonFormat.String()), "python":
@@ -78,7 +78,7 @@ func FormatFromPkgType(t pkg.Type) Format {
 	case pkg.DebPkg:
 		format = DebFormat
 	case pkg.JavaPkg:
-		format = JavaFormat
+		format = MavenFormat
 	case pkg.RpmPkg:
 		format = RpmFormat
 	case pkg.GemPkg:

grype/version/format_test.go

@@ -17,8 +17,8 @@ func TestParseFormat(t *testing.T) {
 			format: DebFormat,
 		},
 		{
-			input:  "java",
-			format: JavaFormat,
+			input:  "maven",
+			format: MavenFormat,
 		},
 		{
 			input:  "gem",
@@ -60,7 +60,7 @@ func TestFormatFromPkgType(t *testing.T) {
 		},
 		{
 			pkgType: pkg.JavaPkg,
-			format:  JavaFormat,
+			format:  MavenFormat,
 		},
 		{
 			pkgType: pkg.GemPkg,

grype/version/maven_constraint.go

@@ -0,0 +1,72 @@
+package version
+
+import "fmt"
+
+type mavenConstraint struct {
+	raw        string
+	expression constraintExpression
+}
+
+func newMavenConstraint(raw string) (mavenConstraint, error) {
+	if raw == "" {
+		// empty constraints are always satisfied
+		return mavenConstraint{}, nil
+	}
+
+	constraints, err := newConstraintExpression(raw, newMavenComparator)
+	if err != nil {
+		return mavenConstraint{}, fmt.Errorf("unable to parse maven constraint phrase: %w", err)
+	}
+
+	return mavenConstraint{
+		raw:        raw,
+		expression: constraints,
+	}, nil
+}
+
+func newMavenComparator(unit constraintUnit) (Comparator, error) {
+	ver, err := newMavenVersion(unit.version)
+	if err != nil {
+		return nil, fmt.Errorf("unable to parse constraint version (%s): %w", unit.version, err)
+	}
+
+	return ver, nil
+}
+
+func (c mavenConstraint) supported(format Format) bool {
+	return format == MavenFormat
+}
+
+func (c mavenConstraint) Satisfied(version *Version) (satisfied bool, err error) {
+	if c.raw == "" && version != nil {
+		// empty constraints are always satisfied
+		return true, nil
+	}
+
+	if version == nil {
+		if c.raw != "" {
+			// a non-empty constraint with no version given should always fail
+			return false, nil
+		}
+
+		return true, nil
+	}
+
+	if !c.supported(version.Format) {
+		return false, fmt.Errorf("(maven) unsupported format: %s", version.Format)
+	}
+
+	if version.rich.mavenVer == nil {
+		return false, fmt.Errorf("no rich apk version given: %+v", version)
+	}
+
+	return c.expression.satisfied(version)
+}
+
+func (c mavenConstraint) String() string {
+	if c.raw == "" {
+		return "none (maven)"
+	}
+
+	return fmt.Sprintf("%s (maven)", c.raw)
+}

grype/version/java_constraint_test.go → grype/version/maven_constraint_test.go

@@ -33,10 +33,10 @@ func TestVersionConstraintJava(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			constraint, err := newJavaConstraint(test.constraint)
+			constraint, err := newMavenConstraint(test.constraint)
 
-			assert.NoError(t, err, "unexpected error from newJavaConstraint %s: %v", test.version, err)
-			test.assertVersionConstraint(t, JavaFormat, constraint)
+			assert.NoError(t, err, "unexpected error from newMavenConstraint %s: %v", test.version, err)
+			test.assertVersionConstraint(t, MavenFormat, constraint)
 
 		})
 	}
@@ -95,10 +95,10 @@ func TestVersionEqualityJava(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			constraint, err := newJavaConstraint(test.constraint)
+			constraint, err := newMavenConstraint(test.constraint)
 
-			assert.NoError(t, err, "unexpected error from newJavaConstraint %s: %v", test.version, err)
-			test.assertVersionConstraint(t, JavaFormat, constraint)
+			assert.NoError(t, err, "unexpected error from newMavenConstraint %s: %v", test.version, err)
+			test.assertVersionConstraint(t, MavenFormat, constraint)
 		})
 	}
 }

grype/version/java_version.go → grype/version/maven_version.go

@@ -6,34 +6,34 @@ import (
 	mvnv "github.com/masahiro331/go-mvn-version"
 )
 
-type javaVersion struct {
+type mavenVersion struct {
 	raw     string
 	version mvnv.Version
 }
 
-func newJavaVersion(raw string) (*javaVersion, error) {
+func newMavenVersion(raw string) (*mavenVersion, error) {
 	ver, err := mvnv.NewVersion(raw)
 	if err != nil {
 		return nil, fmt.Errorf("could not generate new java version from: %s; %w", raw, err)
 	}
 
-	return &javaVersion{
+	return &mavenVersion{
 		raw:     raw,
 		version: ver,
 	}, nil
 }
 
 // Compare returns 0 if j2 == j, 1 if j2 > j, and -1 if j2 < j.
 // If an error returns the int value is -1
-func (j *javaVersion) Compare(j2 *Version) (int, error) {
-	if j2.Format != JavaFormat {
+func (j *mavenVersion) Compare(j2 *Version) (int, error) {
+	if j2.Format != MavenFormat {
 		return -1, fmt.Errorf("unable to compare java to given format: %s", j2.Format)
 	}
-	if j2.rich.javaVer == nil {
-		return -1, fmt.Errorf("given empty javaVersion object")
+	if j2.rich.mavenVer == nil {
+		return -1, fmt.Errorf("given empty mavenVersion object")
 	}
 
-	submittedVersion := j2.rich.javaVer.version
+	submittedVersion := j2.rich.mavenVer.version
 	if submittedVersion.Equal(j.version) {
 		return 0, nil
 	}

grype/version/java_version_test.go → grype/version/maven_version_test.go

@@ -35,13 +35,13 @@ func Test_javaVersion_Compare(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			j, err := NewVersion(tt.name, JavaFormat)
+			j, err := NewVersion(tt.name, MavenFormat)
 			assert.NoError(t, err)
 
-			j2, err := NewVersion(tt.compare, JavaFormat)
+			j2, err := NewVersion(tt.compare, MavenFormat)
 			assert.NoError(t, err)
 
-			if got, _ := j2.rich.javaVer.Compare(j); got != tt.want {
+			if got, _ := j2.rich.mavenVer.Compare(j); got != tt.want {
 				t.Errorf("Compare() = %v, want %v", got, tt.want)
 			}
 		})

grype/version/version.go

@@ -18,7 +18,7 @@ type rich struct {
 	semVer        *semanticVersion
 	apkVer        *apkVersion
 	debVer        *debVersion
-	javaVer       *javaVersion
+	mavenVer      *mavenVersion
 	rpmVer        *rpmVersion
 	kbVer         *kbVersion
 	portVer       *portageVersion
@@ -63,9 +63,9 @@ func (v *Version) populate() error {
 		ver, err := newDebVersion(v.Raw)
 		v.rich.debVer = ver
 		return err
-	case JavaFormat:
-		ver, err := newJavaVersion(v.Raw)
-		v.rich.javaVer = ver
+	case MavenFormat:
+		ver, err := newMavenVersion(v.Raw)
+		v.rich.mavenVer = ver
 		return err
 	case RpmFormat:
 		ver, err := newRpmVersion(v.Raw)