feat: add models to represent Swift package info

BUILD.bazel

@@ -112,6 +112,7 @@ filegroup(
         "//gazelle/internal/pathdistance:all_files",
         "//gazelle/internal/spdesc:all_files",
         "//gazelle/internal/spdump:all_files",
+        "//gazelle/internal/spreso:all_files",
         "//gazelle/internal/stringslices:all_files",
         "//gazelle/internal/swift:all_files",
         "//gazelle/internal/swiftbin:all_files",

examples/pkg_manifest/BUILD.bazel

@@ -34,4 +34,5 @@ bzl_library(
     name = "swift_deps",
     srcs = ["swift_deps.bzl"],
     visibility = ["//visibility:public"],
+    deps = ["@cgrindel_swift_bazel//swiftpkg:defs"],
 )

gazelle/BUILD.bazel

@@ -27,6 +27,7 @@ go_library(
     importpath = "github.com/cgrindel/swift_bazel/gazelle",
     visibility = ["//visibility:public"],
     deps = [
+        "//gazelle/internal/spreso",
         "//gazelle/internal/stringslices",
         "//gazelle/internal/swift",
         "//gazelle/internal/swiftbin",

gazelle/config.go

@@ -97,7 +97,7 @@ func findExternalDepsInManifest(mi *swift.ModuleIndex, pi *swiftpkg.PackageInfo)
 	// Create a map of Swift external dep identity and Bazel repo name
 	depIdentToBazelRepoName := make(map[string]string)
 	for _, d := range dump.Dependencies {
-		depIdentToBazelRepoName[d.Name], err = swift.RepoName(d.URL)
+		depIdentToBazelRepoName[d.Name], err = swift.RepoNameFromURL(d.URL)
 		if err != nil {
 			log.Fatalf("Failed to create repo name for %s: %w", d.Name, err)
 		}

gazelle/internal/spreso/BUILD.bazel

@@ -29,3 +29,11 @@ go_test(
 )
 
 bzlformat_pkg(name = "bzlformat")
+
+# MARK: - Integration Test
+
+filegroup(
+    name = "all_files",
+    srcs = glob(["*"]),
+    visibility = ["//:__subpackages__"],
+)

gazelle/internal/spreso/package_reference.go

@@ -41,3 +41,8 @@ type PackageReference struct {
 	Location string
 	Name     string
 }
+
+func (pr *PackageReference) Remote() string {
+	// We probably want to use a different value based upon the Kind
+	return pr.Location
+}

gazelle/internal/spreso/pin.go

@@ -4,7 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 
-	"github.com/cgrindel/swift_bazel/gazelle/internal/jsonutils"
+ 	"github.com/cgrindel/swift_bazel/gazelle/internal/jsonutils"
 )
 
 // Pin
@@ -76,6 +76,10 @@ func (bps *BranchPinState) PinStateType() PinStateType {
 	return BranchPinStateType
 }
 
+func (bps *BranchPinState) Commit() string {
+	return bps.Revision
+}
+
 // VersionPinState
 
 type VersionPinState struct {
@@ -94,6 +98,10 @@ func (vps *VersionPinState) PinStateType() PinStateType {
 	return VersionPinStateType
 }
 
+func (vps *VersionPinState) Commit() string {
+	return vps.Revision
+}
+
 // RevisionPinState
 
 type RevisionPinState struct {
@@ -107,3 +115,7 @@ func NewRevisionPinState(revision string) *RevisionPinState {
 func (rps *RevisionPinState) PinStateType() PinStateType {
 	return RevisionPinStateType
 }
+
+func (rps *RevisionPinState) Commit() string {
+	return rps.Revision
+}

gazelle/internal/swift/BUILD.bazel

@@ -15,6 +15,7 @@ go_library(
         "module_name.go",
         "module_type.go",
         "repo_name.go",
+        "repo_rule_from_pin.go",
         "rule_kinds.go",
         "rules_common.go",
         "rules_from_manifest.go",
@@ -25,6 +26,7 @@ go_library(
     deps = [
         "//gazelle/internal/pathdistance",
         "//gazelle/internal/spdump",
+        "//gazelle/internal/spreso",
         "//gazelle/internal/stringslices",
         "//gazelle/internal/swiftpkg",
         "@bazel_gazelle//config:go_default_library",
@@ -44,10 +46,12 @@ go_test(
         "module_index_test.go",
         "module_name_test.go",
         "repo_name_test.go",
+        "repo_rule_from_pin_test.go",
         "rule_kinds_test.go",
     ],
     deps = [
         ":swift",
+        "//gazelle/internal/spreso",
         "@bazel_gazelle//label:go_default_library",
         "@bazel_gazelle//rule:go_default_library",
         "@com_github_stretchr_testify//assert",

gazelle/internal/swift/repo_name.go

@@ -4,9 +4,11 @@ import (
 	"fmt"
 	"path"
 	"strings"
+
+	"github.com/cgrindel/swift_bazel/gazelle/internal/spreso"
 )
 
-func RepoName(url string) (string, error) {
+func RepoNameFromURL(url string) (string, error) {
 	if url == "" {
 		return "", fmt.Errorf("URL cannot be empty string")
 	}
@@ -17,7 +19,7 @@ func RepoName(url string) (string, error) {
 
 	// Normalize parts
 	for idx, p := range parts {
-		parts[idx] = strings.ReplaceAll(p, "-", "_")
+		parts[idx] = normalizeStrForRepoName(p)
 	}
 
 	// Remove the extension from the last part of the URL
@@ -30,3 +32,20 @@ func RepoName(url string) (string, error) {
 	// Put parts back together
 	return strings.Join(parts, "_"), nil
 }
+
+func normalizeStrForRepoName(v string) string {
+	return strings.ReplaceAll(v, "-", "_")
+}
+
+func RepoNameFromStr(v string) string {
+	return normalizeStrForRepoName(v)
+}
+
+func RepoNameFromPin(p *spreso.Pin) (string, error) {
+	switch p.PkgRef.Kind {
+	case spreso.RemoteSourceControlPkgRefKind:
+		return RepoNameFromURL(p.PkgRef.Location)
+	default:
+		return RepoNameFromStr(p.PkgRef.Identity), nil
+	}
+}

gazelle/internal/swift/repo_name_test.go

@@ -3,20 +3,53 @@ package swift_test
 import (
 	"testing"
 
+	"github.com/cgrindel/swift_bazel/gazelle/internal/spreso"
 	"github.com/cgrindel/swift_bazel/gazelle/internal/swift"
 	"github.com/stretchr/testify/assert"
 )
 
-func TestRepoName(t *testing.T) {
-	actual, err := swift.RepoName("https://github.com/nicklockwood/SwiftFormat.git")
+func TestRepoNameFromURL(t *testing.T) {
+	actual, err := swift.RepoNameFromURL("https://github.com/nicklockwood/SwiftFormat.git")
 	assert.NoError(t, err)
 	assert.Equal(t, "nicklockwood_SwiftFormat", actual)
 
-	actual, err = swift.RepoName("https://github.com/nicklockwood/SwiftFormat")
+	actual, err = swift.RepoNameFromURL("https://github.com/nicklockwood/SwiftFormat")
 	assert.NoError(t, err)
 	assert.Equal(t, "nicklockwood_SwiftFormat", actual)
 
-	actual, err = swift.RepoName("")
+	actual, err = swift.RepoNameFromURL("")
 	assert.ErrorContains(t, err, "URL cannot be empty string")
 	assert.Equal(t, "", actual)
 }
+
+func TestRepoNameFromStr(t *testing.T) {
+	actual := swift.RepoNameFromStr("swift-argument-parser")
+	assert.Equal(t, "swift_argument_parser", actual)
+}
+
+func TestRepoNameFromPin(t *testing.T) {
+	t.Run("pin is remoteSourceControl", func(t *testing.T) {
+		p := &spreso.Pin{
+			PkgRef: &spreso.PackageReference{
+				Kind:     spreso.RemoteSourceControlPkgRefKind,
+				Location: "https://github.com/apple/swift-argument-parser",
+				Identity: "swift-argument-parser",
+			},
+		}
+		actual, err := swift.RepoNameFromPin(p)
+		assert.NoError(t, err)
+		assert.Equal(t, "apple_swift_argument_parser", actual)
+	})
+	t.Run("pin is not remoteSourceControl", func(t *testing.T) {
+		p := &spreso.Pin{
+			PkgRef: &spreso.PackageReference{
+				Kind:     spreso.LocalSourceControlPkgRefKind,
+				Location: "/path/to/repo",
+				Identity: "swift-argument-parser",
+			},
+		}
+		actual, err := swift.RepoNameFromPin(p)
+		assert.NoError(t, err)
+		assert.Equal(t, "swift_argument_parser", actual)
+	})
+}

gazelle/internal/swift/repo_rule_from_pin.go

@@ -0,0 +1,36 @@
+package swift
+
+import (
+	"fmt"
+
+	"github.com/bazelbuild/bazel-gazelle/rule"
+	"github.com/cgrindel/swift_bazel/gazelle/internal/spreso"
+)
+
+type commitProvider interface {
+	Commit() string
+}
+
+func RepoRuleFromPin(p *spreso.Pin) (*rule.Rule, error) {
+	repoName, err := RepoNameFromPin(p)
+	if err != nil {
+		return nil, err
+	}
+	cp, ok := p.State.(commitProvider)
+	if !ok {
+		return nil, fmt.Errorf("expected pin state to provide a commit hash %T", p.State)
+	}
+
+	r := rule.NewRule(SwiftPkgRuleKind, repoName)
+	r.SetAttr("commit", cp.Commit())
+	r.SetAttr("remote", p.PkgRef.Remote())
+
+	switch t := p.State.(type) {
+	case *spreso.VersionPinState:
+		r.AddComment(fmt.Sprintf("# version: %s", t.Version))
+	case *spreso.BranchPinState:
+		r.AddComment(fmt.Sprintf("# branch: %s", t.Name))
+	}
+
+	return r, nil
+}

gazelle/internal/swift/repo_rule_from_pin_test.go

@@ -0,0 +1,34 @@
+package swift_test
+
+import (
+	"testing"
+
+	"github.com/cgrindel/swift_bazel/gazelle/internal/spreso"
+	"github.com/cgrindel/swift_bazel/gazelle/internal/swift"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRepoRuleFromPin(t *testing.T) {
+	remote := "https://github.com/apple/swift-argument-parser"
+	version := "1.2.3"
+	revision := "12345"
+	p := &spreso.Pin{
+		PkgRef: &spreso.PackageReference{
+			Location: remote,
+		},
+		State: &spreso.VersionPinState{
+			Version:  version,
+			Revision: revision,
+		},
+	}
+	actual, err := swift.RepoRuleFromPin(p)
+	assert.NoError(t, err)
+	assert.Equal(t, swift.SwiftPkgRuleKind, actual.Kind())
+	expectedName, err := swift.RepoNameFromPin(p)
+	assert.NoError(t, err)
+	assert.Equal(t, expectedName, actual.Name())
+	assert.Equal(t, remote, actual.AttrString("remote"))
+	assert.Equal(t, revision, actual.AttrString("commit"))
+	assert.Len(t, actual.Comments(), 1)
+	assert.Contains(t, actual.Comments()[0], "# version: 1.2.3")
+}

gazelle/internal/swift/rule_kinds.go

@@ -2,9 +2,12 @@ package swift
 
 const (
 	LibraryRuleKind = "swift_library"
-	BinaryRuleKind = "swift_binary"
-	TestRuleKind = "swift_test"
- )
+	BinaryRuleKind  = "swift_binary"
+	TestRuleKind    = "swift_test"
+
+	// Repository Rule
+	SwiftPkgRuleKind = "swift_package"
+)
 
 func IsSwiftRuleKind(ruleKind string) bool {
 	switch ruleKind {

gazelle/lang.go

@@ -28,6 +28,12 @@ var loads = []rule.LoadInfo{
 			swift.TestRuleKind,
 		},
 	},
+	{
+		Name: "@cgrindel_swift_bazel//swiftpkg:defs.bzl",
+		Symbols: []string{
+			swift.SwiftPkgRuleKind,
+		},
+	},
 }
 
 type swiftLang struct {

gazelle/update_repos.go

@@ -1,10 +1,13 @@
 package gazelle
 
 import (
-	"log"
+	"os"
 	"path/filepath"
 
 	"github.com/bazelbuild/bazel-gazelle/language"
+	"github.com/bazelbuild/bazel-gazelle/rule"
+	"github.com/cgrindel/swift_bazel/gazelle/internal/spreso"
+	"github.com/cgrindel/swift_bazel/gazelle/internal/swift"
 )
 
 // language.RepoImporter Implementation
@@ -16,19 +19,27 @@ func (*swiftLang) CanImport(path string) bool {
 
 func (*swiftLang) ImportRepos(args language.ImportReposArgs) language.ImportReposResult {
 	result := language.ImportReposResult{}
-	// DEBUG BEGIN
-	log.Printf("*** CHUCK: ImportRepos args: %+#v", args)
-	// DEBUG END
-	return result
-}
 
-// // language.RepoUpdate Implementation
+	// Read the Package.resolved file
+	b, err := os.ReadFile(args.Path)
+	if err != nil {
+		result.Error = err
+		return result
+	}
+	pins, err := spreso.NewPinsFromResolvedPackageJSON(b)
+	if err != nil {
+		result.Error = err
+		return result
+	}
+
+	result.Gen = make([]*rule.Rule, len(pins))
+	for idx, p := range pins {
+		result.Gen[idx], err = swift.RepoRuleFromPin(p)
+		if err != nil {
+			result.Error = err
+			return result
+		}
+	}
 
-// // Update repository rules that provide named libraries
-// func (*swiftLang) UpdateRepos(args language.UpdateReposArgs) language.UpdateReposResult {
-// 	result := language.UpdateReposResult{}
-// 	// DEBUG BEGIN
-// 	log.Printf("*** CHUCK: UpdateRepos args: %+#v", args)
-// 	// DEBUG END
-// 	return result
-// }
+	return result
+}

swiftpkg/BUILD.bazel

@@ -0,0 +1,11 @@
+load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+load("@cgrindel_bazel_starlib//bzlformat:defs.bzl", "bzlformat_pkg")
+
+bzl_library(
+    name = "defs",
+    srcs = ["defs.bzl"],
+    visibility = ["//visibility:public"],
+    deps = ["//swiftpkg/internal:swift_package"],
+)
+
+bzlformat_pkg(name = "bzlformat")

swiftpkg/defs.bzl

@@ -0,0 +1,5 @@
+"""Defines the public API for `swiftpkg`"""
+
+load("//swiftpkg/internal:swift_package.bzl", _swift_package = "swift_package")
+
+swift_package = _swift_package