cmd.scanHandler - Code Metrics - Inspection of "Refactor cmd handlers" - vvval/go-metadata-scanner - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 6a9844...07bc4c )

by Valentin

created 2018-10-16 06:56 UTC

cmd.scanHandler F

↳ Parent: cmd/scan.go

Complexity

Conditions

Size

Total Lines	65
Code Lines	43

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	14
eloc	43
nop	4
dl	0
loc	65
rs	3.6
c	0
b	0
f	0

How to fix Long Method Complexity

package cmd

import (
	"fmt"
	"github.com/spf13/cobra"
	"github.com/vvval/go-metadata-scanner/cmd/scancmd"
	"github.com/vvval/go-metadata-scanner/cmd/scancmd/writers"
	"github.com/vvval/go-metadata-scanner/config"
	"github.com/vvval/go-metadata-scanner/etool"
	"github.com/vvval/go-metadata-scanner/util"
	"github.com/vvval/go-metadata-scanner/util/log"
	"github.com/vvval/go-metadata-scanner/util/rand"
	"github.com/vvval/go-metadata-scanner/util/scan"
	"github.com/vvval/go-metadata-scanner/vars"
	"os"
	"path/filepath"
	"sync"
)

var (
	scanFlags    scancmd.Flags
	PoolSize     = 10
	MinChunkSize = 5
)

func init() {
	// cmd represents the scan command
	var cmd = &cobra.Command{
		Use:   "scan",
		Short: "Scan folder and write metadata into the output file.",
		Long: `Scan folder and write metadata into the output file.
By default output file is a "csv" file.`,
		Run: func(cmd *cobra.Command, args []string) {
			err := scanHandler(scanFlags, config.App, PoolSize, MinChunkSize)
			if err != nil {
				log.Failure("Output writer", err.Error())
				os.Exit(1)
			}
		},
	}

	rootCmd.AddCommand(cmd)
	scanFlags.Fill(cmd)
}

func scanHandler(flags scancmd.Flags, appConfig config.AppConfig, initialPoolSize, minChunkSize int) error {
	if flags.Verbosity() {
		log.Visibility.Debug = true
		log.Visibility.Log = true
		log.Visibility.Command = true
	}

	log.Log("Scanning...", fmt.Sprintf("Directory is \"%s\"", util.Abs(flags.Directory())))

	var files = scan.MustDir(flags.Directory(), appConfig.Extensions())
	poolSize, chunkSize := util.AdjustSizes(len(files), initialPoolSize, minChunkSize)

	var chunks = make(chan vars.Chunk)
	var scannedFiles = make(chan vars.File)
	var wg sync.WaitGroup
	scancmd.CreatePool(
		&wg,
		poolSize,
		chunks,
		func(files vars.Chunk) ([]byte, error) {
			return etool.Read(files, appConfig.Fields())
		},
		func(data []byte) {
			for _, parsed := range etool.Parse(data) {
				scannedFiles <- parsed
			}
		},
	)

	for _, chunk := range files.Split(chunkSize) {
		wg.Add(1)
		chunks <- chunk
	}

	go func() {
		wg.Wait()
		close(chunks)
		close(scannedFiles)
	}()

	outputFilename := randomizeOutputFilename(flags.Filename())

	headers := packHeaders(appConfig.Fields())
	wr, err := writers.Get(flags.Format())
	if err != nil {
		return err
	}

	err = wr.Open(outputFilename, headers)
	if err != nil {
		return err
	}
	defer wr.Close()

	for file := range scannedFiles {
		file.WithRelPath(flags.Directory())
		err := wr.Write(&file)
		if err != nil {
			log.Failure("CSV write", fmt.Sprintf("failed writing data for \"%s\" file", file.RelPath()))
		}
	}

	log.Done("Scanning completed", fmt.Sprintf("Output file is \"%s\" file", outputFilename))

	return nil
}

func randomizeOutputFilename(path string) string {
	ext := filepath.Ext(path)
	dir := filepath.Dir(path)
	base := filepath.Base(path)
	hash := rand.Strings(10)

	return filepath.Join(dir, base[0:len(base)-len(ext)]+"-"+hash+ext)
}

func packHeaders(fields []string) []string {
	headers := []string{"Filename"}

	for _, field := range fields {
		headers = append(headers, field)
	}

	return headers
}


