cli.indexCaseInsensitive - Code Metrics - Inspection of "new flag to allow skipping errors in tables" - fraenky8/tables-to-go - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#20)

unknown

created 2019-07-16 21:12 UTC

cli.indexCaseInsensitive A

↳ Parent: internal/cli/tables-to-go-cli.go

Complexity

Conditions

Size

Total Lines	3
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	3
nop	2
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10
c	0
b	0
f	0

package cli

import (
	"fmt"
	"strings"

	"github.com/fraenky8/tables-to-go/pkg/database"
	"github.com/fraenky8/tables-to-go/pkg/output"
	"github.com/fraenky8/tables-to-go/pkg/settings"
	"github.com/fraenky8/tables-to-go/pkg/tagger"
)

var (
	taggers tagger.Tagger

	// some strings for idiomatic go in column names
	// see https://github.com/golang/go/wiki/CodeReviewComments#initialisms
	initialisms = []string{"ID", "JSON", "XML", "HTTP", "URL"}
)

// Run runs the transformations by creating the concrete Database by the provided settings
func Run(settings *settings.Settings, db database.Database, out output.Writer) (err error) {

	taggers = tagger.NewTaggers(settings)

	fmt.Printf("running for %q...\r\n", settings.DbType)

	tables, err := db.GetTables()
	if err != nil {
		return fmt.Errorf("could not get tables: %v", err)
	}

	if settings.Verbose {
		fmt.Printf("> number of tables: %v\r\n", len(tables))
	}

	if err = db.PrepareGetColumnsOfTableStmt(); err != nil {
		return fmt.Errorf("could not prepare the get-column-statement: %v", err)
	}

	for _, table := range tables {

		if settings.Verbose {
			fmt.Printf("> processing table %q\r\n", table.Name)
		}

		if err = db.GetColumnsOfTable(table); err != nil {
			if !settings.Force {
				return fmt.Errorf("could not get columns of table %q: %v", table.Name, err)
			}
			fmt.Printf("could not get columns of table %q: %v\n", table.Name, err)
			continue
		}

		if settings.Verbose {
			fmt.Printf("\t> number of columns: %v\r\n", len(table.Columns))
		}

		tableName, content := createTableStructString(settings, db, table)

		err = out.Write(tableName, content)
		if err != nil {
			if !settings.Force {
				return fmt.Errorf("could not write struct for table %q: %v", table.Name, err)
			}
			fmt.Printf("could not write struct for table %q: %v\n", table.Name, err)
		}
	}

	fmt.Println("done!")

	return nil
}

type columnInfo struct {
	isNullable          bool
	isTemporal          bool
	isNullablePrimitive bool
	isNullableTemporal  bool
}

func (c columnInfo) hasTrue() bool {
	return c.isNullable || c.isTemporal || c.isNullableTemporal || c.isNullablePrimitive
}

func createTableStructString(settings *settings.Settings, db database.Database, table *database.Table) (string, string) {

	var structFields strings.Builder

	columnInfo := columnInfo{}
	columns := map[string]struct{}{}

	for _, column := range table.Columns {

		columnName := strings.Title(column.Name)
		if settings.IsOutputFormatCamelCase() {
			columnName = camelCaseString(column.Name)
		}
		if settings.ShouldInitialism() {
			columnName = toInitialisms(columnName)
		}

		// ISSUE-4: if columns are part of multiple constraints
		// then the sql returns multiple rows per column name.
		// Therefore we check if we already added a column with
		// that name to the struct, if so, skip.
		if _, ok := columns[columnName]; ok {
			continue
		}
		columns[columnName] = struct{}{}

		if settings.VVerbose {
			fmt.Printf("\t\t> %v\r\n", column.Name)
		}

		columnType, col := mapDbColumnTypeToGoType(settings, db, column)

		// save that we saw types of columns at least once
		if !columnInfo.isTemporal {
			columnInfo.isTemporal = col.isTemporal
		}
		if !columnInfo.isNullableTemporal {
			columnInfo.isNullableTemporal = col.isNullableTemporal
		}
		if !columnInfo.isNullablePrimitive {
			columnInfo.isNullablePrimitive = col.isNullablePrimitive
		}

		structFields.WriteString(columnName)
		structFields.WriteString(" ")
		structFields.WriteString(columnType)
		structFields.WriteString(" ")
		structFields.WriteString(taggers.GenerateTag(db, column))
		structFields.WriteString("\n")
	}

	if settings.IsMastermindStructableRecorder {
		structFields.WriteString("\t\nstructable.Recorder\n")
	}

	var fileContent strings.Builder

	// write header infos
	fileContent.WriteString("package ")
	fileContent.WriteString(settings.PackageName)
	fileContent.WriteString("\n\n")

	// write imports
	generateImports(&fileContent, settings, db, columnInfo)

	tableName := strings.Title(settings.Prefix + table.Name + settings.Suffix)
	if settings.IsOutputFormatCamelCase() {
		tableName = camelCaseString(tableName)
	}

	// write struct with fields
	fileContent.WriteString("type ")
	fileContent.WriteString(tableName)
	fileContent.WriteString(" struct {\n")
	fileContent.WriteString(structFields.String())
	fileContent.WriteString("}")

	return tableName, fileContent.String()
}

