• As a fix for https://github.com/spf13/viper/issues/451 , this PR adds support for casting map types from JSON strings. This allows viper to support binding environment variables for more types. This uses the stdlib's encoding/json package for unmarshalling the data and bubbles up unmarshalling errors to the caller.
• Add test cases to all map casting methods to test this feature
• Add test cases to TestToDurationSliceE in order to reach 100% total coverage for the lib

• [x] added benchmarks
• [x] use predefined errUnableToCast instead of fmt.Errorf
• [x] fixed golint

before:

go test -bench=.
goos: darwin
goarch: amd64
pkg: github.com/yanmhlv/cast
BenchmarkTooBool/valid_bool(true)-4         	200000000	         8.25 ns/op	       0 B/op	       0 allocs/op
BenchmarkTooBool/valid_bool(1)-4            	200000000	         8.36 ns/op	       0 B/op	       0 allocs/op
BenchmarkTooBool/invalid_bool("xxx")-4      	30000000	        45.1 ns/op	      48 B/op	       1 allocs/op
BenchmarkTooBool/invalid_bool(1.0)-4        	 5000000	       302 ns/op	      96 B/op	       3 allocs/op
PASS

after:

goos: darwin
goarch: amd64
pkg: github.com/yanmhlv/cast
BenchmarkTooBool/valid_bool(true)-4         	200000000	         8.03 ns/op	       0 B/op	       0 allocs/op
BenchmarkTooBool/valid_bool(1)-4            	200000000	         8.20 ns/op	       0 B/op	       0 allocs/op
BenchmarkTooBool/invalid_bool("xxx")-4      	30000000	        44.8 ns/op	      48 B/op	       1 allocs/op
BenchmarkTooBool/invalid_bool(1.0)-4        	20000000	        76.0 ns/op	     112 B/op	       2 allocs/op
PASS

I notice that the Hugo use this project to convert the string to time.Time. When I migrate to Hugo from Hexo (another static blog generator). The Hugo said :

page.go:750: Failed to parse date '2016-03-06 15:28:01' in page xxxxx.md

I hope you can merge this Pull request, so that those people who migrate to Hugo from Hexo are easy to use Hugo to generate the static blog.

Thanks. ^_^

Go's time parsing uses UTC when the format doesn't have a timezone, and has even weirder behavior when it has a zone name but no numeric offset. A caller to cast.ToTime cannot know if the returned time was explicitly in UTC or was set by default, so they cannot fix it. These new functions allow a user to supply a different timezone to default to, with nil using the local zone.

This addresses spf13/hugo#1882 by allowing that code to use cast.ToTimeInDefaultLocation(raw, nil).

A note on the implementation: It's not possible to use time.ParseInLocation because parsing with a format that has a named zone but no numeric offset (such as time.RC1123Z) returns a time with a 0 offset in that name iff that's not the current local timezone (!!). You can verify this by changing like 521 to use time.ParseInLocation(format.format, s, defaultLocation) and commenting out the manual override in the body of the if clause – tests will fail.

I think the root cause is that the time pkg has two parsing functions: time.Parse and time.ParseInLocation, both of which use a private workhorse fn time.parse. That private fn takes two zones: a default and what's considered "local". I'm not sure, but I think in order to get the effect we want, we'd need to call that fn with our default and the current local zone. However, time.Parse uses default of UTC, whereas time.ParseInLocation uses the given zone for both default & local.

This should fix #15 and from my personal testing works. I did notice there is no test method for a ToStringMapString so I didn't add a test for ToStringMapStringSlice. Having a ToStringMapString test would have been nice to follow/modify for a TestToStringMapStringSlice function.

This fixes passing map[string]interface{} with the map containing multiple strings. Previously the result is a slice with an empty string in it.

I discovered when using https://github.com/spf13/viper with the following:

{
  "key": [
    "val1",
    "val2"
  ]
}

Viper resolved this to map[string]interface{} and the val key became []string{""}

Casting an interface{} of type bool to string was missing. So added with this PR.

s,err := ToStringE(true)
fmt.Printf("%q Err: %s",s,err)
// Output: "true" Err:

A strange error occurs when I use toString. The example code is as follows:

package main

import (
	"fmt"
	"github.com/spf13/cast"
)
type NewString string

func main() {
	var test NewString
	test = "this is a test string"
	fmt.Println("original: ",test)
	fmt.Println("use string() func: ",string(test))
	fmt.Println("use cast.ToString() func: ",cast.ToString(test))
	fmt.Println(cast.ToString(test)=="")
}

Output:

original:  this is a test string
use string() func:  this is a test string
use cast.ToString() func:  
true

Adds a form to handle the common format strftime("%FT%T%z"), which omits the (optional) colon from the timezone. Also adds a matching T-omitted form.

https://github.com/spf13/cast/blob/2b0eb0f724e320b655240e331aef36d1175986c2/caste.go#L903 when i define a type as: type InstStatus string this cast.toString() API cannot work cause 「indirectToStringerOrErrorand」will not get the type's Elem with reflect package API, it will turn to default branch and the result is ""

What does this MR does?

Create ToInt64SliceE and ToInt64Slice method to support int64 slice casting;

How to test?

• Run the unit tests:

go test -v  -run TestToInt64SliceE .

• Test code:

input := []interface{}{1.2, 3.2}
v = ToInt64Slice(input)
fmt.Println(v)

I'd expect this test to pass:

func TestToFloat64NamedType(t *testing.T) {
	type X float64
	f := ToFloat64(X(2))
	if f != 2.0 {
		t.Fatalf("want %#v, got %#v", 2.0, f)
	}
}

The fix is pretty easy. Near the beginning of ToFloat64E, just after the call to indirect, add something like:

	v := reflect.ValueOf(i)
	if v.CanFloat() {
		return v.Float(), nil
	}

I'm filing an issue rather than sending a PR because the proper fix applies this to all conversions, not just floats, and that's a pretty substantive change, so I wanted to discuss first.

version: 1.5 1.3

test.proto

enum N {
   DEFAULT = 0;
   ONE =  1;
}

message Test {
    N  num  = 1;
}

main.go

a := &pb.Test{ Num:  123 }

cast.toInt32(a)   //return 0
int32(a)   //return 123

parser string to int64 should use strconv.ParseInt(trimZeroDecimal(s), 10, 64) not the follow; v, err := strconv.ParseInt(trimZeroDecimal(s), 0, 0) if err == nil { return v, nil }

func ToUint64E(i interface{}) (uint64, error) use the v, err := strconv.ParseInt(trimZeroDecimal(s), 0, 0) error:strconv.ParseInt: parsing "11166014772858028509": value out of range unable to cast "11166014772858028509" of type string to uint64

case string: v, err := strconv.ParseInt(trimZeroDecimal(s), 0, 0) if err == nil { if v < 0 { return 0, errNegativeNotAllowed } return uint64(v), nil } return 0, fmt.Errorf("unable to cast %#v of type %T to uint64", i, i)

// You can edit this code!
// Click here and start typing.
package main

import (
	"fmt"

	"github.com/spf13/cast"
)

type Hoge = string
type Fuga string

func main() {
	h := Hoge("hoge")
	f := Fuga("fuga")
	fmt.Println(h, f)
	fmt.Println(cast.ToString(h), cast.ToString(f))
}

// output
hoge fuga
hoge