entity

type AnalysisConfig struct {
	Miners                    []string
	MinerAlgorithmFactory     MinerAbstractFactory
	ExtractorFactory          ExtractorFactory
	SplittingAlgorithmFactory SplitterAbstractFactory
	Splitters                 []string
	ExpansionAlgorithmFactory ExpanderAbstractFactory
	Expanders                 []string
}

type AnalysisResults struct {
	ID                      uuid.UUID
	DateCreated             time.Time
	ProjectID               uuid.UUID
	ProjectName             string
	PipelineMiners          []string
	PipelineSplitters       []string
	PipelineExpanders       []string
	FilesTotal              int
	FilesValid              int
	FilesError              int
	FilesErrorSamples       []string
	IdentifiersTotal        int
	IdentifiersValid        int
	IdentifiersError        int
	IdentifiersErrorSamples []string
}

type Expander interface {
	// Name returns the name of the custom expander.
	Name() string
	// ApplicableOn defines the name of splits used as input.
	ApplicableOn() string
	// Expand performs the expansion on the token as a whole.
	Expand(ident Identifier) []Expansion
}

type ExpanderAbstractFactory interface {
	// Get returns a ExpanderFactory for the selectd expansion algorithm.
	Get(algorithm string) (ExpanderFactory, error)
}

type ExpanderFactory interface {
	// Make returns an expansion algorithm instance built from miners.
	Make(miningResults map[string]Miner) (Expander, error)
}

type Expansion struct {
	Order              int
	From               string
	Values             []string
	SplittingAlgorithm string
}

type Extractor interface {
	// Visit applies the extraction logic while traversing the Abstract Syntax Tree.
	Visit(node ast.Node) ast.Visitor
	// Identifiers returns the extracted identifiers.
	Identifiers() []Identifier
}

type ExtractorFactory func(filename string) Extractor

type File struct {
	Name    string
	Raw     []byte
	AST     *ast.File
	FileSet *token.FileSet
	Error   error
}

type IDBuilder struct {
	// contains filtered or unexported fields
}

type Identifier struct {
	ID            string
	ProjectRef    string
	AnalysisID    uuid.UUID
	Package       string
	File          string
	Position      token.Pos
	Name          string
	Type          token.Token
	Node          *ast.Node
	Splits        map[string][]Split
	Expansions    map[string][]Expansion
	Error         error
	Normalization Normalization
}

type Insight struct {
	ID               string
	ProjectRef       string
	AnalysisID       uuid.UUID
	Package          string
	TotalIdentifiers int
	TotalExported    int
	TotalSplits      map[string]int
	TotalExpansions  map[string]int
	TotalWeight      float64
	Files            map[string]struct{}
}

type Metadata struct {
	RemoteID      string
	Owner         string
	Fullname      string
	Description   string
	CloneURL      string
	DefaultBranch string
	License       string
	CreatedAt     *time.Time
	UpdatedAt     *time.Time
	IsFork        bool
	Size          int32
	Stargazers    int32
	Watchers      int32
	Forks         int32
}

type Miner interface {
	// Name provides the name of the miner.
	Name() string
	// Visit applies the mining logic while traversing the Abstract Syntax Tree.
	Visit(node ast.Node) ast.Visitor
	// SetCurrentFile specifies the current file being mined.
	SetCurrentFile(filename string)
	// Results returns the results after mining.
	Results() interface{}
}

type MinerAbstractFactory interface {
	// Get returns a MinerFactory for the selectd mining algorithm.
	Get(algorithm string) (MinerFactory, error)
}

type MinerFactory interface {
	// Make returns a mining algorithm instance.
	Make() (Miner, error)
}

type Normalization struct {
	Word      string
	Algorithm string
	Score     float64
}

type Project struct {
	ID         uuid.UUID
	Status     string
	Reference  string
	CreatedAt  time.Time
	Metadata   Metadata
	SourceCode SourceCode
}

type SourceCode struct {
	Hash     string
	Location string
	Files    []string
}

type Split struct {
	Order int
	Value string
}

type Splitter interface {
	// Name returns the name of the custom splitter.
	Name() string
	// Split returns the split identifier.
	Split(token string) []Split
}

type SplitterAbstractFactory interface {
	// Get returns a SplitterFactory for the selectd splitting algorithm.
	Get(algorithm string) (SplitterFactory, error)
}

type SplitterFactory interface {
	// Make returns a splitting algorithm instance built from miners.
	Make(miners map[string]Miner) (Splitter, error)
}