Method Result.walkWithResult has 5 return statements (exceeds 4 allowed).

Open

func (r *Result) walkWithResult(f func(r *Result, sr *SubmoduleResult, lsTreeEntry *LsTreeEntry) error) error {
    if err := r.lsTreeEntriesWalkWithResult(f); err != nil {
        return err
    }

Method Local.Unshallow has 5 return statements (exceeds 4 allowed).

Open

func (repo *Local) Unshallow(ctx context.Context) error {
    if lock, err := repo.acquireFetchLock(ctx); err != nil {
        return fmt.Errorf("unable to acquire fetch lock: %w", err)
    } else {
        defer werf.ReleaseHostLock(lock)

Function DoTasks has 5 return statements (exceeds 4 allowed).

Open

func DoTasks(ctx context.Context, numberOfTasks int, options DoTasksOptions, taskFunc func(ctx context.Context, taskId int) error) error {
    if numberOfTasks == 0 {
        return nil
    }

Function revertExcludedChangesInServiceWorktreeIndex has 5 return statements (exceeds 4 allowed).

Open

func revertExcludedChangesInServiceWorktreeIndex(ctx context.Context, sourceWorktreeDir, serviceWorktreeDir, sourceCommit, serviceBranchHeadCommit string, globExcludeList []string) (bool, error) {
    if len(globExcludeList) == 0 || serviceBranchHeadCommit == sourceCommit {
        return false, nil
    }

Method includePathMatcher.shouldGoThrough has 5 return statements (exceeds 4 allowed).

Open

func (m includePathMatcher) shouldGoThrough(path string) bool {
    if len(m.includeGlobs) == 0 {
        return false
    }

Function parsePrivateSSHKey has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func parsePrivateSSHKey(cfg sshKeyConfig) (sshKey, error) {
    keyData, err := ioutil.ReadFile(cfg.FilePath)
    if err != nil {
        return sshKey{}, fmt.Errorf("error reading key file %q: %w", cfg.FilePath, err)
    }

• Read up
  Read up

Method dockerHubApi.getToken has 5 return statements (exceeds 4 allowed).

Open

func (api *dockerHubApi) getToken(ctx context.Context, username, password string) (string, *http.Response, error) {
    url := "https://hub.docker.com/v2/users/login/"
    body, err := json.Marshal(map[string]string{
        "username": username,
        "password": password,

Method rawStapelImage.UnmarshalYAML has 5 return statements (exceeds 4 allowed).

Open

func (c *rawStapelImage) UnmarshalYAML(unmarshal func(interface{}) error) error {
    parentStack.Push(c)
    type plain rawStapelImage
    err := unmarshal((*plain)(c))
    parentStack.Pop()

Method rawStageDependencies.toDirective has 5 return statements (exceeds 4 allowed).

Open

func (c *rawStageDependencies) toDirective() (stageDependencies *StageDependencies, err error) {
    stageDependencies = &StageDependencies{}

    if install, err := InterfaceToStringArray(c.Install, c, c.rawGit.rawStapelImage.doc); err != nil {
        return nil, err

Method FullDockerfileStage.GetDependencies has 5 return statements (exceeds 4 allowed).

Open

func (s *FullDockerfileStage) GetDependencies(ctx context.Context, c Conveyor, cb container_backend.ContainerBackend, prevImage, prevBuiltImage *StageImage, buildContextArchive container_backend.BuildContextArchiver) (string, error) {
    resolvedDependenciesArgsHash := ResolveDependenciesArgs(s.targetPlatform, s.dependencies, c)

    resolvedDockerMetaArgsHash, err := s.resolveDockerMetaArgs(resolvedDependenciesArgsHash)
    if err != nil {

Method container.RmIfExist has 5 return statements (exceeds 4 allowed).

Open

func (c *container) RmIfExist(ctx context.Context) error {
    exist, err := docker.ContainerExist(ctx, c.Name)
    if err != nil {
        return err
    }

Method BuildContextArchive.Create has 5 return statements (exceeds 4 allowed).

Open

func (a *BuildContextArchive) Create(ctx context.Context, opts container_backend.BuildContextArchiveCreateOptions) error {
    contextPathRelativeToGitWorkTree := filepath.Join(a.giterminismMgr.RelativeToGitProjectDir(), opts.ContextGitSubDir)

    dockerIgnorePathMatcher, err := createDockerIgnorePathMatcher(ctx, a.giterminismMgr, opts.ContextGitSubDir, opts.DockerfileRelToContextPath)
    if err != nil {

Method WerfConfig.validateDependenciesImages has 5 return statements (exceeds 4 allowed).

Open

func (c *WerfConfig) validateDependenciesImages() error {
    for _, dfImage := range c.ImagesFromDockerfile {
        for _, imgDep := range dfImage.Dependencies {
            if imgDep.ImageName == dfImage.Name {
                return newDetailedConfigError(fmt.Sprintf("image can't depend on itself: `%s`!", imgDep.ImageName), imgDep.raw, dfImage.raw.doc)

Method Image.setupBaseImageRepoDigest has 5 return statements (exceeds 4 allowed).

Open

func (i *Image) setupBaseImageRepoDigest(ctx context.Context, reference string) error {
    i.Conveyor.GetServiceRWMutex("baseImagesRepoIdsCache" + reference).Lock()
    defer i.Conveyor.GetServiceRWMutex("baseImagesRepoIdsCache" + reference).Unlock()

    switch {

Method StapelImageBase.validate has 5 return statements (exceeds 4 allowed).

Open

func (c *StapelImageBase) validate(giterminismManager giterminism_manager.Interface) error {
    if c.FromLatest {
        if err := giterminismManager.Inspector().InspectConfigStapelFromLatest(); err != nil {
            return newDetailedConfigError(err.Error(), nil, c.raw.doc)
        }

Method _escStaticFS.prepare has 5 return statements (exceeds 4 allowed).

Open

func (_escStaticFS) prepare(name string) (*_escFile, error) {
    f, present := _escData[path.Clean(name)]
    if !present {
        return nil, os.ErrNotExist
    }

Function RunAutoHostCleanup has 5 return statements (exceeds 4 allowed).

Open

func RunAutoHostCleanup(ctx context.Context, options AutoHostCleanupOptions) error {
    if !options.ForceShouldRun {
        shouldRun, err := ShouldRunAutoHostCleanup(ctx, options.HostCleanupOptions)
        if err != nil {
            logboek.Context(ctx).Warn().LogF("WARNING: unable to check if auto host cleanup should be run: %s\n", err)

Function InterfaceToStringArray has 5 return statements (exceeds 4 allowed).

Open

func InterfaceToStringArray(stringOrStringArray, configSection interface{}, doc *doc) ([]string, error) {
    if stringOrStringArray == nil {
        return []string{}, nil
    } else if val, ok := stringOrStringArray.(string); ok {
        return []string{val}, nil

Method GitCacheStage.gitMappingsPatchSize has 5 return statements (exceeds 4 allowed).

Open

func (s *GitCacheStage) gitMappingsPatchSize(ctx context.Context, c Conveyor, prevBuiltImage *StageImage) (int64, error) {
    var size int64
    for _, gitMapping := range s.gitMappings {
        commit, err := gitMapping.GetBaseCommitForPrevBuiltImage(ctx, c, prevBuiltImage)
        if err != nil {

Method WerfConfig.validateImageFrom has 5 return statements (exceeds 4 allowed).

Open

func (c *WerfConfig) validateImageFrom(i *StapelImageBase) error {
    if i.raw.FromImage != "" {
        fromImageName := i.raw.FromImage

        if fromImageName == i.Name {