analyzer

type Analyzer ¶

type Analyzer interface {
	Name() string
	Analyze(ctx context.Context, dir fs.FS) ([]Metrics, error)
}

Analyzer is expected to walk dir and extract the PackageImports.

type BoundaryProvider ¶

type BoundaryProvider interface {
	Boundaries(ctx context.Context, dir fs.FS) ([]PackageBoundary, error)
}

BoundaryProvider is optionally implemented by analyzers that can report package boundaries. Boundaries() lazily invokes Analyze() if boundaries have not been populated yet.

type CouplingStat ¶

type CouplingStat struct {
	Count     uint       `json:"count"`
	Positions []Position `json:"positions,omitempty"`
}

CouplingStat records the occurrence count and source positions for a single coupling.

type CouplingStats ¶

type CouplingStats map[string]CouplingStat

CouplingStats stores granular dependency statistics key is a qualified type or selector expression e.g. context.Context: Count: 10 e.g. io.ReadAll: Count: 10.

type Import ¶

type Import Package

Import is semantically identical to package except in how it is used re-typed here to explicitly communicate the relationship in PackageImports.

type ImportInfo ¶

type ImportInfo struct {
	Package string
	// contains filtered or unexported fields
}

ImportInfo accumulates per-symbol coupling statistics for one imported package.

func NewImportInfo(pkg string) *ImportInfo

func (ii *ImportInfo) Add(key, expr string, pos Position)

func (ii *ImportInfo) AddWithCount(key, expr string, count uint, positions []Position)

func (ii *ImportInfo) CouplingStats() CouplingStats

func (ii *ImportInfo) Key() string

type LanguageMetricsSummary ¶

type LanguageMetricsSummary struct {
	Language string           `json:"language"`
	Metrics  []MetricsSummary `json:"metrics"`
}

LanguageMetricsSummary pairs a language with simplified metrics.

type Metrics ¶

type Metrics struct {
	Package Package `json:"package"`
	// The number of packages that depend on this package
	Inward PackageCouplingStats `json:"inward"`
	// The number of other packages this package depends on
	Outward PackageCouplingStats `json:"outward"`
}

Metrics is the coupling snapshot for a single package — the inward dependents and the outward dependencies, each carrying per-package CouplingStats. Marshalled JSON layout:

{
  "github.com/f/uda/internal/analyzer": {
    "outward": {
      "context":  {"context.Context": 1},
      "io/fs":    {"fs.FS": 1}
    },
    "inward": {
      "github.com/f/uda/internal/analyzer/golang": {
        "analyzer.Package":        5,
        "analyzer.Analyzer":       1,
        "analyzer.PackageImports": 2
      }
    }
  }
}

func (m Metrics) Instability() float64

func (m Metrics) InwardCoupling() float64

func (m Metrics) OutwardCoupling() float64

type MetricsSummary ¶

type MetricsSummary struct {
	Package     string  `json:"package"`
	Inward      int     `json:"inward"`
	Outward     int     `json:"outward"`
	Instability float64 `json:"instability"`
}

MetricsSummary is the simplified output format matching the table view.

type Package ¶

type Package string

Package identifies an analyzed package by its canonical name.

type PackageAnalysis ¶

type PackageAnalysis struct {
	Package string
	Out     *PackageImportInfo
	In      *PackageImportInfo
	Aliases map[string]string
}

PackageAnalysis holds the inward and outward import information for one package.

func (p *PackageAnalysis) Key() string

type PackageAnalysisTree ¶

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

PackageAnalysisTree indexes PackageAnalysis nodes by package name.

func NewPackageAnalysisTree() *PackageAnalysisTree

func (p *PackageAnalysisTree) Add(packageName string) *PackageAnalysis

func (p *PackageAnalysisTree) Get(packageName string) (*PackageAnalysis, bool)

func (p *PackageAnalysisTree) GetRootNodes() []*PackageAnalysis

type PackageBoundary ¶

type PackageBoundary struct {
	Name string   `json:"Name"` // Package identifier (matches Package string value)
	Dirs []string `json:"Dirs"` // Directories constituting this package (relative to analysis root)
}

PackageBoundary describes the filesystem scope of a package.

type PackageCouplingStats ¶

type PackageCouplingStats map[Package]CouplingStats

PackageCouplingStats is expected to contain a list of outward or inward dependencies Inward example:

"github.com/flamingoosesoftwareinc/uda/internal/analyzer/golang": {
  "analyzer.Package": 3
}

Outward example:

"github.com/flamingoosesoftwareinc/uda/internal/analyzer": {
  "context.Context": 3
}

func GetCouplingStats(ctx context.Context, pii *PackageImportInfo) PackageCouplingStats

type PackageImportInfo ¶

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

PackageImportInfo maps imported package names to their ImportInfo.

func (pi *PackageImportInfo) Add(pkg string) *ImportInfo

func (pi *PackageImportInfo) Get(pkg string) (*ImportInfo, bool)

func (pi *PackageImportInfo) GetChildren() []*ImportInfo

type PackageImports ¶

type PackageImports map[Package][]Import

PackageImports is expected to contain a mapping of a package and its dependencies e.g. {"analyzer":["context","io/fs"]}.

type Position ¶

type Position struct {
	File     string `json:"file"`
	Line     uint   `json:"line"`
	ColStart uint   `json:"col_start"`
	ColEnd   uint   `json:"col_end"`
}

Position records where a coupling reference occurs in source code.

type StringInterner ¶

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

StringInterner deduplicates strings so that identical strings share the same underlying memory. This reduces memory usage when the same file path appears in many Position structs.

func NewStringInterner() *StringInterner

func (i *StringInterner) Intern(s string) string