tagcmp/godoc.md

<!-- Code generated by gomarkdoc. DO NOT EDIT -->

# tagcmp

```go
import "coopcloud.tech/tagcmp"
```

Package tagcmp provides image tag comparison operations\.

## Index

- [Variables](<#variables>)
- [func IsParsable(tag string) bool](<#func-isparsable>)
- [type ByTagAsc](<#type-bytagasc>)
  - [func (t ByTagAsc) Len() int](<#func-bytagasc-len>)
  - [func (t ByTagAsc) Less(i, j int) bool](<#func-bytagasc-less>)
  - [func (t ByTagAsc) Swap(i, j int)](<#func-bytagasc-swap>)
- [type ByTagDesc](<#type-bytagdesc>)
  - [func (t ByTagDesc) Len() int](<#func-bytagdesc-len>)
  - [func (t ByTagDesc) Less(i, j int) bool](<#func-bytagdesc-less>)
  - [func (t ByTagDesc) Swap(i, j int)](<#func-bytagdesc-swap>)
- [type Tag](<#type-tag>)
  - [func Parse(tag string) (Tag, error)](<#func-parse>)
  - [func (t Tag) Equals(tag Tag) bool](<#func-tag-equals>)
  - [func (t Tag) IsCompatible(tag Tag) bool](<#func-tag-iscompatible>)
  - [func (t Tag) IsGreaterThan(tag Tag) bool](<#func-tag-isgreaterthan>)
  - [func (t Tag) IsLessThan(tag Tag) bool](<#func-tag-islessthan>)
  - [func (t Tag) String() string](<#func-tag-string>)
  - [func (curTag Tag) UpgradeDelta(newTag Tag) (TagDelta, error)](<#func-tag-upgradedelta>)
- [type TagDelta](<#type-tagdelta>)
  - [func ParseDelta(delta string) (TagDelta, error)](<#func-parsedelta>)
  - [func (t TagDelta) String() string](<#func-tagdelta-string>)
  - [func (d TagDelta) UpgradeType() int](<#func-tagdelta-upgradetype>)


## Variables

CommitHashPattern matches commit\-like hash tags

```go
var CommitHashPattern = "^[a-f0-9]{7,40}$"
```

DotPattern matches tags which contain multiple versions

```go
var DotPattern = "([0-9]+)\\.([0-9]+)"
```

EmptyPattern matches when tags are missing

```go
var EmptyPattern = "^$"
```

ParametrizedPattern matches when tags are parametrized

```go
var ParametrizedPattern = "\\${.+}"
```

StringPattern matches when tags are only made up of alphabetic characters

```go
var StringPattern = "^[a-zA-Z]+$"
```

## func IsParsable

```go
func IsParsable(tag string) bool
```

IsParsable determines if a tag is supported by this library

## type ByTagAsc

ByTagAsc sorts tags in ascending order where the last element is the latest tag\.

```go
type ByTagAsc []Tag
```

### func \(ByTagAsc\) Len

```go
func (t ByTagAsc) Len() int
```

### func \(ByTagAsc\) Less

```go
func (t ByTagAsc) Less(i, j int) bool
```

### func \(ByTagAsc\) Swap

```go
func (t ByTagAsc) Swap(i, j int)
```

## type ByTagDesc

ByTagDesc sorts tags in descending order where the first element is the latest tag\.

```go
type ByTagDesc []Tag
```

### func \(ByTagDesc\) Len

```go
func (t ByTagDesc) Len() int
```

### func \(ByTagDesc\) Less

```go
func (t ByTagDesc) Less(i, j int) bool
```

### func \(ByTagDesc\) Swap

```go
func (t ByTagDesc) Swap(i, j int)
```

## type Tag

```go
type Tag struct {
    Major        string `json:",omitempty"` // major semver part
    Minor        string `json:",omitempty"` // minor semver part
    MissingMinor bool   // whether or not the minor semver part was left out
    Patch        string `json:",omitempty"` // patch semver part
    MissingPatch bool   // whether or not he patch semver part was left out
    Suffix       string // tag suffix (e.g. "-alpine") [would be release candidate in semver]
    UsesV        bool   // whether or not the tag uses the "v" prefix
    Metadata     string // metadata: what's after + and after the first "-"
}
```

### func Parse

```go
func Parse(tag string) (Tag, error)
```

Parse converts an image tag into a structured data format\. It aims to to support the general case of tags which are "semver\-like" and/or stable and parseable by heuristics\. Image tags follow no formal specification and therefore this is a best\-effort implementation\. Examples of tags this function can parse are: "5"\, "5\.2"\, "v4"\, "v5\.3\.6"\, "4\-alpine"\, "v3\.2\.1\-debian"\.

### func \(Tag\) Equals

```go
func (t Tag) Equals(tag Tag) bool
```

Equals tests Tag equality

### func \(Tag\) IsCompatible

```go
func (t Tag) IsCompatible(tag Tag) bool
```

IsCompatible determines if two tags can be compared together

### func \(Tag\) IsGreaterThan

```go
func (t Tag) IsGreaterThan(tag Tag) bool
```

IsGreaterThan tests if a tag is greater than another\. There are some tag\-isms to take into account here\, shorter is bigger \(i\.e\. 2\.1 \> 2\.1\.1 == true\, 2 \> 2\.1 == true\)\.

### func \(Tag\) IsLessThan

```go
func (t Tag) IsLessThan(tag Tag) bool
```

IsLessThan tests if a tag is less than another\. There are some tag\-isms to take into account here\, shorter is bigger \(i\.e\. 2\.1 \< 2\.1\.1 == false\, 2 \< 2\.1 == false\)\.

### func \(Tag\) String

```go
func (t Tag) String() string
```

String formats a Tag correctly in string representation

### func \(Tag\) UpgradeDelta

```go
func (curTag Tag) UpgradeDelta(newTag Tag) (TagDelta, error)
```

UpgradeDelta returns a TagDelta object which is the difference between an old and new tag It can contain negative numbers if comparing with an older tag\.

## type TagDelta

```go
type TagDelta struct {
    Major int // major semver difference
    Minor int // minor semver difference
    Patch int // patch semver difference
}
```

### func ParseDelta

```go
func ParseDelta(delta string) (TagDelta, error)
```

ParseDelta converts a tag difference in the format of X\, X\.Y or X\.Y\.Z where X\, Y\, Z are positive or negative integers or 0

### func \(TagDelta\) String

```go
func (t TagDelta) String() string
```

### func \(TagDelta\) UpgradeType

```go
func (d TagDelta) UpgradeType() int
```

UpgradeType takes exit from UpgradeElemene and returns a numeric representation of upgrade or downgrade 1/\-1: patch 2/\-2: minor 4/\-4: major 0: no change



Generated by [gomarkdoc](<https://github.com/princjef/gomarkdoc>)