func generateImports(content *strings.Builder, settings *settings.Settings, db database.Database, columnInfo columnInfo) {

	if !columnInfo.hasTrue() && !settings.IsMastermindStructableRecorder {
		return
	}

	content.WriteString("import (\n")

	if columnInfo.isNullablePrimitive && settings.IsNullTypeSQL() {
		content.WriteString("\t\"database/sql\"\n")
	}

	if columnInfo.isTemporal {
		content.WriteString("\t\"time\"\n")
	}

	if columnInfo.isNullableTemporal && settings.IsNullTypeSQL() {
		content.WriteString("\t\n")
		content.WriteString(db.GetDriverImportLibrary())
		content.WriteString("\n")
	}

	if settings.IsMastermindStructableRecorder {
		content.WriteString("\t\n\"github.com/Masterminds/structable\"\n")
	}

	content.WriteString(")\n\n")
}

func mapDbColumnTypeToGoType(s *settings.Settings, db database.Database, column database.Column) (goType string, columnInfo columnInfo) {
	if db.IsString(column) || db.IsText(column) {
		goType = "string"
		if db.IsNullable(column) {
			goType = getNullType(s, "*string", "sql.NullString")
			columnInfo.isNullable = true
		}
	} else if db.IsInteger(column) {
		goType = "int"
		if db.IsNullable(column) {
			goType = getNullType(s, "*int", "sql.NullInt64")
			columnInfo.isNullable = true
		}
	} else if db.IsFloat(column) {
		goType = "float64"
		if db.IsNullable(column) {
			goType = getNullType(s, "*float64", "sql.NullFloat64")
			columnInfo.isNullable = true
		}
	} else if db.IsTemporal(column) {
		if !db.IsNullable(column) {
			goType = "time.Time"
			columnInfo.isTemporal = true
		} else {
			goType = getNullType(s, "*time.Time", db.GetTemporalDriverDataType())
			columnInfo.isTemporal = s.Null == settings.NullTypeNative
			columnInfo.isNullableTemporal = true
			columnInfo.isNullable = true
		}
	} else {
		// TODO handle special data types
		switch column.DataType {
		case "boolean":
			goType = "bool"
			if db.IsNullable(column) {
				goType = getNullType(s, "*bool", "sql.NullBool")
				columnInfo.isNullable = true
			}
		default:
			goType = getNullType(s, "*string", "sql.NullString")
		}
	}

	columnInfo.isNullablePrimitive = columnInfo.isNullable && !db.IsTemporal(column)

	return goType, columnInfo
}

func getNullType(settings *settings.Settings, primitive string, sql string) string {
	if settings.IsNullTypeSQL() {
		return sql
	}
	return primitive
}

func camelCaseString(s string) string {
	if s == "" {
		return s
	}

	splitted := strings.Split(s, "_")

	if len(splitted) == 1 {
		return strings.Title(s)
	}

	var cc string
	for _, part := range splitted {
		cc += strings.Title(strings.ToLower(part))
	}
	return cc
}

func toInitialisms(s string) string {
	for _, substr := range initialisms {
		idx := indexCaseInsensitive(s, substr)
		if idx == -1 {
			continue
		}
		toReplace := s[idx : idx+len(substr)]
		s = strings.ReplaceAll(s, toReplace, substr)
	}
	return s
}

func indexCaseInsensitive(s, substr string) int {
	s, substr = strings.ToLower(s), strings.ToLower(substr)
	return strings.Index(s, substr)
}


