engine

type CodeCount ¶

type CodeCount struct {
	Summary struct {
		LineCount     int `json:"line_count"`
		CommentCount  int `json:"comment_count"`
		FunctionCount int `json:"function_count"`
		FileCount     int `json:"file_count"`
	} `json:"summary"`
	Content struct {
		Pkg               []string `json:"pkg"`
		PkgLineCount      []int    `json:"pkg_line_count"`
		PkgCommentCount   []int    `json:"pkg_comment_count"`
		PkgFunctionCount  []int    `json:"pkg_function_count"`
		File              []string `json:"file"`
		FileLineCount     []int    `json:"file_line_count"`
		FileCommentCount  []int    `json:"file_comment_count"`
		FileFunctionCount []int    `json:"file_function_count"`
	} `json:"content"`
}

CodeCount is a struct that contains Summary and Content. t represents the code statistics of the data, you can understand the project from the perspective of the number of lines.

type CodeOptimization ¶

type CodeOptimization struct {
	Summary struct {
		IssuesNum int    `json:"issue_num"`
		FilesNum  int    `json:"file_num"`
		Quality   string `json:"quality"`
	} `json:"summary"`
	Content struct {
		DeadCode       StyleItem `json:"dead_code"`
		SimpleCode     StyleItem `json:"simple_code"`
		StaticCode     StyleItem `json:"static_code"`
		CopyCode       CopyItem  `json:"copy_code"`
		InterfacerCode StyleItem `json:"interfacer_code"`
	} `json:"content"`
}

CodeTest is a struct that contains Summary and Content. It represents the result data of the project unit test.

type CodeSmell ¶

type CodeSmell struct {
	Summary struct {
		CycloAvg   int `json:"cyclo_avg"`
		CycloHigh  int `json:"cyclo_high"`
		CycloGrave int `json:"cyclo_grave"`
	} `json:"summary"`
	Content struct {
		Percentage map[string]int  `json:"percentage"`
		Pkg        []string        `json:"pkg"`
		Cyclo      []int           `json:"cyclo"`
		List       []CodeSmellItem `json:"list"`
	} `json:"content"`
}

CodeSmell is a struct that contains Summary and Content. It represents the taste of the code data, you can understand the project from the perspective of complexity.

type CodeSmellItem ¶

type CodeSmellItem struct {
	Path  string `json:"path"`
	Cyclo int    `json:"cyclo"`
}

CodeSmellItem is a struct that contains path and cyclo.

type CodeStyle ¶

type CodeStyle struct {
	Summary struct {
		IssuesNum int    `json:"issue_num"`
		FilesNum  int    `json:"file_num"`
		Quality   string `json:"quality"`
	} `json:"summary"`
	Content struct {
		GoFmt     StyleItem `json:"go_fmt"`
		GoVet     StyleItem `json:"go_vet"`
		GoLint    StyleItem `json:"go_lint"`
		MissSpell StyleItem `json:"miss_spell"`
	} `json:"content"`
}

CodeTest is a struct that contains Summary and Content. It represents the result data of the project unit test.

type CodeTest ¶

type CodeTest struct {
	Summary struct {
		CodeCover    float64 `json:"code_cover"`
		PackageCover float64 `json:"pkg_cover"`
		TotalTime    float64 `json:"total_time"`
	} `json:"summary"`
	Content struct {
		Pkg    []string  `json:"pkg"`
		Cover  []float64 `json:"cover"`
		Time   []float64 `json:"time"`
		NoTest []string  `json:"no_test"`
	} `json:"content"`
}

CodeTest is a struct that contains Summary and Content. It represents the result data of the project unit test.

type CopyItem ¶

type CopyItem struct {
	Label  string     `json:"label"`
	Score  int        `json:"score"`
	Detail [][]string `json:"detail"`
	// contains filtered or unexported fields
}

CodeTest is a struct that contains Summary and Content. It represents the result data of the project unit test.

