asteris-llc/converge

View on GitHub

Showing 247 of 615 total issues

Function isExportedField has 6 return statements (exceeds 4 allowed).
Open

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

Severity: Major
Found in resource/field_extractor.go - About 40 mins to fix

    Function Parse has 6 return statements (exceeds 4 allowed).
    Open

    func Parse(content []byte) (resources []*Node, err error) {
        obj, err := hcl.ParseBytes(content)
        if err != nil {
            return resources, err
        }
    Severity: Major
    Found in parse/parse.go - About 40 mins to fix

      Function loadKeyring has 6 return statements (exceeds 4 allowed).
      Open

      func loadKeyring(ks *Keystore) (openpgp.KeyRing, error) {
          var keyring openpgp.EntityList
          trustedKeys := make(map[string]*openpgp.Entity)
      
          for _, p := range []string{ks.SystemPath, ks.UserPath, ks.LocalPath} {
      Severity: Major
      Found in keystore/keystore.go - About 40 mins to fix

        Function TestNotifyTransform has 6 return statements (exceeds 4 allowed).
        Open

        func TestNotifyTransform(t *testing.T) {
            g := graph.New()
            g.Add(node.New("root", 1))
        
            doNothing := func(*node.Node, *graph.Graph) error { return nil }
        Severity: Major
        Found in graph/notifier_test.go - About 40 mins to fix

          Method Printer.DrawNode has 6 return statements (exceeds 4 allowed).
          Open

          func (p *Printer) DrawNode(g *graph.Graph, id string) (pp.Renderable, error) {
              meta, ok := g.Get(id)
              if !ok {
                  return pp.HiddenString(), nil
              }
          Severity: Major
          Found in prettyprinters/human/human.go - About 40 mins to fix

            Function expandSwitchMacro has 6 return statements (exceeds 4 allowed).
            Open

            func expandSwitchMacro(data []byte, current *source, n *parse.Node, g *graph.Graph) (*graph.Graph, error) {
                if !control.IsSwitchNode(n) {
                    return g, nil
                }
                switchObj, err := control.NewSwitch(n, data)
            Severity: Major
            Found in load/nodes.go - About 40 mins to fix

              Method Printer.Show has 6 return statements (exceeds 4 allowed).
              Open

              func (p Printer) Show(ctx context.Context, g *graph.Graph) (string, error) {
                  outputBuffer := new(bytes.Buffer)
                  write := func(s Renderable) { outputBuffer.WriteString(s.String()) }
              
                  subgraphs := makeSubgraphMap()
              Severity: Major
              Found in prettyprinters/prettyprinter.go - About 40 mins to fix

                Method Preparer.convertValue has 5 arguments (exceeds 4 allowed). Consider refactoring.
                Open

                func (p *Preparer) convertValue(typ reflect.Type, r Renderer, name string, val interface{}, base int) (out reflect.Value, err error) {
                Severity: Minor
                Found in resource/preparer.go - About 35 mins to fix

                  Method Preparer.convertMap has 5 arguments (exceeds 4 allowed). Consider refactoring.
                  Open

                  func (p *Preparer) convertMap(typ reflect.Type, r Renderer, name string, val interface{}, base int) (reflect.Value, error) {
                  Severity: Minor
                  Found in resource/preparer.go - About 35 mins to fix

                    Method Preparer.convertNumber has 5 arguments (exceeds 4 allowed). Consider refactoring.
                    Open

                    func (p *Preparer) convertNumber(typ reflect.Type, r Renderer, name string, val interface{}, base int) (reflect.Value, error) {
                    Severity: Minor
                    Found in resource/preparer.go - About 35 mins to fix

                      Method Preparer.convertDuration has 5 arguments (exceeds 4 allowed). Consider refactoring.
                      Open

                      func (p *Preparer) convertDuration(typ reflect.Type, r Renderer, name string, val interface{}, base int) (reflect.Value, error) {
                      Severity: Minor
                      Found in resource/preparer.go - About 35 mins to fix

                        Method Preparer.convertInterface has 5 arguments (exceeds 4 allowed). Consider refactoring.
                        Open

                        func (p *Preparer) convertInterface(typ reflect.Type, r Renderer, name string, val interface{}, base int) (reflect.Value, error) {
                        Severity: Minor
                        Found in resource/preparer.go - About 35 mins to fix

                          Method Preparer.convertTime has 5 arguments (exceeds 4 allowed). Consider refactoring.
                          Open

                          func (p *Preparer) convertTime(typ reflect.Type, r Renderer, name string, val interface{}, base int) (reflect.Value, error) {
                          Severity: Minor
                          Found in resource/preparer.go - About 35 mins to fix

                            Method Preparer.convertSlice has 5 arguments (exceeds 4 allowed). Consider refactoring.
                            Open

                            func (p *Preparer) convertSlice(typ reflect.Type, r Renderer, name string, val interface{}, base int) (reflect.Value, error) {
                            Severity: Minor
                            Found in resource/preparer.go - About 35 mins to fix

                              Function VertexSplitTraverse has 5 arguments (exceeds 4 allowed). Consider refactoring.
                              Open

                              func VertexSplitTraverse(g *graph.Graph, toFind string, startingNode string, stop func(*graph.Graph, string) bool, history map[string]struct{}) (string, string, bool) {
                              Severity: Minor
                              Found in render/preprocessor/preprocessor.go - About 35 mins to fix

                                Method Preparer.convertPointer has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                Open

                                func (p *Preparer) convertPointer(typ reflect.Type, r Renderer, name string, val interface{}, base int) (reflect.Value, error) {
                                Severity: Minor
                                Found in resource/preparer.go - About 35 mins to fix

                                  Function newMockOS has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                  Open

                                  func newMockOS(ownedFiles []ownershipRecord,
                                      users []*user.User,
                                      groups []*user.Group,
                                      defaultUser *user.User,
                                      defaultGroup *user.Group,
                                  Severity: Minor
                                  Found in resource/file/owner/helper_test.go - About 35 mins to fix

                                    Function simpleApplySuccess has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                    Open

                                    func simpleApplySuccess(t *testing.T, lvm lowlevel.LVM, group string, name string, size *lowlevel.LvmSize) resource.TaskStatus {
                                    Severity: Minor
                                    Found in resource/lvm/lv/lv_test.go - About 35 mins to fix

                                      Function NewResourceVG has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                      Open

                                      func NewResourceVG(lvm lowlevel.LVM, name string, devs []string, remove bool, forceRemove bool) resource.Task {
                                      Severity: Minor
                                      Found in resource/lvm/vg/vg.go - About 35 mins to fix

                                        Function execPipeline has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                        Open

                                        func execPipeline(ctx context.Context, in *graph.Graph, pipelineF MkPipelineF, renderingPlant *render.Factory, notify *graph.Notifier) (*graph.Graph, error) {
                                        Severity: Minor
                                        Found in apply/apply.go - About 35 mins to fix
                                          Severity
                                          Category
                                          Status
                                          Source
                                          Language