vnameutil

Documentation

Overview

Package vnameutil provides utilities for generating consistent VNames from common path-like values (e.g., filenames, import paths).

Index

• func Compare(a, b *spb.VName) int
• type Rule
  • func ConvertRule(r *spb.VNameRewriteRule) (Rule, error)
  • func (r Rule) Apply(input string) (*spb.VName, bool)
• type Rules
  • func LoadRules(path string) (Rules, error)
  • func ParseRules(data []byte) (Rules, error)
  • func ReadRules(r io.Reader) (Rules, error)
  • func (r Rules) Apply(input string) (*spb.VName, bool)
  • func (r Rules) ApplyDefault(input string, v *spb.VName) *spb.VName

Functions

func Compare

func Compare(a, b *spb.VName) int

Compare reports the relative order of two vnames, returning -1 if a < b, 0 if a == b, and 1 if a > b.

Types

type Rule

type Rule struct {
	*regexp.Regexp // A pattern to match against an input string
	*spb.VName     // A template to populate with matches from the input
}

A Rule associates a regular expression pattern with a VName template. A Rule can be applied to a string to produce a VName.

func ConvertRule

func ConvertRule(r *spb.VNameRewriteRule) (Rule, error)

ConvertRule compiles a VNameRewriteRule proto into a Rule that can be applied to strings.

func (Rule) Apply

func (r Rule) Apply(input string) (*spb.VName, bool)

Apply reports whether input matches the regexp associated with r. If so, it returns a VName whose fields have values taken from r.VName, with submatches populated from the input string.

Submatch replacement is done using regexp.ExpandString, so the same syntax is supported for specifying replacements.

type Rules

type Rules []Rule

Rules are an ordered set of rewriting rules. Applying a group of rules tries each rule in sequence, and returns the result of the first one that matches.

func LoadRules

func LoadRules(path string) (Rules, error)

LoadRules loads and parses the vname mapping rules in path. If path == "", this returns nil without error (no rules).

func ParseRules

func ParseRules(data []byte) (Rules, error)

ParseRules reads Rules data from a byte array.

func ReadRules

func ReadRules(r io.Reader) (Rules, error)

ReadRules parses Rules from JSON-encoded data in the following format:

[
  {
    "pattern": "re2_regex_pattern",
    "vname": {
      "corpus": "corpus_template",
      "root": "root_template",
      "path": "path_template"
    }
  }, ...
]

Each pattern is an RE2 regexp pattern. Patterns are implicitly anchored at both ends. The template strings may contain markers of the form @n@, that will be replaced by the n'th regexp group on a successful input match.

func (Rules) Apply

func (r Rules) Apply(input string) (*spb.VName, bool)

Apply applies each rule in to the input in sequence, returning the first successful match. If no rules apply, returns (nil, false).

func (Rules) ApplyDefault

func (r Rules) ApplyDefault(input string, v *spb.VName) *spb.VName

ApplyDefault acts as r.Apply, but returns v there is no matching rule.