module

Documentation

Overview

Package module defines a FOSSA CLI module.

Index

• type Analysis
• type AnalyzerV2
  • func (a AnalyzerV2) ScanModule(startJob func() error, endJob func(), progress display.ProgressTracker, ...) ([]TaggedGraph, *errors.Error)
• type AnalyzerV2Output
• type DiscoverFuncV2
• type DiscoveredStrategies
• type Filepath
• type Hashes
• type Module
  • func (p *Module) IsAnalyzed() bool
• type Strategies
• type Strategy
• type StrategyName
• type TaggedGraph

Types

type Analysis

type Analysis struct {
	AnalyzerName string
	Graphs       []TaggedGraph
}

The completed analysis by an analyzer

type AnalyzerV2

type AnalyzerV2 struct {
	Name         string
	DiscoverFunc DiscoverFuncV2
	Strategies   Strategies
}

func (AnalyzerV2) ScanModule

func (a AnalyzerV2) ScanModule(startJob func() error, endJob func(), progress display.ProgressTracker, folder Filepath, strategies DiscoveredStrategies) ([]TaggedGraph, *errors.Error)

type AnalyzerV2Output

type AnalyzerV2Output map[Filepath][]Analysis

type DiscoverFuncV2

type DiscoverFuncV2 func(dir Filepath) (map[Filepath]DiscoveredStrategies, *errors.Error) // Map from 'module' roots to discovered strategies

A discoverfunc takes a root directory to scan and produces a map of relative filepaths to discovered strategies

NB: we may discover overlapping strategies for the same module For example: if we find package.json and node_modules, we're going to discover two `npm ls` strategies

We arbitrarily choose one file to use as the target of that strategy

type DiscoveredStrategies

type DiscoveredStrategies = map[StrategyName]Filepath

The filepath is the relative filepath from the root of the module

type Filepath

type Filepath = string

type Hashes

type Hashes struct {
	SHA1   string
	SHA256 string
	MD5    string
}

Hashes contains hexadecimal checksums of code libraries brought in by running a Build.

type Module

type Module struct {
	Name         string   `yaml:"name"`             // Uniquely identifies the module.
	Type         pkg.Type `yaml:"type"`             // Type of the root package, used to select the module's analyzer.
	IsExecutable bool     `yaml:"-"`                // Used for filtering discovered projects.
	Ignore       bool     `yaml:"ignore,omitempty"` // Used for marking ignored (blacklisted) modules.

	BuildTarget string `yaml:"target,omitempty"` // Exact build target in the semantics of the module's analyzers.
	Dir         string `yaml:"cwd,omitempty"`    // CWD to analyze the module from.

	Options map[string]interface{} `yaml:"options,omitempty"` // Analyzer option struct of the module type.

	Imports []pkg.Import           `yaml:"-"` // Direct dependencies of the root package.
	Deps    map[pkg.ID]pkg.Package `yaml:"-"` // All transitive dependencies of the root package (including Imports).
}

A Module is a single compilable unit of code (e.g. an entrypoint) to analyze. Modules consist of a root Package, and the transitive dependencies of that package.

func (*Module) IsAnalyzed

func (p *Module) IsAnalyzed() bool

IsAnalyzed returns true if a module has already been analyzed, and false otherwise.

type Strategies

type Strategies struct {
	// Map of strategy names to functions
	Named map[StrategyName]Strategy
	// The order in which to run strategies -- the first strategy to succeed is elected
	// as the "Best" dependency graph
	SortedNames []StrategyName
	// The set of optimal strategies. This will be used for warnings
	Optimal []StrategyName
}

type Strategy

type Strategy func(dir Filepath, target Filepath) (graph.Deps, *errors.Error)

A strategy produces a dependency graph, with two paths relative to the root as arguments:

• The directory of the module. This is usually the parent directory of the "target"
• The "target" -- usually the file (or directory) that caused the invocation of this strategy

type StrategyName

type StrategyName = string

type TaggedGraph

type TaggedGraph struct {
	Strategy StrategyName
	// The file that led to this analysis, most often the file
	// analyzed by the relevant strategy
	File  Filepath
	Graph graph.Deps
}