get

Documentation

Overview

cmd/get/repo.go

Index

• Variables

Variables

var RepoCmd = &cobra.Command{
	Use:   "repo <slug>",
	Short: "Get detailed info for a single repository",
	Args:  cobra.ExactArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		cfg := utils.LoadConfig()
		pk := utils.ProjectKey
		repoSlug := args[0]
		includeBranch := strings.Contains(utils.FieldsToShow, "defaultBranch")
		svc := api.NewRepoService(cfg, pk)
		rs, err := svc.Get(repoSlug)
		if err != nil {
			slog.Error("failed to get repo")
			return
		}

		manifest := map[string]interface{}{}
		if utils.ManifestFile != "" {
			manifest = tryLoadManifest(cfg, pk, repoSlug, utils.ManifestFile)
		}

		repos := []models.RepoEntity{{
			Name:          rs.Name,
			Slug:          rs.Slug,
			Description:   rs.Description,
			State:         rs.State,
			Public:        rs.Public,
			Forkable:      rs.Forkable,
			Archived:      rs.Archived,
			DefaultBranch: rs.DefaultBranch,
		}}

		if includeBranch {
			repos[0].DefaultBranch = *svc.GetDefaultBranch(rs.Slug)
		}

		outMan := map[string]map[string]interface{}{rs.Slug: manifest}

		if utils.OutputFile != "" {
			printRepoYaml(repos, utils.FieldsToShow, outMan)
		} else {
			printRepoFields(repos, utils.FieldsToShow, outMan)
		}
	},
}

var ReposCmd = &cobra.Command{
	Use:   "repos",
	Short: "Get list of repositories",
	Run: func(cmd *cobra.Command, args []string) {
		cfg := utils.LoadConfig()

		projectKey := utils.ProjectKey
		svc := api.NewRepoService(cfg, projectKey)
		summaries, err := svc.List()
		if err != nil {
			slog.Error("failed to list repos")
			slog.Debug("details", slog.Any("err", err))
			return
		}

		filters := parseFilter(utils.FilterExpr)
		manifests := map[string]map[string]interface{}{}
		includeBranch := strings.Contains(utils.FieldsToShow, "defaultBranch")
		includeTemplate := utils.TemplateStr != ""
		repos := make([]models.RepoEntity, 0, len(summaries))

		var wg sync.WaitGroup
		sem := make(chan struct{}, 5)

		for _, rs := range summaries {
			r := models.RepoEntity{
				Name:        rs.Name,
				Slug:        rs.Slug,
				Description: rs.Description,
				State:       rs.State,
				Public:      rs.Public,
				Forkable:    rs.Forkable,
				Archived:    rs.Archived,
			}

			wg.Add(1)
			sem <- struct{}{}
			go func(r models.RepoEntity) {
				defer wg.Done()
				defer func() { <-sem }()

				if includeBranch {
					r.DefaultBranch = *svc.GetDefaultBranch(r.Slug)
				}

				var manifest map[string]interface{}
				if includeTemplate || utils.FilterExpr != "" {
					manifest = tryLoadManifest(cfg, projectKey, r.Slug, utils.ManifestFile)
				}

				if manifest != nil {
					manifests[r.Slug] = manifest
				}

				if utils.FilterExpr != "" {
					if !matchesFilter(manifest, filters) {
						return
					}
				}

				if utils.ManifestExists {
					if manifest != nil {
						repos = append(repos, r)
					}
				} else {
					repos = append(repos, r)
				}
			}(r)
		}
		wg.Wait()

		if utils.OutputFile != "" {
			printRepoYaml(repos, utils.FieldsToShow, manifests)
		} else {
			printRepoFields(repos, utils.FieldsToShow, manifests)
		}
	},
}