type Copycode ¶

type Copycode struct {
	Files string
	Path  []string
}

Copycode is a struct that contains Files and Path. The type of Path MUST []string that contains more than one file path. The Copycode represents some copyed code information.

type Cyclo ¶

type Cyclo struct {
	Pkg  string
	Size int
	Info []CycloInfo
}

Cyclo is a struct that contains Pkg, Size and Info. The type of Info MUST []CycloInfo that represents detail information of all function.

type CycloInfo ¶

type CycloInfo struct {
	Comp int
	Info string
}

CycloInfo is a struct that contains Comp and Info. The type of Comp MUST int that represents the cyclo of one function.The CycloInfo represents one cyclo function information.

type Cycloi ¶

type Cycloi struct {
	Average string
	Result  []string
}

Cycloi is a struct that contains Average and Result. The Average is one package's cyclo coverage. And Result is the detail cyclo of the package's all function.

type Deadcode ¶

type Deadcode struct {
	Path string
	Info string
}

Deadcode is a struct that contains Path and Info. The type of Path and Info MUST string. The Deadcode represents one dead code.

type Depth ¶

type Depth struct {
	Pkg  string
	Size int
	Info []DepthInfo
}

Depth is a struct that contains Pkg, Size and Info. Info is an alias to CycloInfo

type DepthInfo ¶

type DepthInfo CycloInfo

type Error ¶

type Error struct {
	LineNumber  int    `json:"line_number"`
	ErrorString string `json:"error_string"`
}

Error contains the line number and the reason for an error output from a command

type File ¶

type File struct {
	Color     string
	CycloVal  string
	CycloInfo string
}

File is a struct that contains Color, CycloVal and CycloInfo. And it is just for one file's display. The CycloInfo contains all cyclo detail information.

type HtmlData ¶

type HtmlData struct {
	Project          string
	Score            int
	IssuesNum        int
	CodeTest         string
	CodeStyle        string
	CodeOptimization string
	CodeCount        string
	CodeSmell        string
	DepGraph         template.HTML

	Date                 string
	LastRefresh          time.Time `json:"last_refresh"`
	HumanizedLastRefresh string    `json:"humanized_last_refresh"`
}

UnitTest is a struct that contains some features in a report of html.

     GoReporter HTML Report Features

+----------------------------------------------------------------------+
|        Feature        |                 Information                  |
+=======================+==============================================+
| Project               | The path address of the item being detected  |
+-----------------------+----------------------------------------------+
| Score                 | The score of the tested project              |
+-----------------------+----------------------------------------------+
| CodeTest              | Unit test results                            |
+-----------------------+----------------------------------------------+
| IssuesNum             | Issues number of the project                 |
+-----------------------+----------------------------------------------+
| CodeCount             | Number of lines of code                      |
+-----------------------+----------------------------------------------+
| CodeStyle             | Code style check                             |
+-----------------------+----------------------------------------------+
| CodeOptimization      | Code optimization                            |
+-----------------------+----------------------------------------------+
| CodeSmell             | Code smell                                   |
+-----------------------+----------------------------------------------+
| DepGraph              | Depend graph of all packages in the project  |
+-----------------------+----------------------------------------------+
| Date                  | Date assessment of the project               |
+-----------------------+----------------------------------------------+
| LastRefresh           | Last refresh time of one project             |
+-----------------------+----------------------------------------------+
| HumanizedLastRefresh  | Humanized last refresh setting               |
+-----------------------+----------------------------------------------+

And the HtmlData just as data for default html template. If you want to customize your own template file, please follow these data, or you can redefine it yourself.

type Interfacer ¶

type Interfacer struct {
	Path string
	Info string
}

Interfacer is a struct that contains Path and Info. The type of Path and Info MUST string. The Interfacer warns about the usage of types that are more specific than necessary.

type Item ¶

type Item struct {
	File    string   `json:"rep"`
	Content []string `json:"content"`
}

