func ParseRefSpec(spec string) (RefSpec, error) {
dspec, err := ParseDatasetSpec(spec)
if err != nil {
return RefSpec{}, err
}
if r, ok := hash.MaybeParse(dspec.DatasetName); ok {
return RefSpec{DbSpec: dspec.DbSpec, Ref: r}, nil
}
return RefSpec{}, fmt.Errorf("Invalid path spec: %s", spec)
}
func NewAbsolutePath(str string) (AbsolutePath, error) {
if len(str) == 0 {
return AbsolutePath{}, errors.New("Empty path")
}
var h hash.Hash
var dataset string
var pathStr string
if str[0] == '#' {
tail := str[1:]
if len(tail) < hash.StringLen {
return AbsolutePath{}, errors.New("Invalid hash: " + tail)
}
hashStr := tail[:hash.StringLen]
if h2, ok := hash.MaybeParse(hashStr); ok {
h = h2
} else {
return AbsolutePath{}, errors.New("Invalid hash: " + hashStr)
}
pathStr = tail[hash.StringLen:]
} else {
datasetParts := datasetCapturePrefixRe.FindStringSubmatch(str)
if datasetParts == nil {
return AbsolutePath{}, fmt.Errorf("Invalid dataset name: %s", str)
}
dataset = datasetParts[1]
pathStr = str[len(dataset):]
}
if len(pathStr) == 0 {
return AbsolutePath{hash: h, dataset: dataset}, nil
}
path, err := types.ParsePath(pathStr)
if err != nil {
return AbsolutePath{}, err
}
return AbsolutePath{hash: h, dataset: dataset, path: path}, nil
}
func parsePathIndex(str string) (idx Value, h hash.Hash, rem string, err error) {
Switch:
switch str[0] {
case '"':
// String is complicated because ] might be quoted, and " or \ might be escaped.
stringBuf := bytes.Buffer{}
i := 1
for ; i < len(str); i++ {
c := str[i]
if c == '"' {
break
}
if c == '\\' && i < len(str)-1 {
i++
c = str[i]
if c != '\\' && c != '"' {
err = errors.New(`Only " and \ can be escaped`)
break Switch
}
}
stringBuf.WriteByte(c)
}
if i == len(str) {
err = errors.New("[ is missing closing ]")
} else {
idx = String(stringBuf.String())
rem = str[i+2:]
}
default:
split := strings.SplitN(str, "]", 2)
if len(split) < 2 {
err = errors.New("[ is missing closing ]")
break Switch
}
idxStr := split[0]
rem = split[1]
if len(idxStr) == 0 {
err = errors.New("Empty index value")
} else if idxStr[0] == '#' {
hashStr := idxStr[1:]
h, _ = hash.MaybeParse(hashStr)
if h.IsEmpty() {
err = errors.New("Invalid hash: " + hashStr)
}
} else if idxStr == "true" {
idx = Bool(true)
} else if idxStr == "false" {
idx = Bool(false)
} else if i, err2 := strconv.ParseFloat(idxStr, 64); err2 == nil {
// Should we be more strict here? ParseFloat allows leading and trailing dots, and exponents.
idx = Number(i)
} else {
err = errors.New("Invalid index: " + idxStr)
}
}
return
}
