Factor out datas.ReadAbsolutePaths() (#2623)

go/datas/dataset.go

@@ -84,3 +84,7 @@ func (ds Dataset) HeadValue() types.Value {
 	c := ds.Head()
 	return c.Get(ValueField)
 }
+
+func IsValidDatasetName(name string) bool {
+	return DatasetFullRe.MatchString(name)
+}

go/datas/dataset_test.go

@@ -168,3 +168,22 @@ func TestHeadValueFunctions(t *testing.T) {
 	_, ok = ds2.MaybeHeadValue()
 	assert.False(ok)
 }
+
+func TestIsValidDatasetName(t *testing.T) {
+	assert := assert.New(t)
+	cases := []struct {
+		name  string
+		valid bool
+	}{
+		{"foo", true},
+		{"foo/bar", true},
+		{"f1", true},
+		{"1f", true},
+		{"", false},
+		{"f!!", false},
+	}
+	for _, c := range cases {
+		assert.Equal(c.valid, IsValidDatasetName(c.name),
+			"Expected %s validity to be %t", c.name, c.valid)
+	}
+}

go/spec/absolute_path.go

@@ -98,3 +98,21 @@ func (p AbsolutePath) String() (str string) {
 
 	return str + p.path.String()
 }
+
+func ReadAbsolutePaths(db datas.Database, paths ...string) ([]types.Value, error) {
+	r := make([]types.Value, 0, len(paths))
+	for _, ps := range paths {
+		p, err := NewAbsolutePath(ps)
+		if err != nil {
+			return nil, fmt.Errorf("Invalid input path '%s'", ps)
+		}
+
+		v := p.Resolve(db)
+		if v == nil {
+			return nil, fmt.Errorf("Input path '%s' does not exist in database", ps)
+		}
+
+		r = append(r, v)
+	}
+	return r, nil
+}

go/spec/absolute_path_test.go

@@ -80,6 +80,33 @@ func TestAbsolutePaths(t *testing.T) {
 	resolvesTo(nil, "#"+types.String("baz").Hash().String()+"[0]")
 }
 
+func TestReadAbsolutePaths(t *testing.T) {
+	assert := assert.New(t)
+
+	s0, s1 := types.String("foo"), types.String("bar")
+	list := types.NewList(s0, s1)
+
+	db := datas.NewDatabase(chunks.NewMemoryStore())
+	ds := db.GetDataset("ds")
+	ds, err := db.CommitValue(ds, list)
+	assert.NoError(err)
+
+	vals, err := ReadAbsolutePaths(db, "ds.value[0]", "ds.value[1]")
+	assert.NoError(err)
+
+	assert.Equal(2, len(vals))
+	assert.Equal("foo", string(vals[0].(types.String)))
+	assert.Equal("bar", string(vals[1].(types.String)))
+
+	vals, err = ReadAbsolutePaths(db, "!!#")
+	assert.Nil(vals)
+	assert.Equal("Invalid input path '!!#'", err.Error())
+
+	vals, err = ReadAbsolutePaths(db, "invalid.monkey")
+	assert.Nil(vals)
+	assert.Equal("Input path 'invalid.monkey' does not exist in database", err.Error())
+}
+
 func TestAbsolutePathParseErrors(t *testing.T) {
 	assert := assert.New(t)
 

samples/go/photo-index/main.go

@@ -49,29 +49,17 @@ func index() (win bool) {
 	defer db.Close()
 
 	var outDS datas.Dataset
-	if !datas.DatasetFullRe.MatchString(*outDSStr) {
+	if !datas.IsValidDatasetName(*outDSStr) {
 		fmt.Fprintf(os.Stderr, "Invalid output dataset name: %s\n", *outDSStr)
 		return
 	} else {
 		outDS = db.GetDataset(*outDSStr)
 	}
 
-	inputs := []types.Value{}
-	for i := 0; i < flag.NArg(); i++ {
-		p, err := spec.NewAbsolutePath(flag.Arg(i))
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Invalid input path '%s', error: %s\n", flag.Arg(i), err)
-			return
-		}
-
-		v := p.Resolve(db)
-		if v == nil {
-			fmt.Fprintf(os.Stderr, "Input path '%s' does not exist in '%s'", flag.Arg(i), *dbStr)
-			return
-		}
-
-		inputs = append(inputs, v)
-		continue
+	inputs, err := spec.ReadAbsolutePaths(db, flag.Args()...)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "%s\n", err)
+		return
 	}
 
 	sizeType := types.MakeStructTypeFromFields("", types.FieldMap{