1		package cli
2
3		import (
4		"fmt"
5		"strings"
6
7		"github.com/fraenky8/tables-to-go/pkg/database"
8		"github.com/fraenky8/tables-to-go/pkg/output"
9		"github.com/fraenky8/tables-to-go/pkg/settings"
10		"github.com/fraenky8/tables-to-go/pkg/tagger"
11		)
12
13		var (
14		taggers tagger.Tagger
15
16		// some strings for idiomatic go in column names
17		// see https://github.com/golang/go/wiki/CodeReviewComments#initialisms
18		initialisms = []string{"ID", "JSON", "XML", "HTTP", "URL"}
19		)
20
21		// Run runs the transformations by creating the concrete Database by the provided settings
22		func Run(settings *settings.Settings, db database.Database, out output.Writer) (err error) {
23
24	1	taggers = tagger.NewTaggers(settings)
25
26	1	fmt.Printf("running for %q...\r\n", settings.DbType)
27
28	1	tables, err := db.GetTables()
29	1	if err != nil {
30		return fmt.Errorf("could not get tables: %v", err)
31		}
32
33	1	if settings.Verbose {
34		fmt.Printf("> number of tables: %v\r\n", len(tables))
35		}
36
37	1	if err = db.PrepareGetColumnsOfTableStmt(); err != nil {
38		return fmt.Errorf("could not prepare the get-column-statement: %v", err)
39		}
40
41	1	for _, table := range tables {
42
43	1	if settings.Verbose {
44		fmt.Printf("> processing table %q\r\n", table.Name)
45		}
46
47	1	if err = db.GetColumnsOfTable(table); err != nil {
48		if !settings.Force {
49		return fmt.Errorf("could not get columns of table %q: %v", table.Name, err)
50		}
51		fmt.Printf("could not get columns of table %q: %v\n", table.Name, err)
52		continue
53		}
54
55	1	if settings.Verbose {
56		fmt.Printf("\t> number of columns: %v\r\n", len(table.Columns))
57		}
58
59	1	tableName, content := createTableStructString(settings, db, table)
60
61	1	err = out.Write(tableName, content)
62	1	if err != nil {
63		if !settings.Force {
64		return fmt.Errorf("could not write struct for table %q: %v", table.Name, err)
65		}
66		fmt.Printf("could not write struct for table %q: %v\n", table.Name, err)
67		}
68		}
69
70	1	fmt.Println("done!")
71
72	1	return nil
73		}
74
75		type columnInfo struct {
76		isNullable bool
77		isTemporal bool
78		isNullablePrimitive bool
79		isNullableTemporal bool
80		}
81
82		func (c columnInfo) hasTrue() bool {
83	1	return c.isNullable \|\| c.isTemporal \|\| c.isNullableTemporal \|\| c.isNullablePrimitive
84		}
85
86		func createTableStructString(settings settings.Settings, db database.Database, table database.Table) (string, string) {
87
88	1	var structFields strings.Builder
89
90	1	columnInfo := columnInfo{}
91	1	columns := map[string]struct{}{}
92
93	1	for _, column := range table.Columns {
94
95	1	columnName := strings.Title(column.Name)
96	1	if settings.IsOutputFormatCamelCase() {
97	1	columnName = camelCaseString(column.Name)
98		}
99	1	if settings.ShouldInitialism() {
100	1	columnName = toInitialisms(columnName)
101		}
102
103		// ISSUE-4: if columns are part of multiple constraints
104		// then the sql returns multiple rows per column name.
105		// Therefore we check if we already added a column with
106		// that name to the struct, if so, skip.
107	1	if _, ok := columns[columnName]; ok {
108		continue
109		}
110	1	columns[columnName] = struct{}{}
111
112	1	if settings.VVerbose {
113		fmt.Printf("\t\t> %v\r\n", column.Name)
114		}
115
116	1	columnType, col := mapDbColumnTypeToGoType(settings, db, column)
117
118		// save that we saw types of columns at least once
119	1	if !columnInfo.isTemporal {
120	1	columnInfo.isTemporal = col.isTemporal
121		}
122	1	if !columnInfo.isNullableTemporal {
123	1	columnInfo.isNullableTemporal = col.isNullableTemporal
124		}
125	1	if !columnInfo.isNullablePrimitive {
126	1	columnInfo.isNullablePrimitive = col.isNullablePrimitive
127		}
128
129	1	structFields.WriteString(columnName)
130	1	structFields.WriteString(" ")
131	1	structFields.WriteString(columnType)
132	1	structFields.WriteString(" ")
133	1	structFields.WriteString(taggers.GenerateTag(db, column))
134	1	structFields.WriteString("\n")
135		}
136
137	1	if settings.IsMastermindStructableRecorder {
138		structFields.WriteString("\t\nstructable.Recorder\n")
139		}
140
141	1	var fileContent strings.Builder
142
143		// write header infos
144	1	fileContent.WriteString("package ")
145	1	fileContent.WriteString(settings.PackageName)
146	1	fileContent.WriteString("\n\n")
147
148		// write imports
149	1	generateImports(&fileContent, settings, db, columnInfo)
150
151	1	tableName := strings.Title(settings.Prefix + table.Name + settings.Suffix)
152	1	if settings.IsOutputFormatCamelCase() {
153	1	tableName = camelCaseString(tableName)
154		}
155
156		// write struct with fields
157	1	fileContent.WriteString("type ")
158	1	fileContent.WriteString(tableName)
159	1	fileContent.WriteString(" struct {\n")
160	1	fileContent.WriteString(structFields.String())
161	1	fileContent.WriteString("}")
162
163	1	return tableName, fileContent.String()
164		}
165
166		func generateImports(content strings.Builder, settings settings.Settings, db database.Database, columnInfo columnInfo) {
167
168	1	if !columnInfo.hasTrue() && !settings.IsMastermindStructableRecorder {
169	1	return
170		}
171
172	1	content.WriteString("import (\n")
173
174	1	if columnInfo.isNullablePrimitive && settings.IsNullTypeSQL() {
175	1	content.WriteString("\t\"database/sql\"\n")
176		}
177
178	1	if columnInfo.isTemporal {
179	1	content.WriteString("\t\"time\"\n")
180		}
181
182	1	if columnInfo.isNullableTemporal && settings.IsNullTypeSQL() {
183	1	content.WriteString("\t\n")
184	1	content.WriteString(db.GetDriverImportLibrary())
185	1	content.WriteString("\n")
186		}
187
188	1	if settings.IsMastermindStructableRecorder {
189		content.WriteString("\t\n\"github.com/Masterminds/structable\"\n")
190		}
191
192	1	content.WriteString(")\n\n")
193		}
194
195		func mapDbColumnTypeToGoType(s *settings.Settings, db database.Database, column database.Column) (goType string, columnInfo columnInfo) {
196	1	if db.IsString(column) \|\| db.IsText(column) {
197	1	goType = "string"
198	1	if db.IsNullable(column) {
199	1	goType = getNullType(s, "*string", "sql.NullString")
200	1	columnInfo.isNullable = true
201		}
202	1	} else if db.IsInteger(column) {
203	1	goType = "int"
204	1	if db.IsNullable(column) {
205	1	goType = getNullType(s, "*int", "sql.NullInt64")
206	1	columnInfo.isNullable = true
207		}
208	1	} else if db.IsFloat(column) {
209	1	goType = "float64"
210	1	if db.IsNullable(column) {
211	1	goType = getNullType(s, "*float64", "sql.NullFloat64")
212	1	columnInfo.isNullable = true
213		}
214	1	} else if db.IsTemporal(column) {
215	1	if !db.IsNullable(column) {
216	1	goType = "time.Time"
217	1	columnInfo.isTemporal = true
218		} else {
219	1	goType = getNullType(s, "*time.Time", db.GetTemporalDriverDataType())
220	1	columnInfo.isTemporal = s.Null == settings.NullTypeNative
221	1	columnInfo.isNullableTemporal = true
222	1	columnInfo.isNullable = true
223		}
224		} else {
225		// TODO handle special data types
226	1	switch column.DataType {
227		case "boolean":
228	1	goType = "bool"
229	1	if db.IsNullable(column) {
230	1	goType = getNullType(s, "*bool", "sql.NullBool")
231	1	columnInfo.isNullable = true
232		}
233		default:
234		goType = getNullType(s, "*string", "sql.NullString")
235		}
236		}
237
238	1	columnInfo.isNullablePrimitive = columnInfo.isNullable && !db.IsTemporal(column)
239
240	1	return goType, columnInfo
241		}
242
243		func getNullType(settings *settings.Settings, primitive string, sql string) string {
244	1	if settings.IsNullTypeSQL() {
245	1	return sql
246		}
247	1	return primitive
248		}
249
250		func camelCaseString(s string) string {
251	1	if s == "" {
252	1	return s
253		}
254
255	1	splitted := strings.Split(s, "_")
256
257	1	if len(splitted) == 1 {
258	1	return strings.Title(s)
259		}
260
261	1	var cc string
262	1	for _, part := range splitted {
263	1	cc += strings.Title(strings.ToLower(part))
264		}
265	1	return cc
266		}
267
268		func toInitialisms(s string) string {
269	1	for _, substr := range initialisms {
270	1	idx := indexCaseInsensitive(s, substr)
271	1	if idx == -1 {
272	1	continue
273		}
274	1	toReplace := s[idx : idx+len(substr)]
275	1	s = strings.ReplaceAll(s, toReplace, substr)
276		}
277	1	return s
278		}
279
280		func indexCaseInsensitive(s, substr string) int {
281	1	s, substr = strings.ToLower(s), strings.ToLower(substr)
282	1	return strings.Index(s, substr)
283		}
284

fraenky8 / tables-to-go

Pull Request — master (#20)

cli.indexCaseInsensitive A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like