proto_scala_library: support aliasing for scala imports

Author: pcj

pkg/rule/rules_scala/scala_library.go

@@ -338,7 +338,7 @@ func getScalapbImports(files []*protoc.File) []string {
 				switch namedLiteral.Name {
 				case "import":
 					if namedLiteral.Source != "" {
-						imps = append(imps, namedLiteral.Source)
+						imps = append(imps, parseScalaImportNamedLiteral(namedLiteral.Source)...)
 					}
 				}
 			}
@@ -362,6 +362,28 @@ func getScalapbImports(files []*protoc.File) []string {
 	return protoc.DeduplicateAndSort(imps)
 }
 
+func parseScalaImportNamedLiteral(lit string) (imports []string) {
+	ob := strings.Index(lit, "{")
+	cb := strings.Index(lit, "}")
+	if ob == -1 || cb == -1 {
+		return []string{lit}
+	}
+	prefix := strings.TrimRight(lit[:ob], ".")
+	exprs := strings.Split(lit[ob+1:cb], ",")
+	for _, expr := range exprs {
+		expr = strings.TrimSpace(expr)
+		parts := strings.Split(expr, "=>")
+		if len(parts) == 2 {
+			source := strings.TrimSpace(parts[0])
+			imports = append(imports, prefix+"."+source)
+		} else {
+			imports = append(imports, prefix+"."+expr)
+
+		}
+	}
+	return
+}
+
 // javaPackageOption is a utility function to seek for the java_package option.
 func javaPackageOption(options []proto.Option) (string, bool) {
 	for _, opt := range options {

pkg/rule/rules_scala/scala_library_test.go

@@ -46,6 +46,42 @@ func TestGetJavaPackageOption(t *testing.T) {
 	}
 }
 
+// TestParseScalaImportNamedLiteral asserts the ability to parse
+// a subset of scala import expressions.
+func TestParseScalaImportNamedLiteral(t *testing.T) {
+	for name, tc := range map[string]struct {
+		imp  string
+		want []string
+	}{
+		"degenerate": {
+			want: []string{""},
+		},
+		"single import": {
+			imp:  "a.b.c.Foo",
+			want: []string{"a.b.c.Foo"},
+		},
+		"multiple import": {
+			imp:  "a.b.c.{Foo,Bar}",
+			want: []string{"a.b.c.Foo", "a.b.c.Bar"},
+		},
+		"multiple import +ws": {
+			imp:  "a.b.c.{ Foo  , Bar  }  ",
+			want: []string{"a.b.c.Foo", "a.b.c.Bar"},
+		},
+		"alias import": {
+			imp:  "a.b.c.{ Foo => Fog , Bar => Baz }",
+			want: []string{"a.b.c.Foo", "a.b.c.Bar"},
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			got := parseScalaImportNamedLiteral(tc.imp)
+			if diff := cmp.Diff(tc.want, got); diff != "" {
+				t.Errorf("(-want +got):\n%s", diff)
+			}
+		})
+	}
+}
+
 // TestGetScalapbImports shows that an import named in (scalapb.options) works as expected.
 func TestGetScalapbImports(t *testing.T) {
 	for name, tc := range map[string]struct {
@@ -74,6 +110,18 @@ option (scalapb.options) = {
 			},
 			want: []string{"corp.common.utils.WithORM"},
 		},
+		"with scalapb import (aliased)": {
+			in: map[string]string{
+				"foo.proto": `syntax = "proto3";
+import "scalapb/scalapb.proto";
+
+option (scalapb.options) = {
+	import: "corp.common.utils.{WithORM => WithORMAlias}"
+};`,
+			},
+			want: []string{"corp.common.utils.WithORM"},
+		},
+
 		"with field type": {
 			in: map[string]string{
 				"foo.proto": `