feat(remotes): base/fill/PathValue used by Config, to enable Remotes

Instead of the old Config.Set, use the new base/fill/PathValue to Set
and Get dot-separated field values on the Config object. Use this to
set and get Remote names.

base/fill/path_value.go

@@ -0,0 +1,183 @@
+package fill
+
+import (
+ "fmt"
+ "reflect"
+ "strconv"
+ "strings"
+)
+
+var (
+ // ErrNotFound is returned when a field isn't found
+ ErrNotFound = fmt.Errorf("not found")
+)
+
+// CoercionError represents an error when a value cannot be converted from one type to another
+type CoercionError struct {
+ From string
+ To string
+}
+
+// Error displays the text version of the CoercionError
+func (c *CoercionError) Error() string {
+ return fmt.Sprintf("could not coerce from %s to %s", c.From, c.To)
+}
+
+// SetPathValue sets a value on a the output struct, accessed using the path of dot-separated fields
+func SetPathValue(path string, val interface{}, output interface{}) error {
+ target := reflect.ValueOf(output)
+ steps := strings.Split(path, ".")
+ // Find target place to assign to, field is a non-empty string only if target is a map.
+ target, field, err := findTargetAtPath(steps, target)
+ if err != nil {
+ if err == ErrNotFound {
+ return fmt.Errorf("path: \"%s\" not found", path)
+ }
+ return err
+ }
+ if field == "" {
+ // Convert val into the correct type, parsing ints and bools and so forth.
+ val, err = coerceToTargetType(val, target)
+ if err != nil {
+ if cerr, ok := err.(*CoercionError); ok {
+ return fmt.Errorf("invalid type for path \"%s\": expected %s, got %s",
+ path, cerr.To, cerr.From)
+ }
+ return err
+ }
+ return putValueToPlace(val, target)
+ }
+ // A map with a field name to assign to.
+ // TODO: Only works for map[string]string, not map's with a struct for a value.
+ target.SetMapIndex(reflect.ValueOf(field), reflect.ValueOf(val))
+ return nil
+}
+
+// GetPathValue gets a value from the input struct, accessed using the path of dot-separated fields
+func GetPathValue(path string, input interface{}) (interface{}, error) {
+ target := reflect.ValueOf(input)
+ steps := strings.Split(path, ".")
+ // Find target place to assign to, field is a non-empty string only if target is a map.
+ target, field, err := findTargetAtPath(steps, target)
+ if err != nil {
+ if err == ErrNotFound {
+ return nil, fmt.Errorf("path: \"%s\" not found", path)
+ }
+ return nil, err
+ }
+ if field == "" {
+ return target.Interface(), nil
+ }
+ lookup := target.MapIndex(reflect.ValueOf(field))
+ if lookup.IsValid() {
+ return lookup.Interface(), nil
+ }
+ return nil, fmt.Errorf("invalid path: \"%s\"", path)
+}
+
+func findTargetAtPath(steps []string, place reflect.Value) (reflect.Value, string, error) {
+ if len(steps) == 0 {
+ return place, "", nil
+ }
+ // Get current step of the path, dispatch on its type.
+ s := steps[0]
+ rest := steps[1:]
+ if place.Kind() == reflect.Struct {
+ field := getFieldCaseInsensitive(place, s)
+ if !field.IsValid() {
+ return place, "", ErrNotFound
+ }
+ return findTargetAtPath(rest, field)
+ } else if place.Kind() == reflect.Ptr {
+ var inner reflect.Value
+ if place.IsNil() {
+ alloc := reflect.New(place.Type().Elem())
+ place.Set(alloc)
+ inner = alloc.Elem()
+ } else {
+ inner = place.Elem()
+ }
+ return findTargetAtPath(steps, inner)
+ } else if place.Kind() == reflect.Map {
+ if place.IsNil() {
+ place.Set(reflect.MakeMap(place.Type()))
+ }
+ // TODO: Handle case where `rest` has more steps and `val` is a struct: more
+ // recursive is needed.
+ return place, s, nil
+ } else if place.Kind() == reflect.Slice {
+ num, err := coerceToInt(s)
+ if err != nil {
+ return place, "", err
+ }
+ if num >= place.Len() {
+ return place, "", fmt.Errorf("index outside of range: %d, len is %d", num, place.Len())
+ }
+ elem := place.Index(num)
+ return findTargetAtPath(rest, elem)
+ } else {
+ return place, "", fmt.Errorf("cannot set field of type %s", place.Kind())
+ }
+}
+
+func coerceToTargetType(val interface{}, place reflect.Value) (interface{}, error) {
+ switch place.Kind() {
+ case reflect.Bool:
+ str, ok := val.(string)
+ if ok {
+ str = strings.ToLower(str)
+ if str == "true" {
+ return true, nil
+ } else if str == "false" {
+ return false, nil
+ } else {
+ return nil, fmt.Errorf("could not parse value to bool")
+ }
+ }
+ b, ok := val.(bool)
+ if ok {
+ return b, nil
+ }
+ return nil, &CoercionError{To: "bool", From: reflect.TypeOf(val).Name()}
+ case reflect.Int:
+ num, ok := val.(int)
+ if ok {
+ return num, nil
+ }
+ str, ok := val.(string)
+ if ok {
+ parsed, err := strconv.ParseInt(str, 10, 32)
+ return int(parsed), err
+ }
+ return nil, &CoercionError{To: "int", From: reflect.TypeOf(val).Name()}
+ case reflect.Ptr:
+ alloc := reflect.New(place.Type().Elem())
+ return coerceToTargetType(val, alloc.Elem())
+ case reflect.String:
+ str, ok := val.(string)
+ if ok {
+ return str, nil
+ }
+ return nil, &CoercionError{To: "string", From: reflect.TypeOf(val).Name()}
+ default:
+ return nil, fmt.Errorf("unknown kind: %s", place.Kind())
+ }
+}
+
+func coerceToInt(val interface{}) (int, error) {
+ num, ok := val.(int)
+ if ok {
+ return num, nil
+ }
+ str, ok := val.(string)
+ if ok {
+ parsed, err := strconv.ParseInt(str, 10, 32)
+ return int(parsed), err
+ }
+ return -1, &CoercionError{To: "int", From: reflect.TypeOf(val).Name()}
+}
+
+func getFieldCaseInsensitive(place reflect.Value, name string) reflect.Value {
+ name = strings.ToLower(name)
+ return place.FieldByNameFunc(func(s string) bool { return strings.ToLower(s) == name })
+}