Item is a struct that contains File and Content. It is the code-based infrastructure.

type Metric ¶

type Metric struct {
	Name        string             `json:"name"`
	Description string             `json:"description"`
	Summaries   map[string]Summary `json:"summaries"`
	Weight      float64            `json:"weight"`
	Percentage  float64            `json:"percentage"`
	Error       string             `json:"error"`
}

Metric as template of report and will save all linters result data.But may have some difference in different linter.

type PackageTest ¶

type PackageTest struct {
	IsPass   bool    `json:"is_pass"`
	Coverage string  `json:"coverage"`
	Time     float64 `json:"time"`
}

PackageTest is a struct that contains IsPass, Coverage and Time. The type of Time MUST float64.

type Race ¶

type Race struct {
	Pkg  string
	Len  string
	Leng string
	Info []string
}

Race is a struct that contains Pkg, Len, Leng and Info. The type of Info MUST []string that represents more than one race case. Len is the number of cases.

type Reporter ¶

type Reporter struct {
	Project   string            `json:"project"`
	Score     int               `json:"score"`
	Grade     int               `json:"grade"`
	Metrics   map[string]Metric `json:"metrics"`
	Issues    int               `json:"issues"`
	TimeStamp string            `json:"time_stamp"`
	Linters   []StrategyLinter
	Sync      *Synchronizer `inject:"" json:"-"`

	ProjectPath    string `json:"-"`
	ReportPath     string `json:"-"`
	HtmlTemplate   string `json:"-"`
	ReportFormat   string `json:"-"`
	ExceptPackages string `json:"-"`

	StartTime time.Time
}

Reporter is the top struct of GoReporter.

func NewReporter(projectPath, reportPath, reportFormat, htmlTemplate string) *Reporter

func (r *Reporter) AddLinters(strategies ...StrategyLinter)

func (r *Reporter) Close()

func (r *Reporter) GetFinalScore() (score float64)

func (r *Reporter) Render() (err error)

func (r *Reporter) Report() error

type Scan ¶

type Scan struct {
	Path string
	Info string
}

Scan is a struct that contains Path and Info. The type of Path and Info MUST string. The Scan represents one defect case.

type Simple ¶

type Simple struct {
	Path string
	Info string
}

Simple is a struct that contains Path and Info. The type of Path and Info MUST string. The Simple represents one can be simpled code case.

type Spell ¶

type Spell struct {
	Path string
	Info string
}

Spell is a struct that contains Path and Info. The type of Path and Info MUST string. The Spell represents one word is misspelled.

type StrategyCopyCheck ¶

type StrategyCopyCheck struct {
	Sync *Synchronizer `inject:""`
}

func (s *StrategyCopyCheck) Compute(parameters StrategyParameter) (summaries *Summaries)

func (s *StrategyCopyCheck) GetDescription() string

func (s *StrategyCopyCheck) GetName() string

func (s *StrategyCopyCheck) GetWeight() float64

func (s *StrategyCopyCheck) Percentage(summaries *Summaries) float64

type StrategyCountCode ¶

type StrategyCountCode struct {
	Sync *Synchronizer `inject:""`
}

func (s *StrategyCountCode) Compute(parameters StrategyParameter) (summaries *Summaries)

func (s *StrategyCountCode) GetDescription() string

func (s *StrategyCountCode) GetName() string

func (s *StrategyCountCode) GetWeight() float64

func (s *StrategyCountCode) Percentage(summaries *Summaries) float64

type StrategyCyclo ¶

type StrategyCyclo struct {
	Sync *Synchronizer `inject:""`
	// contains filtered or unexported fields
}

func (s *StrategyCyclo) Compute(parameters StrategyParameter) (summaries *Summaries)

func (s *StrategyCyclo) GetDescription() string

func (s *StrategyCyclo) GetName() string

func (s *StrategyCyclo) GetWeight() float64

