Similar blocks of code found in 2 locations. Consider refactoring.

Open

func postRunPlugins(pluginsRootPath string, plugins []*domain.Plugin) error {
    for _, plugin := range plugins {
        if plugin.ExecNumber <= 0 {
            continue
        }

• Read up
  Read up

Method Service.getRepository has 6 return statements (exceeds 4 allowed).

Open

func (s Service) getRepository(url *url.URL) (*repo, error) {
    if url.Hostname() != "github.com" {
        return nil, fmt.Errorf("invalid host %s", url.Hostname())
    }

Method packageStore.RemovePackage has 6 return statements (exceeds 4 allowed).

Open

func (ps packageStore) RemovePackage(label string) error {
    tx := ps.db.Begin()
    defer func() {
        if r := recover(); r != nil {
            tx.Rollback()

Method repo.setBranch has 6 return statements (exceeds 4 allowed).

Open

func (r *repo) setBranch(ctx context.Context, isAuthenticated bool) error {
    // Skip if a branch was already set
    if r.branch != "" {
        return nil
    }

Method projectService.CreateProject has 6 return statements (exceeds 4 allowed).

Open

func (ps projectService) CreateProject(configRootPath string, project *domain.Project) (err error) {
    // Create the root folder of the project.
    err = createProjectRootFolder(project.Path)
    if err != nil {
        return errors.Wrap(err, "create base folder")

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

Open

func newProjectSetPathCommand() *projectSetPath {
    cmd := &cobra.Command{
        Use:                   "path OLD-PATH NEW-PATH",
        Short:                 "Set a new path",
        Aliases:               []string{"p"},

Method packageService.ImportPackagesFromCollection has 5 return statements (exceeds 4 allowed).

Open

func (ps packageService) ImportPackagesFromCollection(url *url.URL, exclude *regexp.Regexp) ([]*domain.Package, error) {
    // Get code repo
    codeRepo, err := remote.NewCodeRepository(url, ps.authentication)
    if err != nil {
        return nil, errors.Wrap(err, "get code repository")

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

Open

func newProjectAddCommand() *projectAddCommand {
    cmd := &cobra.Command{
        Use:                   "add LABEL PATH",
        Short:                 "Add an existing project",
        Aliases:               []string{"a"},

Method packageService.ImportPackageFromConfig has 5 return statements (exceeds 4 allowed).

Open

func (ps packageService) ImportPackageFromConfig(path string) (*domain.Package, error) {
    // Validate file path
    err := isConfigPathValid(path)
    if err != nil {
        return nil, err

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

Open

func storePlugins(tx *gorm.DB, plugins []*domain.Plugin, packageID uint) error {
    var err error
    insertPluginStmt := "INSERT OR IGNORE INTO plugins (created_at, updated_at, path, exec_number, description) VALUES (?, ?, ?, ?, ?)"
    insertAssociationStmt := "INSERT OR IGNORE INTO package_plugins (package_id, plugin_id) VALUES (?, ?)"
    queryIDStmt := "SELECT id from plugins WHERE path = ?"

Method packageStore.deepQueryPackage has 5 return statements (exceeds 4 allowed).

Open

func (ps packageStore) deepQueryPackage(conditions string, values ...string) (pkg *domain.Package, err error) {
    rows, err := ps.db.Raw(defaultPackageDeepQueryBase+" "+conditions, values).Rows()
    if err != nil {
        return nil, err
    }

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

Open

func newPackageRemoveCommand() *packageRemoveCommand {
    var removeAllPackages, forceRemovePackages bool

    cmd := &cobra.Command{
        Use:     "rm LABEL [LABEL...]",

• Read up
  Read up

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

Open

func newPackageImportCommand() *packageImportCommand {
    var remoteRepos, directories, configs, packages, collections []string

    cmd := &cobra.Command{
        Use:     "import FROM [FROM...]",

Method projectStore.StoreProject has 5 return statements (exceeds 4 allowed).

Open

func (ps *projectStore) StoreProject(project *domain.Project) error {
    err := ps.db.Where("path = ?", project.Path).First(project).Error
    if err == nil {
        return ErrProjectExists
    }

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

Open

func storeTemplates(tx *gorm.DB, templates []*domain.Template, packageID uint) error {
    insertTemplateStmt := "INSERT OR IGNORE INTO templates (created_at, updated_at, is_file, destination, path, description) VALUES (?, ?, ?, ?, ?, ?)"
    insertAssociationStmt := "INSERT OR IGNORE INTO package_templates (package_id, template_id) VALUES (?, ?)"
    queryIDStmt := "SELECT id from templates WHERE destination = ? AND path = ?"
    for _, template := range templates {

Method packageService.ImportPackageFromRemote has 5 return statements (exceeds 4 allowed).

Open

func (ps packageService) ImportPackageFromRemote(url *url.URL) (*domain.Package, error) {
    // Get code repo
    codeRepo, err := remote.NewCodeRepository(url, ps.authentication)
    if err != nil {
        return nil, errors.Wrap(err, "get code repository")

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

Open

func newProjectRemoveCommand() *projectRemoveCommand {
    var removeAllProjects, forceRemoveProjects bool

    cmd := &cobra.Command{
        Use:     "rm PATH [PATH...]",