Sign upLogin

lflux/eve-sdeloader

View on GitHub
Star

Showing 39 of 182 total issues

Method Planet.ImportMoons has 8 return statements (exceeds 4 allowed).
Open

func (p *Planet) ImportMoons() error {
    var moons = make(Moons, 0, len(p.Moons))
    var err error
    for moonID, moon := range p.Moons {
        moon.moonID = moonID
Severity: Major
Found in universe/planet.go - About 50 mins to fix

    Function importInvUniqueNames has 7 return statements (exceeds 4 allowed).
    Open

    func importInvUniqueNames(db *sql.DB, r io.Reader) error {
    var err error
    tx, err := db.Begin()
    if err != nil {
        return err
    Severity: Major
    Found in bsd/inv_unique_names.go - About 45 mins to fix

      Function importInvPositions has 7 return statements (exceeds 4 allowed).
      Open

      func importInvPositions(db *sql.DB, r io.Reader) error {
    var err error
    tx, err := db.Begin()
    if err != nil {
        return err
      Severity: Major
      Found in bsd/inv_positions.go - About 45 mins to fix

        Function ImportSkins has 7 return statements (exceeds 4 allowed).
        Open

        func ImportSkins(db *sql.DB, r io.Reader) error {
    defer utils.TimeTrack(time.Now(), "skins")

    entries := make(map[string]*Skin)
        Severity: Major
        Found in skins/import_skins.go - About 45 mins to fix

          Function importDgmTypeAttributes has 7 return statements (exceeds 4 allowed).
          Open

          func importDgmTypeAttributes(db *sql.DB, r io.Reader) error {
    var err error
    tx, err := db.Begin()
    if err != nil {
        return err
          Severity: Major
          Found in bsd/dgm_type_attributes.go - About 45 mins to fix

            Function importInvNames has 7 return statements (exceeds 4 allowed).
            Open

            func importInvNames(db *sql.DB, r io.Reader) error {
    var err error
    tx, err := db.Begin()
    if err != nil {
        return err
            Severity: Major
            Found in bsd/inv_names.go - About 45 mins to fix

              Function importInvItems has 7 return statements (exceeds 4 allowed).
              Open

              func importInvItems(db *sql.DB, r io.Reader) error {
    var err error
    tx, err := db.Begin()
    if err != nil {
        return err
              Severity: Major
              Found in bsd/inv_items.go - About 45 mins to fix

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

                func Import(db *sql.DB, regionPath, invNamePath string) error {
    regions, err := filepath.Glob(filepath.Join(regionPath, "*", "*", "region.staticdata"))

    if err != nil {
        return err
                Severity: Major
                Found in universe/import.go - About 40 mins to fix

                  Method Importer.importToTable has 6 return statements (exceeds 4 allowed).
                  Open

                  func (i *Importer) importToTable(tableName string, r io.Reader) error {
    statements := make(map[string]*sql.Stmt)

    buf, err := ioutil.ReadAll(r)
    if err != nil {
                  Severity: Major
                  Found in bsd/import.go - About 40 mins to fix

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

                    func Import(db *sql.DB, r io.Reader) error {
    defer utils.TimeTrack(time.Now(), "graphics")

    entries := make(map[string]*Graphic)
    err := utils.LoadFromReader(r, entries)
                    Severity: Major
                    Found in graphics/import.go - About 40 mins to fix

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

                      func Import(db *sql.DB, r io.Reader) error {
    defer utils.TimeTrack(time.Now(), "certificates")

    entries := make(map[string]*Certificate)
                      Severity: Major
                      Found in certificates/import.go - About 40 mins to fix

                        Function Import has 5 return statements (exceeds 4 allowed).
                        Open

                        func Import(db *sql.DB, r io.Reader) error {
    defer utils.TimeTrack(time.Now(), "icons")

    entries := make(map[int64]*Icon)
                        Severity: Major
                        Found in icons/import.go - About 35 mins to fix

                          Function ImportVolume1 has 5 return statements (exceeds 4 allowed).
                          Open

                          func ImportVolume1(db *sql.DB, path string) error {
    defer utils.TimeTrack(time.Now(), "volume1")

    records, err := readCSV(path)
    if err != nil {
                          Severity: Major
                          Found in volumes/import.go - About 35 mins to fix

                            Method Planet.ImportBelts has 5 return statements (exceeds 4 allowed).
                            Open

                            func (p *Planet) ImportBelts() error {
    var err error
    var belts = make(AsteroidBelts, 0, len(p.AsteroidBelts))
    for beltID, belt := range p.AsteroidBelts {
        belt.planet = p
                            Severity: Major
                            Found in universe/planet.go - About 35 mins to fix

                              Function ImportMaterials has 5 return statements (exceeds 4 allowed).
                              Open

                              func ImportMaterials(db *sql.DB, r io.Reader) error {
    defer utils.TimeTrack(time.Now(), "skin materials")

    entries := make(map[string]*SkinMaterial)
                              Severity: Major
                              Found in skins/import_materials.go - About 35 mins to fix

                                Function ExecDDLFromFile has 5 return statements (exceeds 4 allowed).
                                Open

                                func ExecDDLFromFile(db *sql.DB, path string) error {
    f, err := os.Open(path)
    if err != nil {
        return err
    }
                                Severity: Major
                                Found in utils/exec_ddl.go - About 35 mins to fix

                                  Function ImportVolume2 has 5 return statements (exceeds 4 allowed).
                                  Open

                                  func ImportVolume2(db *sql.DB, path string) error {
    defer utils.TimeTrack(time.Now(), "volume2")

    records, err := readCSV(path)
    if err != nil {
                                  Severity: Major
                                  Found in volumes/import.go - About 35 mins to fix

                                    Function ImportLicenses has 5 return statements (exceeds 4 allowed).
                                    Open

                                    func ImportLicenses(db *sql.DB, r io.Reader) error {
    defer utils.TimeTrack(time.Now(), "skin licenses")

    entries := make(map[string]*SkinLicense)
                                    Severity: Major
                                    Found in skins/import_licenses.go - About 35 mins to fix

                                      Method Planet.ImportMoons has a Cognitive Complexity of 21 (exceeds 20 allowed). Consider refactoring.
                                      Open

                                      func (p *Planet) ImportMoons() error {
    var moons = make(Moons, 0, len(p.Moons))
    var err error
    for moonID, moon := range p.Moons {
        moon.moonID = moonID
                                      Severity: Minor
                                      Found in universe/planet.go - About 25 mins to fix

                                      Cognitive Complexity

                                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                      A method's cognitive complexity is based on a few simple rules:

                                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                      • Code is considered more complex for each "break in the linear flow of the code"
                                      • Code is considered more complex when "flow breaking structures are nested"

                                      Further reading

                                      Severity
                                      Category
                                      Status
                                      Source
                                      Language