func (s *StrategyCyclo) Percentage(summaries *Summaries) float64

type StrategyDeadCode ¶

type StrategyDeadCode struct {
	Sync *Synchronizer `inject:""`
}

func (s *StrategyDeadCode) Compute(parameters StrategyParameter) (summaries *Summaries)

func (s *StrategyDeadCode) GetDescription() string

func (s *StrategyDeadCode) GetName() string

func (s *StrategyDeadCode) GetWeight() float64

func (s *StrategyDeadCode) Percentage(summaries *Summaries) float64

type StrategyDependGraph ¶

type StrategyDependGraph struct {
	Sync *Synchronizer `inject:""`
}

func (s *StrategyDependGraph) Compute(parameters StrategyParameter) (summaries *Summaries)

func (s *StrategyDependGraph) GetDescription() string

func (s *StrategyDependGraph) GetName() string

func (s *StrategyDependGraph) GetWeight() float64

func (s *StrategyDependGraph) Percentage(summaries *Summaries) float64

type StrategyDepth ¶

type StrategyDepth struct {
	Sync *Synchronizer `inject:""`
	// contains filtered or unexported fields
}

func (s *StrategyDepth) Compute(parameters StrategyParameter) (summaries *Summaries)

func (s *StrategyDepth) GetDescription() string

func (s *StrategyDepth) GetName() string

func (s *StrategyDepth) GetWeight() float64

func (s *StrategyDepth) Percentage(summaries *Summaries) float64

type StrategyGoFmt ¶

type StrategyGoFmt struct {
	Sync *Synchronizer `inject:""`
}

func (s *StrategyGoFmt) Compute(parameters StrategyParameter) (summaries *Summaries)

func (s *StrategyGoFmt) GetDescription() string

func (s *StrategyGoFmt) GetName() string

func (s *StrategyGoFmt) GetWeight() float64

func (s *StrategyGoFmt) Percentage(summaries *Summaries) float64

type StrategyGoVet ¶

type StrategyGoVet struct {
	Sync *Synchronizer `inject:""`
}

func (s *StrategyGoVet) Compute(parameters StrategyParameter) (summaries *Summaries)

func (s *StrategyGoVet) GetDescription() string

func (s *StrategyGoVet) GetName() string

func (s *StrategyGoVet) GetWeight() float64

func (s *StrategyGoVet) Percentage(summaries *Summaries) float64

type StrategyImportPackages ¶

type StrategyImportPackages struct {
	Sync *Synchronizer `inject:""`
}

func (s *StrategyImportPackages) Compute(parameters StrategyParameter) (summaries *Summaries)

func (s *StrategyImportPackages) GetDescription() string

func (s *StrategyImportPackages) GetName() string

func (s *StrategyImportPackages) GetWeight() float64

func (s *StrategyImportPackages) Percentage(summaries *Summaries) float64

type StrategyInterfacer ¶

type StrategyInterfacer struct {
	Sync *Synchronizer `inject:""`
}

func (s *StrategyInterfacer) Compute(parameters StrategyParameter) (summaries *Summaries)

func (s *StrategyInterfacer) GetDescription() string

func (s *StrategyInterfacer) GetName() string

func (s *StrategyInterfacer) GetWeight() float64

func (s *StrategyInterfacer) Percentage(summaries *Summaries) float64

type StrategyLint ¶

type StrategyLint struct {
	Sync *Synchronizer `inject:""`
}

func (s *StrategyLint) Compute(parameters StrategyParameter) (summaries *Summaries)

func (s *StrategyLint) GetDescription() string

func (s *StrategyLint) GetName() string

func (s *StrategyLint) GetWeight() float64

func (s *StrategyLint) Percentage(summaries *Summaries) float64

type StrategyLinter ¶

type StrategyLinter interface {
	Compute(parameters StrategyParameter) *Summaries
	Percentage(summaries *Summaries) float64
	GetName() string
	GetDescription() string
	GetWeight() float64
}

