Method Container.compareLinks has 5 return statements (exceeds 4 allowed).

Open

func (c *Container) compareLinks(container *dc.Container) (actual, expected string) {
    normalizeLink := func(link string) string {
        // internally links are stored as "/linkedcontainername:/containername/alias"
        parts := strings.Split(link, ":")
        if len(parts) == 1 {

Method Preparer.Prepare has 5 return statements (exceeds 4 allowed).

Open

func (p *Preparer) Prepare(ctx context.Context, r Renderer) (Task, error) {
    value := reflect.ValueOf(p.Destination)
    typ := value.Type()
    wasPtr := false // so we can re-wrap later if we need to

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

Open

func AssertDiff(t *testing.T, diffs map[string]resource.Diff, name, original, current string) bool {
    var ok bool

    if ok = assert.NotEmpty(t, diffs); !ok {
        return false

Method Preparer.convertMap has 5 return statements (exceeds 4 allowed).

Open

func (p *Preparer) convertMap(typ reflect.Type, r Renderer, name string, val interface{}, base int) (reflect.Value, error) {
    if val == nil {
        return reflect.Zero(typ), nil
    }

Method Unarchive.readWrite has 5 return statements (exceeds 4 allowed).

Open

func (u *Unarchive) readWrite(file string) error {
    fileName := strings.TrimPrefix(file, u.fetchDir.Name())

    fStat, err := os.Stat(file)
    if err != nil {

Method pipelineGen.prepareNode has 5 return statements (exceeds 4 allowed).

Open

func (p pipelineGen) prepareNode(ctx context.Context, idi interface{}) (interface{}, error) {
    var metadataErr error

    res, ok := idi.(resource.Resource)
    if !ok {

Method Preparer.convertDuration has 5 return statements (exceeds 4 allowed).

Open

func (p *Preparer) convertDuration(typ reflect.Type, r Renderer, name string, val interface{}, base int) (reflect.Value, error) {
    if val == nil {
        return reflect.Zero(typ), nil
    }

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

Open

func newExportedField(input interface{}, index int) (*ExportedField, bool) {
    if nil == input {
        return nil, false
    }

Method pipelineGen.GetTask has 5 return statements (exceeds 4 allowed).

Open

func (g *pipelineGen) GetTask(ctx context.Context, idi interface{}) (interface{}, error) {
    if thunk, ok := idi.(*render.PrepareThunk); ok {
        thunked, err := thunk.Thunk(g.RenderingPlant)
        if err != nil {
            return nil, err

Method GrapherClient.Graph has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func (gc *GrapherClient) Graph(ctx context.Context, loc *pb.LoadRequest, opts ...grpc.CallOption) (*graph.Graph, error) {
    stream, err := gc.client.Graph(ctx, loc, opts...)
    if err != nil {
        return nil, errors.Wrap(err, "could not open stream")
    }

• Read up
  Read up

Method Preparer.convertTime has 5 return statements (exceeds 4 allowed).

Open

func (p *Preparer) convertTime(typ reflect.Type, r Renderer, name string, val interface{}, base int) (reflect.Value, error) {
    if val == nil {
        return reflect.Zero(typ), nil
    }

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

Open

func getXrefs(g *graph.Graph, id string, node *parse.Node) (out []string, err error) {
    var nodeStrings []string
    var calls []string
    nodeRefs := make(map[string]struct{})
    nodeStrings, err = node.GetStrings()

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

Open

func execPipeline(ctx context.Context, in *graph.Graph, pipelineF MkPipelineF, renderingPlant *render.Factory, notify *graph.Notifier) (*graph.Graph, error) {
    var hasErrors error

    out, err := in.Transform(ctx,
        notify.Transform(func(meta *node.Node, out *graph.Graph) error {

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

Open

        t.Run("automount", func(t *testing.T) {
            t.Parallel()
            u := &Unit{Type: UnitTypeAutoMount, AutomountProperties: &AutomountTypeProperties{Result: "success"}}
            actual, err := getFailedReason(u)
            require.NoError(t, err)

• Read up
  Read up

Method resourceVG.Check has 5 return statements (exceeds 4 allowed).

Open

func (r *resourceVG) Check(context.Context, resource.Renderer) (resource.TaskStatus, error) {
    status := &resource.Status{}

    if err := r.lvm.Check(); err != nil {
        return nil, errors.Wrap(err, "lvm.volumegroup")

Method resourceVG.Apply has 5 return statements (exceeds 4 allowed).

Open

func (r *resourceVG) Apply(context.Context) (status resource.TaskStatus, err error) {
    if r.exists {
        for _, d := range r.devicesToAdd {
            if err := r.lvm.ExtendVolumeGroup(r.name, d); err != nil {
                return nil, errors.Wrapf(err, "extending volume group")

Method Printer.DrawEdge has 5 return statements (exceeds 4 allowed).

Open

func (p *Printer) DrawEdge(g *graph.Graph, id1, id2 string) (pp.Renderable, error) {
    var srcVal, destVal interface{}

    if src, ok := g.Get(id1); ok {
        srcVal = src.Value()

Method Graph.IsNibling has 5 return statements (exceeds 4 allowed).

Open

func (g *Graph) IsNibling(fst, snd string) bool {
    sndID, sndHasParent := g.GetParentID(snd)
    if !sndHasParent {
        return false
    }

Method pipelineGen.maybeRunFinalCheck has 5 return statements (exceeds 4 allowed).

Open

func (g *pipelineGen) maybeRunFinalCheck(ctx context.Context, resultI interface{}) (interface{}, error) {
    result, ok := resultI.(*Result)
    if !ok {
        return nil, fmt.Errorf("expected *Result but got %T", resultI)
    }

Method resourceFS.Check has 5 return statements (exceeds 4 allowed).

Open

func (r *resourceFS) Check(context.Context, resource.Renderer) (resource.TaskStatus, error) {
    status := &resource.Status{}

    if err := r.lvm.CheckFilesystemTools(r.mount.Type); err != nil {
        return nil, errors.Wrapf(err, "filesystem prerequisites for %s", r.mount.Type)