settings.*OutputFormat.Set - Code Metrics - Inspection of "Add new option for out file name casing" - fraenky8/tables-to-go - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#30)

unknown

created 2020-06-07 06:04 UTC

settings.*OutputFormat.Set A

↳ Parent: pkg/settings/settings.go

Complexity

Conditions

Size

Total Lines	9
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	3

Importance

Changes

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

package settings

import (
	"fmt"
	"os"
	"path/filepath"
)

// These database types are supported.
const (
	DbTypePostgresql DbType = "pg"
	DbTypeMySQL      DbType = "mysql"
	DbTypeSQLite     DbType = "sqlite3"
)

// DbType represents a type of a database.
type DbType string

// Set sets the datatype for the custom type for the flag package.
func (db *DbType) Set(s string) error {
	*db = DbType(s)
	if *db == "" {
		*db = DbTypePostgresql
	}
	if !SupportedDbTypes[*db] {
		return fmt.Errorf("type of database %q not supported! supported: %v", *db, SprintfSupportedDbTypes())
	}
	return nil
}

// String is the implementation of the Stringer interface needed for flag.Value interface.
func (db DbType) String() string {
	return string(db)
}

// These null types are supported. The types native and primitive map to the same
// underlying builtin golang type.
const (
	NullTypeSQL       NullType = "sql"
	NullTypeNative    NullType = "native"
	NullTypePrimitive NullType = "primitive"
)

// NullType represents a null type.
type NullType string

// Set sets the datatype for the custom type for the flag package.
func (t *NullType) Set(s string) error {
	*t = NullType(s)
	if *t == "" {
		*t = NullTypeSQL
	}
	if !supportedNullTypes[*t] {
		return fmt.Errorf("null type %q not supported! supported: %v", *t, SprintfSupportedNullTypes())
	}
	return nil
}

// String is the implementation of the Stringer interface needed for flag.Value interface.
func (t NullType) String() string {
	return string(t)
}

// These are the output format command line parameter.
const (
	OutputFormatCamelCase OutputFormat = "c"
	OutputFormatOriginal  OutputFormat = "o"
)

// OutputFormat represents a output format option.
type OutputFormat string

// Set sets the datatype for the custom type for the flag package.
func (of *OutputFormat) Set(s string) error {
	*of = OutputFormat(s)
	if *of == "" {
		*of = OutputFormatCamelCase
	}
	if !supportedOutputFormats[*of] {
		return fmt.Errorf("output format %q not supported", *of)
	}
	return nil
}

// String is the implementation of the Stringer interface needed for flag.Value interface.
func (of OutputFormat) String() string {
	return string(of)
}

// These are the filename format command line parameter.
const (
	FileNameFormatCamelCase FileNameFormat = "c"
	FileNameFormatSnakeCase FileNameFormat = "s"
)

// FileNameFormat represents a output filename format
type FileNameFormat string

func (of *FileNameFormat) Set(s string) error {
	*of = FileNameFormat(s)
	if *of == "" {
		*of = FileNameFormatCamelCase
	}
	if !supportedFileNameFormats[*of] {
		return fmt.Errorf("filename format %q not supported", *of)
	}
	return nil
}

func (of FileNameFormat) String() string {
	return string(of)
}

var (
	// SupportedDbTypes represents the supported databases
	SupportedDbTypes = map[DbType]bool{
		DbTypePostgresql: true,
		DbTypeMySQL:      true,
		DbTypeSQLite:     true,
	}

	// supportedOutputFormats represents the supported output formats
	supportedOutputFormats = map[OutputFormat]bool{
		OutputFormatCamelCase: true,
		OutputFormatOriginal:  true,
	}

	// dbDefaultPorts maps the database type to the default ports
	dbDefaultPorts = map[DbType]string{
		DbTypePostgresql: "5432",
		DbTypeMySQL:      "3306",
		DbTypeSQLite:     "",
	}

	// supportedNullTypes represents the supported types of NULL types
	supportedNullTypes = map[NullType]bool{
		NullTypeSQL:       true,
		NullTypeNative:    true,
		NullTypePrimitive: true,
	}

	supportedFileNameFormats = map[FileNameFormat]bool{
		FileNameFormatCamelCase: true,
		FileNameFormatSnakeCase: true,
	}
)

