Showing 22 of 28 total issues
File schema_generator.go
has 673 lines of code (exceeds 500 allowed). Consider refactoring. Open
package generator
import (
"errors"
"fmt"
Method schemaGenerator.generateStructType
has a Cognitive Complexity of 49 (exceeds 20 allowed). Consider refactoring. Open
func (g *schemaGenerator) generateStructType(
t *schemas.Type,
scope nameScope,
) (codegen.Type, error) {
if len(t.Properties) == 0 {
- Read upRead up
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
Method schemaGenerator.generateEnumType
has a Cognitive Complexity of 46 (exceeds 20 allowed). Consider refactoring. Open
func (g *schemaGenerator) generateEnumType(
t *schemas.Type, scope nameScope,
) (codegen.Type, error) {
if len(t.Enum) == 0 {
return nil, errEnumArrCannotBeEmpty
- Read upRead up
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
Method schemaGenerator.generateTypeInline
has a Cognitive Complexity of 46 (exceeds 20 allowed). Consider refactoring. Open
func (g *schemaGenerator) generateTypeInline(
t *schemas.Type,
scope nameScope,
) (codegen.Type, error) {
two := 2
- Read upRead up
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
Method schemaGenerator.generateStructType
has 139 lines of code (exceeds 50 allowed). Consider refactoring. Open
func (g *schemaGenerator) generateStructType(
t *schemas.Type,
scope nameScope,
) (codegen.Type, error) {
if len(t.Properties) == 0 {
Method schemaGenerator.generateReferencedType
has 116 lines of code (exceeds 50 allowed). Consider refactoring. Open
func (g *schemaGenerator) generateReferencedType(ref string) (codegen.Type, error) {
refType, err := schemas.GetRefType(ref)
if err != nil {
return nil, fmt.Errorf("%w: %w", errCannotGenerateReferencedType, err)
}
Method schemaGenerator.generateReferencedType
has a Cognitive Complexity of 38 (exceeds 20 allowed). Consider refactoring. Open
func (g *schemaGenerator) generateReferencedType(ref string) (codegen.Type, error) {
refType, err := schemas.GetRefType(ref)
if err != nil {
return nil, fmt.Errorf("%w: %w", errCannotGenerateReferencedType, err)
}
- Read upRead up
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
Method schemaGenerator.generateEnumType
has 106 lines of code (exceeds 50 allowed). Consider refactoring. Open
func (g *schemaGenerator) generateEnumType(
t *schemas.Type, scope nameScope,
) (codegen.Type, error) {
if len(t.Enum) == 0 {
return nil, errEnumArrCannotBeEmpty
Function PrimitiveTypeFromJSONSchemaType
has 91 lines of code (exceeds 50 allowed). Consider refactoring. Open
func PrimitiveTypeFromJSONSchemaType(jsType, format string, pointer bool) (Type, error) {
var t Type
switch jsType {
case schemas.TypeNameString:
Method schemaGenerator.generateType
has a Cognitive Complexity of 27 (exceeds 20 allowed). Consider refactoring. Open
func (g *schemaGenerator) generateType(
t *schemas.Type,
scope nameScope,
) (codegen.Type, error) {
typeIndex := 0
- Read upRead up
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
Method schemaGenerator.generateDeclaredType
has 59 lines of code (exceeds 50 allowed). Consider refactoring. Open
func (g *schemaGenerator) generateDeclaredType(
t *schemas.Type, scope nameScope,
) (codegen.Type, error) {
if decl, ok := g.output.declsBySchema[t]; ok {
return &codegen.NamedType{Decl: decl}, nil
Method schemaGenerator.generateType
has 59 lines of code (exceeds 50 allowed). Consider refactoring. Open
func (g *schemaGenerator) generateType(
t *schemas.Type,
scope nameScope,
) (codegen.Type, error) {
typeIndex := 0
Method schemaGenerator.generateReferencedType
has 13 return statements (exceeds 4 allowed). Open
func (g *schemaGenerator) generateReferencedType(ref string) (codegen.Type, error) {
refType, err := schemas.GetRefType(ref)
if err != nil {
return nil, fmt.Errorf("%w: %w", errCannotGenerateReferencedType, err)
}
Method schemaGenerator.generateTypeInline
has 56 lines of code (exceeds 50 allowed). Consider refactoring. Open
func (g *schemaGenerator) generateTypeInline(
t *schemas.Type,
scope nameScope,
) (codegen.Type, error) {
two := 2
Method schemaGenerator.generateDeclaredType
has a Cognitive Complexity of 25 (exceeds 20 allowed). Consider refactoring. Open
func (g *schemaGenerator) generateDeclaredType(
t *schemas.Type, scope nameScope,
) (codegen.Type, error) {
if decl, ok := g.output.declsBySchema[t]; ok {
return &codegen.NamedType{Decl: decl}, nil
- Read upRead up
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
Method schemaGenerator.generateType
has 11 return statements (exceeds 4 allowed). Open
func (g *schemaGenerator) generateType(
t *schemas.Type,
scope nameScope,
) (codegen.Type, error) {
typeIndex := 0
Method schemaGenerator.generateTypeInline
has 9 return statements (exceeds 4 allowed). Open
func (g *schemaGenerator) generateTypeInline(
t *schemas.Type,
scope nameScope,
) (codegen.Type, error) {
two := 2
Function PrimitiveTypeFromJSONSchemaType
has 9 return statements (exceeds 4 allowed). Open
func PrimitiveTypeFromJSONSchemaType(jsType, format string, pointer bool) (Type, error) {
var t Type
switch jsType {
case schemas.TypeNameString:
Method schemaGenerator.generateDeclaredType
has 6 return statements (exceeds 4 allowed). Open
func (g *schemaGenerator) generateDeclaredType(
t *schemas.Type, scope nameScope,
) (codegen.Type, error) {
if decl, ok := g.output.declsBySchema[t]; ok {
return &codegen.NamedType{Decl: decl}, nil
Method Package.Generate
has 5 return statements (exceeds 4 allowed). Open
func (p *Package) Generate(out *Emitter) {
out.Comment(p.Comment)
out.Printlnf("package %s", p.Name())
if len(p.Imports) > 0 {