Sign upLogin

Fs02/grimoire

View on GitHub
Star

Showing 11 of 42 total issues

Query has 34 methods (exceeds 20 allowed). Consider refactoring.
Open

type Query struct {
    repo            *Repo
    Collection      string
    Fields          []string
    AggregateField  string
Severity: Minor
Found in query.go - About 4 hrs to fix

    Method Form.convert has a Cognitive Complexity of 36 (exceeds 20 allowed). Consider refactoring.
    Open

    func (form Form) convert(str string, typ reflect.Type) (interface{}, bool) {
    result := interface{}(nil)
    valid := false

    switch typ.Kind() {
    Severity: Minor
    Found in params/form.go - About 2 hrs 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

    Builder has 22 methods (exceeds 20 allowed). Consider refactoring.
    Open

    type Builder struct {
    config      *Config
    returnField string
    count       int
}
    Severity: Minor
    Found in adapter/sql/bulder.go - About 2 hrs to fix

      Method Form.convert has 73 lines of code (exceeds 50 allowed). Consider refactoring.
      Open

      func (form Form) convert(str string, typ reflect.Type) (interface{}, bool) {
    result := interface{}(nil)
    valid := false

    switch typ.Kind() {
      Severity: Minor
      Found in params/form.go - About 1 hr to fix

        Method JSON.convert has 54 lines of code (exceeds 50 allowed). Consider refactoring.
        Open

        func (json *JSON) convert(value gjson.Result, typ reflect.Type) (interface{}, bool) {
    if value.Type == gjson.Null {
        return nil, true
    }
        Severity: Minor
        Found in params/json.go - About 1 hr to fix

          Function ParseForm has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.
          Open

          func ParseForm(raw url.Values) Form {
    result := make(Form, len(raw))

    for k, v := range raw {
        if len(v) == 0 {
          Severity: Minor
          Found in params/form.go - About 55 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

          Function Not has 9 return statements (exceeds 4 allowed).
          Open

          func Not(inner ...Condition) Condition {
    if len(inner) == 1 {
        c := inner[0]
        switch c.Type {
        case ConditionEq:
          Severity: Major
          Found in c/condition.go - About 55 mins to fix

            Method JSON.convert has 7 return statements (exceeds 4 allowed).
            Open

            func (json *JSON) convert(value gjson.Result, typ reflect.Type) (interface{}, bool) {
    if value.Type == gjson.Null {
        return nil, true
    }
            Severity: Major
            Found in params/json.go - About 45 mins to fix

              Method Map.GetWithType has 6 return statements (exceeds 4 allowed).
              Open

              func (m Map) GetWithType(name string, typ reflect.Type) (interface{}, bool) {
    value := m[name]

    if value == nil {
        return nil, true
              Severity: Major
              Found in params/map.go - About 40 mins to fix

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

                func ValidateRange(ch *Changeset, field string, min int, max int, opts ...Option) {
                Severity: Minor
                Found in changeset/validate_range.go - About 35 mins to fix

                  Method Query.Save has 5 return statements (exceeds 4 allowed).
                  Open

                  func (query Query) Save(record interface{}) error {
    rv := reflect.ValueOf(record)
    rt := rv.Type()
    if rt.Kind() == reflect.Ptr && rt.Elem().Kind() == reflect.Slice {
        // Put multiple records
                  Severity: Major
                  Found in query.go - About 35 mins to fix
                    Severity
                    Category
                    Status
                    Source
                    Language