// Settings stores the supported settings / command line arguments
type Settings struct {
	Verbose  bool
	VVerbose bool
	Force    bool // continue through errors

	DbType DbType

	User   string
	Pswd   string
	DbName string
	Schema string
	Host   string
	Port   string

	OutputFilePath string
	OutputFormat   OutputFormat

	FileNameFormat FileNameFormat
	PackageName    string
	Prefix         string
	Suffix         string
	Null           NullType

	NoInitialism bool

	TagsNoDb bool

	TagsMastermindStructable       bool
	TagsMastermindStructableOnly   bool
	IsMastermindStructableRecorder bool

	// TODO not implemented yet
	TagsGorm bool
}

// New constructs settings with default values
func New() *Settings {

	dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
	if err != nil {
		dir = "."
	}

	return &Settings{
		Verbose:  false,
		VVerbose: false,
		Force:    false,

		DbType:         DbTypePostgresql,
		User:           "",
		Pswd:           "",
		DbName:         "postgres",
		Schema:         "public",
		Host:           "127.0.0.1",
		Port:           "", // left blank -> is automatically determined if not set
		OutputFilePath: dir,
		OutputFormat:   OutputFormatCamelCase,
		FileNameFormat: FileNameFormatCamelCase,
		PackageName:    "dto",
		Prefix:         "",
		Suffix:         "",
		Null:           NullTypeSQL,

		NoInitialism: false,

		TagsNoDb: false,

		TagsMastermindStructable:       false,
		TagsMastermindStructableOnly:   false,
		IsMastermindStructableRecorder: false,

		TagsGorm: false,
	}
}

// Verify verifies the settings and checks the given output paths
func (settings *Settings) Verify() (err error) {

	if err = settings.verifyOutputPath(); err != nil {
		return err
	}

	if settings.OutputFilePath, err = settings.prepareOutputPath(); err != nil {
		return err
	}

	if settings.Port == "" {
		settings.Port = dbDefaultPorts[settings.DbType]
	}

	if settings.PackageName == "" {
		return fmt.Errorf("name of package can not be empty")
	}

	if settings.VVerbose {
		settings.Verbose = true
	}

	return err
}

func (settings *Settings) verifyOutputPath() (err error) {

	info, err := os.Stat(settings.OutputFilePath)

	if os.IsNotExist(err) {
		return fmt.Errorf("output file path %q does not exists", settings.OutputFilePath)
	}

	if !info.Mode().IsDir() {
		return fmt.Errorf("output file path %q is not a directory", settings.OutputFilePath)
	}

	return err
}

func (settings *Settings) prepareOutputPath() (outputFilePath string, err error) {
	outputFilePath, err = filepath.Abs(settings.OutputFilePath)
	outputFilePath += string(filepath.Separator)
	return outputFilePath, err
}

// SprintfSupportedDbTypes returns a slice of strings as names of the supported database types
func SprintfSupportedDbTypes() string {
	names := make([]string, 0, len(SupportedDbTypes))
	for name := range SupportedDbTypes {
		names = append(names, string(name))
	}
	return fmt.Sprintf("%v", names)
}

// SprintfSupportedNullTypes returns a slice of strings as names of the supported null types
func SprintfSupportedNullTypes() string {
	names := make([]string, 0, len(supportedNullTypes))
	for name := range supportedNullTypes {
		names = append(names, string(name))
	}
	return fmt.Sprintf("%v", names)
}

// IsNullTypeSQL returns true if the type given by the command line args is of null type SQL
func (settings *Settings) IsNullTypeSQL() bool {
	return settings.Null == NullTypeSQL
}

// ShouldInitialism returns wheather or not if column names should be converted
// to initialisms.
func (settings *Settings) ShouldInitialism() bool {
	return !settings.NoInitialism
}

// IsOutputFormatCamelCase returns if the type given by command line args is of camel-case format.
func (settings *Settings) IsOutputFormatCamelCase() bool {
	return settings.OutputFormat == OutputFormatCamelCase
}

// IsFileNameFormatSnakeCase returns if the type given by the command line args is snake-case format
func (settings *Settings) IsFileNameFormatSnakeCase() bool {
	return settings.FileNameFormat == FileNameFormatSnakeCase
}