type StrategyParameter ¶

type StrategyParameter struct {
	AllDirs, UnitTestDirs       map[string]string
	ProjectPath, ExceptPackages string
}

type StrategySimpleCode ¶

type StrategySimpleCode struct {
	Sync *Synchronizer `inject:""`
}

func (s *StrategySimpleCode) Compute(parameters StrategyParameter) (summaries *Summaries)

func (s *StrategySimpleCode) GetDescription() string

func (s *StrategySimpleCode) GetName() string

func (s *StrategySimpleCode) GetWeight() float64

func (s *StrategySimpleCode) Percentage(summaries *Summaries) float64

type StrategySpellCheck ¶

type StrategySpellCheck struct {
	Sync *Synchronizer `inject:""`
}

func (s *StrategySpellCheck) Compute(parameters StrategyParameter) (summaries *Summaries)

func (s *StrategySpellCheck) GetDescription() string

func (s *StrategySpellCheck) GetName() string

func (s *StrategySpellCheck) GetWeight() float64

func (s *StrategySpellCheck) Percentage(summaries *Summaries) float64

type StrategyUnitTest ¶

type StrategyUnitTest struct {
	Sync *Synchronizer `inject:""`
	// contains filtered or unexported fields
}

func (s *StrategyUnitTest) Compute(parameters StrategyParameter) (summaries *Summaries)

func (s *StrategyUnitTest) GetDescription() string

func (s *StrategyUnitTest) GetName() string

func (s *StrategyUnitTest) GetWeight() float64

func (s *StrategyUnitTest) Percentage(summaries *Summaries) float64

type StyleItem ¶

type StyleItem struct {
	Label  string `json:"label"`
	Score  int    `json:"score"`
	Detail []Item `json:"detail"`
	// contains filtered or unexported fields
}

CodeTest is a struct that contains Summary and Content. It represents the result data of the project unit test.

type Summaries ¶

type Summaries struct {
	Summaries map[string]Summary
	sync.RWMutex
}

func NewSummaries() *Summaries

type Summary ¶

type Summary struct {
	Name        string  `json:"name"`
	Description string  `json:"description"`
	Errors      []Error `json:"errors"`
	SumCover    float64
	CountCover  int
	Avg         float64
}

FileSummary contains the filename, location of the file on GitHub, and all of the errors related to the file

type Synchronizer ¶

type Synchronizer struct {
	SyncRW                *sync.RWMutex     `inject:""`
	WaitGW                *WaitGroupWrapper `inject:""`
	LintersProcessChans   chan int64        `json:"-"`
	LintersFinishedSignal chan string       `json:"-"`
}

type Test ¶

type Test struct {
	Path   string
	Result int
	Time   float64
	Cover  float64
}

Test is a struct that contains Path, Result, Time and Cover. The type of Time and Cover MUST float64. And it is just for one package's display.

type UnitTest ¶

type UnitTest struct {
	AvgCover           string                 `json:"average_cover"`
	PackagesTestDetail map[string]PackageTest `json:"packages_test_detail"`
	PackagesRaceDetail map[string][]string    `json:"packages_race_detail"`
}

UnitTest is a struct that contains AvgCover, PackagesTestDetail and PackagesRaceDetail. The type of AvgCover MUST string that represents the code coverage of the entire project. The type of PackagesTestDetail MUST map[string]PackageTest(contains pass-status,code-coverage and time). and it has all packages' detail information. PackagesRaceDetail contains all packages' race cases.

And the UnitTest contains all packages' result.

type WaitGroupWrapper ¶

type WaitGroupWrapper struct {
	sync.WaitGroup
}

WaitGroupWrapper is a struct that as a waiter for all linetr-tasks.And it encapsulates Sync.WaitGroup that can be call as a interface.

func (w *WaitGroupWrapper) Wrap(cb func())