1			package cmd
2
3			import (
4			"fmt"
5			"github.com/spf13/cobra"
6			"github.com/vvval/go-metadata-scanner/cmd/scancmd"
7			"github.com/vvval/go-metadata-scanner/cmd/scancmd/writers"
8			"github.com/vvval/go-metadata-scanner/config"
9			"github.com/vvval/go-metadata-scanner/etool"
10			"github.com/vvval/go-metadata-scanner/util"
11			"github.com/vvval/go-metadata-scanner/util/log"
12			"github.com/vvval/go-metadata-scanner/util/rand"
13			"github.com/vvval/go-metadata-scanner/util/scan"
14			"github.com/vvval/go-metadata-scanner/vars"
15			"os"
16			"path/filepath"
17			"sync"
18			)
19
20			var (
21			scanFlags scancmd.Flags
22			PoolSize = 10
23			MinChunkSize = 5
24			)
25
26			func init() {
27			// cmd represents the scan command
28			var cmd = &cobra.Command{
29			Use: "scan",
30			Short: "Scan folder and write metadata into the output file.",
31			Long: `Scan folder and write metadata into the output file.
32			By default output file is a "csv" file.`,
33			Run: func(cmd *cobra.Command, args []string) {
34			err := scanHandler(scanFlags, config.App, PoolSize, MinChunkSize)
35			if err != nil {
36			log.Failure("Output writer", err.Error())
37			os.Exit(1)
38			}
39			},
40			}
41
42			rootCmd.AddCommand(cmd)
43			scanFlags.Fill(cmd)
44			}
45
46			func scanHandler(flags scancmd.Flags, appConfig config.AppConfig, initialPoolSize, minChunkSize int) error {
47			if flags.Verbosity() {
48			log.Visibility.Debug = true
49			log.Visibility.Log = true
50			log.Visibility.Command = true
51			}
52
53			log.Log("Scanning...", fmt.Sprintf("Directory is \"%s\"", util.Abs(flags.Directory())))
54
55			var files = scan.MustDir(flags.Directory(), appConfig.Extensions())
56			poolSize, chunkSize := util.AdjustSizes(len(files), initialPoolSize, minChunkSize)
57
58			var chunks = make(chan vars.Chunk)
59			var scannedFiles = make(chan vars.File)
60			var wg sync.WaitGroup
61			scancmd.CreatePool(
62			&wg,
63			poolSize,
64			chunks,
65			func(files vars.Chunk) ([]byte, error) {
66			return etool.Read(files, appConfig.Fields())
67			},
68			func(data []byte) {
69			for _, parsed := range etool.Parse(data) {
70			scannedFiles <- parsed
71			}
72			},
73			)
74
75			for _, chunk := range files.Split(chunkSize) {
76			wg.Add(1)
77			chunks <- chunk
78			}
79
80			go func() {
81			wg.Wait()
82			close(chunks)
83			close(scannedFiles)
84			}()
85
86			outputFilename := randomizeOutputFilename(flags.Filename())
87
88			headers := packHeaders(appConfig.Fields())
89			wr, err := writers.Get(flags.Format())
90			if err != nil {
91			return err
92			}
93
94			err = wr.Open(outputFilename, headers)
95			if err != nil {
96			return err
97			}
98			defer wr.Close()
99
100			for file := range scannedFiles {
101			file.WithRelPath(flags.Directory())
102			err := wr.Write(&file)
103			if err != nil {
104			log.Failure("CSV write", fmt.Sprintf("failed writing data for \"%s\" file", file.RelPath()))
105			}
106			}
107
108			log.Done("Scanning completed", fmt.Sprintf("Output file is \"%s\" file", outputFilename))
109
110			return nil
111			}
112
113			func randomizeOutputFilename(path string) string {
114			ext := filepath.Ext(path)
115			dir := filepath.Dir(path)
116			base := filepath.Base(path)
117			hash := rand.Strings(10)
118
119			return filepath.Join(dir, base[0:len(base)-len(ext)]+"-"+hash+ext)
120			}
121
122			func packHeaders(fields []string) []string {
123			headers := []string{"Filename"}
124
125			for _, field := range fields {
126			headers = append(headers, field)
127			}
128
129			return headers
130			}
131

vvval / go-metadata-scanner

Push — master ( 6a9844...07bc4c )

cmd.scanHandler F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like