1		package settings
2
3		import (
4		"fmt"
5		"os"
6		"path/filepath"
7		)
8
9		// These database types are supported.
10		const (
11		DbTypePostgresql DbType = "pg"
12		DbTypeMySQL DbType = "mysql"
13		DbTypeSQLite DbType = "sqlite3"
14		)
15
16		// DbType represents a type of a database.
17		type DbType string
18
19		// Set sets the datatype for the custom type for the flag package.
20		func (db *DbType) Set(s string) error {
21	1	*db = DbType(s)
22	1	if *db == "" {
23	1	*db = DbTypePostgresql
24		}
25	1	if !SupportedDbTypes[*db] {
26	1	return fmt.Errorf("type of database %q not supported! supported: %v", *db, SprintfSupportedDbTypes())
27		}
28	1	return nil
29		}
30
31		// String is the implementation of the Stringer interface needed for flag.Value interface.
32		func (db DbType) String() string {
33	1	return string(db)
34		}
35
36		// These null types are supported. The types native and primitive map to the same
37		// underlying builtin golang type.
38		const (
39		NullTypeSQL NullType = "sql"
40		NullTypeNative NullType = "native"
41		NullTypePrimitive NullType = "primitive"
42		)
43
44		// NullType represents a null type.
45		type NullType string
46
47		// Set sets the datatype for the custom type for the flag package.
48		func (t *NullType) Set(s string) error {
49	1	*t = NullType(s)
50	1	if *t == "" {
51	1	*t = NullTypeSQL
52		}
53	1	if !supportedNullTypes[*t] {
54	1	return fmt.Errorf("null type %q not supported! supported: %v", *t, SprintfSupportedNullTypes())
55		}
56	1	return nil
57		}
58
59		// String is the implementation of the Stringer interface needed for flag.Value interface.
60		func (t NullType) String() string {
61	1	return string(t)
62		}
63
64		// These are the output format command line parameter.
65		const (
66		OutputFormatCamelCase OutputFormat = "c"
67		OutputFormatOriginal OutputFormat = "o"
68		)
69
70		// OutputFormat represents a output format option.
71		type OutputFormat string
72
73		// Set sets the datatype for the custom type for the flag package.
74		func (of *OutputFormat) Set(s string) error {
75	1	*of = OutputFormat(s)
76	1	if *of == "" {
77	1	*of = OutputFormatCamelCase
78		}
79	1	if !supportedOutputFormats[*of] {
80	1	return fmt.Errorf("output format %q not supported", *of)
81		}
82	1	return nil
83		}
84
85		// String is the implementation of the Stringer interface needed for flag.Value interface.
86		func (of OutputFormat) String() string {
87	1	return string(of)
88		}
89
90		// These are the filename format command line parameter.
91		const (
92		FileNameFormatCamelCase FileNameFormat = "c"
93		FileNameFormatSnakeCase FileNameFormat = "s"
94		)
95
96		// FileNameFormat represents a output filename format
97		type FileNameFormat string
98
99		func (of *FileNameFormat) Set(s string) error {
100		*of = FileNameFormat(s)
101		if *of == "" {
102		*of = FileNameFormatCamelCase
103		}
104		if !supportedFileNameFormats[*of] {
105		return fmt.Errorf("filename format %q not supported", *of)
106		}
107		return nil
108		}
109
110		func (of FileNameFormat) String() string {
111		return string(of)
112		}
113
114		var (
115		// SupportedDbTypes represents the supported databases
116		SupportedDbTypes = map[DbType]bool{
117		DbTypePostgresql: true,
118		DbTypeMySQL: true,
119		DbTypeSQLite: true,
120		}
121
122		// supportedOutputFormats represents the supported output formats
123		supportedOutputFormats = map[OutputFormat]bool{
124		OutputFormatCamelCase: true,
125		OutputFormatOriginal: true,
126		}
127
128		// dbDefaultPorts maps the database type to the default ports
129		dbDefaultPorts = map[DbType]string{
130		DbTypePostgresql: "5432",
131		DbTypeMySQL: "3306",
132		DbTypeSQLite: "",
133		}
134
135		// supportedNullTypes represents the supported types of NULL types
136		supportedNullTypes = map[NullType]bool{
137		NullTypeSQL: true,
138		NullTypeNative: true,
139		NullTypePrimitive: true,
140		}
141
142		supportedFileNameFormats = map[FileNameFormat]bool{
143		FileNameFormatCamelCase: true,
144		FileNameFormatSnakeCase: true,
145		}
146		)
147
148		// Settings stores the supported settings / command line arguments
149		type Settings struct {
150		Verbose bool
151		VVerbose bool
152		Force bool // continue through errors
153
154		DbType DbType
155
156		User string
157	1	Pswd string
158	1	DbName string
159		Schema string
160		Host string
161		Port string
162	1
163		OutputFilePath string
164		OutputFormat OutputFormat
165
166		FileNameFormat FileNameFormat
167		PackageName string
168		Prefix string
169		Suffix string
170		Null NullType
171
172		NoInitialism bool
173
174		TagsNoDb bool
175
176		TagsMastermindStructable bool
177		TagsMastermindStructableOnly bool
178		IsMastermindStructableRecorder bool
179
180		// TODO not implemented yet
181		TagsGorm bool
182		}
183
184		// New constructs settings with default values
185		func New() *Settings {
186
187		dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
188		if err != nil {
189		dir = "."
190		}
191
192		return &Settings{
193		Verbose: false,
194		VVerbose: false,
195		Force: false,
196	1
197	1	DbType: DbTypePostgresql,
198		User: "",
199		Pswd: "",
200	1	DbName: "postgres",
201		Schema: "public",
202		Host: "127.0.0.1",
203		Port: "", // left blank -> is automatically determined if not set
204	1	OutputFilePath: dir,
205	1	OutputFormat: OutputFormatCamelCase,
206		FileNameFormat: FileNameFormatCamelCase,
207		PackageName: "dto",
208	1	Prefix: "",
209	1	Suffix: "",
210		Null: NullTypeSQL,
211
212	1	NoInitialism: false,
213	1
214		TagsNoDb: false,
215
216	1	TagsMastermindStructable: false,
217		TagsMastermindStructableOnly: false,
218		IsMastermindStructableRecorder: false,
219
220		TagsGorm: false,
221	1	}
222		}
223	1
224	1	// Verify verifies the settings and checks the given output paths
225		func (settings *Settings) Verify() (err error) {
226
227	1	if err = settings.verifyOutputPath(); err != nil {
228	1	return err
229		}
230
231	1	if settings.OutputFilePath, err = settings.prepareOutputPath(); err != nil {
232		return err
233		}
234
235	1	if settings.Port == "" {
236	1	settings.Port = dbDefaultPorts[settings.DbType]
237	1	}
238
239		if settings.PackageName == "" {
240		return fmt.Errorf("name of package can not be empty")
241		}
242	1
243	1	if settings.VVerbose {
244	1	settings.Verbose = true
245		}
246	1
247		return err
248		}
249
250		func (settings *Settings) verifyOutputPath() (err error) {
251	1
252	1	info, err := os.Stat(settings.OutputFilePath)
253	1
254		if os.IsNotExist(err) {
255	1	return fmt.Errorf("output file path %q does not exists", settings.OutputFilePath)
256		}
257
258		if !info.Mode().IsDir() {
259		return fmt.Errorf("output file path %q is not a directory", settings.OutputFilePath)
260	1	}
261
262		return err
263		}
264
265		func (settings *Settings) prepareOutputPath() (outputFilePath string, err error) {
266	1	outputFilePath, err = filepath.Abs(settings.OutputFilePath)
267		outputFilePath += string(filepath.Separator)
268		return outputFilePath, err
269		}
270
271	1	// SprintfSupportedDbTypes returns a slice of strings as names of the supported database types
272		func SprintfSupportedDbTypes() string {
273		names := make([]string, 0, len(SupportedDbTypes))
274		for name := range SupportedDbTypes {
275		names = append(names, string(name))
276		}
277		return fmt.Sprintf("%v", names)
278		}
279
280		// SprintfSupportedNullTypes returns a slice of strings as names of the supported null types
281		func SprintfSupportedNullTypes() string {
282		names := make([]string, 0, len(supportedNullTypes))
283		for name := range supportedNullTypes {
284		names = append(names, string(name))
285		}
286		return fmt.Sprintf("%v", names)
287		}
288
289		// IsNullTypeSQL returns true if the type given by the command line args is of null type SQL
290		func (settings *Settings) IsNullTypeSQL() bool {
291		return settings.Null == NullTypeSQL
292		}
293
294		// ShouldInitialism returns wheather or not if column names should be converted
295		// to initialisms.
296		func (settings *Settings) ShouldInitialism() bool {
297		return !settings.NoInitialism
298		}
299
300		// IsOutputFormatCamelCase returns if the type given by command line args is of camel-case format.
301		func (settings *Settings) IsOutputFormatCamelCase() bool {
302		return settings.OutputFormat == OutputFormatCamelCase
303		}
304
305		// IsFileNameFormatSnakeCase returns if the type given by the command line args is snake-case format
306		func (settings *Settings) IsFileNameFormatSnakeCase() bool {
307		return settings.FileNameFormat == FileNameFormatSnakeCase
308		}
309

fraenky8 / tables-to-go

Pull Request — master (#30)

settings.*OutputFormat.Set A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like