base/fill/path_value_test.go

@@ -0,0 +1,122 @@
+package fill
+
+import (
+ "testing"
+)
+
+func TestFillPathValue(t *testing.T) {
+ c := Collection{}
+ err := SetPathValue("name", "Alice", &c)
+ if err != nil {
+ panic(err)
+ }
+ if c.Name != "Alice" {
+ t.Errorf("expected: s.Name should be \"Alice\"")
+ }
+
+ c = Collection{}
+ err = SetPathValue("age", 42, &c)
+ if err != nil {
+ panic(err)
+ }
+ if c.Age != 42 {
+ t.Errorf("expected: s.Age should be 42")
+ }
+
+ c = Collection{}
+ err = SetPathValue("age", "56", &c)
+ if err != nil {
+ panic(err)
+ }
+ if c.Age != 56 {
+ t.Errorf("expected: s.Age should be 56")
+ }
+
+ c = Collection{}
+ err = SetPathValue("ison", "true", &c)
+ if err != nil {
+ panic(err)
+ }
+ if !c.IsOn {
+ t.Errorf("expected: s.IsOn should be true")
+ }
+
+ c = Collection{}
+ err = SetPathValue("ison", true, &c)
+ if err != nil {
+ panic(err)
+ }
+ if !c.IsOn {
+ t.Errorf("expected: s.IsOn should be true")
+ }
+
+ c = Collection{}
+ err = SetPathValue("ptr", 123, &c)
+ if err != nil {
+ panic(err)
+ }
+ if *(c.Ptr) != 123 {
+ t.Errorf("expected: s.Ptr should be 123")
+ }
+
+ c = Collection{}
+ err = SetPathValue("not_found", "missing", &c)
+ expect := "path: \"not_found\" not found"
+ if err == nil {
+ t.Fatalf("expected: error \"%s\", got no error", expect)
+ }
+ if err.Error() != expect {
+ t.Errorf("expected: error should be \"%s\", got \"%s\"", expect, err.Error())
+ }
+
+ c = Collection{}
+ err = SetPathValue("sub.num", 7, &c)
+ if err != nil {
+ panic(err)
+ }
+ if c.Sub.Num != 7 {
+ t.Errorf("expected: s.Sub.Num should be 7")
+ }
+
+ c = Collection{}
+ err = SetPathValue("dict.cat", "meow", &c)
+ if err != nil {
+ panic(err)
+ }
+ if c.Dict["cat"] != "meow" {
+ t.Errorf("expected: s.Dict[\"cat\"] should be \"meow\"")
+ }
+
+ // Don't allocate a new map.
+ err = SetPathValue("dict.dog", "bark", &c)
+ if err != nil {
+ panic(err)
+ }
+ if c.Dict["cat"] != "meow" {
+ t.Errorf("expected: s.Dict[\"cat\"] should be \"meow\"")
+ }
+ if c.Dict["dog"] != "bark" {
+ t.Errorf("expected: s.Dict[\"dog\"] should be \"bark\"")
+ }
+
+ s := &SubElement{}
+ err = SetPathValue("things.eel", "zap", &s)
+ if err != nil {
+ panic(err)
+ }
+ if (*s.Things)["eel"] != "zap" {
+ t.Errorf("expected: c.Things[\"eel\"] should be \"zap\"")
+ }
+
+ // Don't allocate a new map.
+ err = SetPathValue("things.frog", "ribbit", &s)
+ if err != nil {
+ panic(err)
+ }
+ if (*s.Things)["eel"] != "zap" {
+ t.Errorf("expected: c.Things[\"eel\"] should be \"zap\"")
+ }
+ if (*s.Things)["frog"] != "ribbit" {
+ t.Errorf("expected: c.Things[\"frog\"] should be \"ribbit\"")
+ }
+}

cmd/config.go

@@ -6,7 +6,6 @@ import (
  "os"
  "strings"
 
- "github.com/ghodss/yaml"
  "github.com/qri-io/ioes"
  "github.com/qri-io/qri/config"
  "github.com/qri-io/qri/lib"
@@ -179,8 +178,9 @@ func (o *ConfigOptions) Set(args []string) (err error) {
  profileChanged := false
 
  for i := 0; i < len(args)-1; i = i + 2 {
- var value interface{}
  path := strings.ToLower(args[i])
+ value := args[i+1]
+
  if ip[path] {
  ErrExit(o.ErrOut, fmt.Errorf("cannot set path %s", path))
  }
@@ -196,10 +196,6 @@ func (o *ConfigOptions) Set(args []string) (err error) {
  }
  profileChanged = true
  } else {
- if err = yaml.Unmarshal([]byte(args[i+1]), &value); err != nil {
- return err
- }
-
  if err = lib.Config.Set(path, value); err != nil {
  return err
  }