tech: ignore /data folder for dep

Gopkg.lock

@@ -43,12 +43,6 @@
   packages = ["quantile"]
   revision = "4c0e84591b9aa9e6dcfdf3e020114cd81f89d5f9"
 
-[[projects]]
-  name = "github.com/bitly/go-simplejson"
-  packages = ["."]
-  revision = "aabad6e819789e569bd6aabf444c935aa9ba1e44"
-  version = "v0.5.0"
-
 [[projects]]
   branch = "master"
   name = "github.com/bmizerany/assert"
@@ -474,6 +468,6 @@
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
-  inputs-digest = "1824c50aa4685fb22643ab89d45457238d9e6c8f7980315c2a41bb35222ea1a7"
+  inputs-digest = "dbc036f87b80a8874e6df839df1dea4c18898cf23a147b1183da986621a5c43e"
   solver-name = "gps-cdcl"
   solver-version = 1

Gopkg.toml

@@ -1,4 +1,3 @@
-
 # Gopkg.toml example
 #
 # Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
@@ -20,6 +19,7 @@
 #  name = "github.com/x/y"
 #  version = "2.4.0"
 
+ignored = ["github.com/grafana/grafana/data/*"]
 
 [[constraint]]
   name = "github.com/BurntSushi/toml"
@@ -38,10 +38,6 @@
   branch = "master"
   name = "github.com/benbjohnson/clock"
 
-[[constraint]]
-  name = "github.com/bitly/go-simplejson"
-  version = "0.5.0"
-
 [[constraint]]
   branch = "master"
   name = "github.com/bmizerany/assert"
@@ -174,7 +170,7 @@
 
 [[constraint]]
   name = "gopkg.in/gomail.v2"
-  branch = "v2" 
+  branch = "v2"
 
 [[constraint]]
   name = "gopkg.in/ini.v1"
@@ -190,5 +186,5 @@
 
 [prune]
   non-go = true
-  test-go = true
+  #go-tests = true
   unused-packages = true

vendor/github.com/bitly/go-simplejson/LICENSE

@@ -1,17 +0,0 @@
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

vendor/github.com/bitly/go-simplejson/README.md

@@ -1,13 +0,0 @@
-### go-simplejson
-
-a Go package to interact with arbitrary JSON
-
-[![Build Status](https://secure.travis-ci.org/bitly/go-simplejson.png)](http://travis-ci.org/bitly/go-simplejson)
-
-### Importing
-
-    import github.com/bitly/go-simplejson
-
-### Documentation
-
-Visit the docs on [gopkgdoc](http://godoc.org/github.com/bitly/go-simplejson)

vendor/github.com/bitly/go-simplejson/simplejson.go

@@ -1,446 +0,0 @@
-package simplejson
-
-import (
-	"encoding/json"
-	"errors"
-	"log"
-)
-
-// returns the current implementation version
-func Version() string {
-	return "0.5.0"
-}
-
-type Json struct {
-	data interface{}
-}
-
-// NewJson returns a pointer to a new `Json` object
-// after unmarshaling `body` bytes
-func NewJson(body []byte) (*Json, error) {
-	j := new(Json)
-	err := j.UnmarshalJSON(body)
-	if err != nil {
-		return nil, err
-	}
-	return j, nil
-}
-
-// New returns a pointer to a new, empty `Json` object
-func New() *Json {
-	return &Json{
-		data: make(map[string]interface{}),
-	}
-}
-
-// Interface returns the underlying data
-func (j *Json) Interface() interface{} {
-	return j.data
-}
-
-// Encode returns its marshaled data as `[]byte`
-func (j *Json) Encode() ([]byte, error) {
-	return j.MarshalJSON()
-}
-
-// EncodePretty returns its marshaled data as `[]byte` with indentation
-func (j *Json) EncodePretty() ([]byte, error) {
-	return json.MarshalIndent(&j.data, "", "  ")
-}
-
-// Implements the json.Marshaler interface.
-func (j *Json) MarshalJSON() ([]byte, error) {
-	return json.Marshal(&j.data)
-}
-
-// Set modifies `Json` map by `key` and `value`
-// Useful for changing single key/value in a `Json` object easily.
-func (j *Json) Set(key string, val interface{}) {
-	m, err := j.Map()
-	if err != nil {
-		return
-	}
-	m[key] = val
-}
-
-// SetPath modifies `Json`, recursively checking/creating map keys for the supplied path,
-// and then finally writing in the value
-func (j *Json) SetPath(branch []string, val interface{}) {
-	if len(branch) == 0 {
-		j.data = val
-		return
-	}
-
-	// in order to insert our branch, we need map[string]interface{}
-	if _, ok := (j.data).(map[string]interface{}); !ok {
-		// have to replace with something suitable
-		j.data = make(map[string]interface{})
-	}
-	curr := j.data.(map[string]interface{})
-
-	for i := 0; i < len(branch)-1; i++ {
-		b := branch[i]
-		// key exists?
-		if _, ok := curr[b]; !ok {
-			n := make(map[string]interface{})
-			curr[b] = n
-			curr = n
-			continue
-		}
-
-		// make sure the value is the right sort of thing
-		if _, ok := curr[b].(map[string]interface{}); !ok {
-			// have to replace with something suitable
-			n := make(map[string]interface{})
-			curr[b] = n
-		}
-
-		curr = curr[b].(map[string]interface{})
-	}
-
-	// add remaining k/v
-	curr[branch[len(branch)-1]] = val
-}
-
-// Del modifies `Json` map by deleting `key` if it is present.
-func (j *Json) Del(key string) {
-	m, err := j.Map()
-	if err != nil {
-		return
-	}
-	delete(m, key)
-}
-
-// Get returns a pointer to a new `Json` object
-// for `key` in its `map` representation
-//
-// useful for chaining operations (to traverse a nested JSON):
-//    js.Get("top_level").Get("dict").Get("value").Int()
-func (j *Json) Get(key string) *Json {
-	m, err := j.Map()
-	if err == nil {
-		if val, ok := m[key]; ok {
-			return &Json{val}
-		}
-	}
-	return &Json{nil}
-}
-
-// GetPath searches for the item as specified by the branch
-// without the need to deep dive using Get()'s.
-//
-//   js.GetPath("top_level", "dict")
-func (j *Json) GetPath(branch ...string) *Json {
-	jin := j
-	for _, p := range branch {
-		jin = jin.Get(p)
-	}
-	return jin
-}
-
-// GetIndex returns a pointer to a new `Json` object
-// for `index` in its `array` representation
-//
-// this is the analog to Get when accessing elements of
-// a json array instead of a json object:
-//    js.Get("top_level").Get("array").GetIndex(1).Get("key").Int()
-func (j *Json) GetIndex(index int) *Json {
-	a, err := j.Array()
-	if err == nil {
-		if len(a) > index {
-			return &Json{a[index]}
-		}
-	}
-	return &Json{nil}
-}
-
-// CheckGet returns a pointer to a new `Json` object and
-// a `bool` identifying success or failure
-//
-// useful for chained operations when success is important:
-//    if data, ok := js.Get("top_level").CheckGet("inner"); ok {
-//        log.Println(data)
-//    }
-func (j *Json) CheckGet(key string) (*Json, bool) {
-	m, err := j.Map()
-	if err == nil {
-		if val, ok := m[key]; ok {
-			return &Json{val}, true
-		}
-	}
-	return nil, false
-}
-
-// Map type asserts to `map`
-func (j *Json) Map() (map[string]interface{}, error) {
-	if m, ok := (j.data).(map[string]interface{}); ok {
-		return m, nil
-	}
-	return nil, errors.New("type assertion to map[string]interface{} failed")
-}
-
-// Array type asserts to an `array`
-func (j *Json) Array() ([]interface{}, error) {
-	if a, ok := (j.data).([]interface{}); ok {
-		return a, nil
-	}
-	return nil, errors.New("type assertion to []interface{} failed")
-}
-
-// Bool type asserts to `bool`
-func (j *Json) Bool() (bool, error) {
-	if s, ok := (j.data).(bool); ok {
-		return s, nil
-	}
-	return false, errors.New("type assertion to bool failed")
-}
-
-// String type asserts to `string`
-func (j *Json) String() (string, error) {
-	if s, ok := (j.data).(string); ok {
-		return s, nil
-	}
-	return "", errors.New("type assertion to string failed")
-}
-
-// Bytes type asserts to `[]byte`
-func (j *Json) Bytes() ([]byte, error) {
-	if s, ok := (j.data).(string); ok {
-		return []byte(s), nil
-	}
-	return nil, errors.New("type assertion to []byte failed")
-}
-
-// StringArray type asserts to an `array` of `string`
-func (j *Json) StringArray() ([]string, error) {
-	arr, err := j.Array()
-	if err != nil {
-		return nil, err
-	}
-	retArr := make([]string, 0, len(arr))
-	for _, a := range arr {
-		if a == nil {
-			retArr = append(retArr, "")
-			continue
-		}
-		s, ok := a.(string)
-		if !ok {
-			return nil, err
-		}
-		retArr = append(retArr, s)
-	}
-	return retArr, nil
-}
-
-// MustArray guarantees the return of a `[]interface{}` (with optional default)
-//
-// useful when you want to interate over array values in a succinct manner:
-//		for i, v := range js.Get("results").MustArray() {
-//			fmt.Println(i, v)
-//		}
-func (j *Json) MustArray(args ...[]interface{}) []interface{} {
-	var def []interface{}
-
-	switch len(args) {
-	case 0:
-	case 1:
-		def = args[0]
-	default:
-		log.Panicf("MustArray() received too many arguments %d", len(args))
-	}
-
-	a, err := j.Array()
-	if err == nil {
-		return a
-	}
-
-	return def
-}
-
-// MustMap guarantees the return of a `map[string]interface{}` (with optional default)
-//
-// useful when you want to interate over map values in a succinct manner:
-//		for k, v := range js.Get("dictionary").MustMap() {
-//			fmt.Println(k, v)
-//		}
-func (j *Json) MustMap(args ...map[string]interface{}) map[string]interface{} {
-	var def map[string]interface{}
-
-	switch len(args) {
-	case 0:
-	case 1:
-		def = args[0]
-	default:
-		log.Panicf("MustMap() received too many arguments %d", len(args))
-	}
-
-	a, err := j.Map()
-	if err == nil {
-		return a
-	}
-
-	return def
-}
-
-// MustString guarantees the return of a `string` (with optional default)
-//
-// useful when you explicitly want a `string` in a single value return context:
-//     myFunc(js.Get("param1").MustString(), js.Get("optional_param").MustString("my_default"))
-func (j *Json) MustString(args ...string) string {
-	var def string
-
-	switch len(args) {
-	case 0:
-	case 1:
-		def = args[0]
-	default:
-		log.Panicf("MustString() received too many arguments %d", len(args))
-	}
-
-	s, err := j.String()
-	if err == nil {
-		return s
-	}
-
-	return def
-}
-
-// MustStringArray guarantees the return of a `[]string` (with optional default)
-//
-// useful when you want to interate over array values in a succinct manner:
-//		for i, s := range js.Get("results").MustStringArray() {
-//			fmt.Println(i, s)
-//		}
-func (j *Json) MustStringArray(args ...[]string) []string {
-	var def []string
-
-	switch len(args) {
-	case 0:
-	case 1:
-		def = args[0]
-	default:
-		log.Panicf("MustStringArray() received too many arguments %d", len(args))
-	}
-
-	a, err := j.StringArray()
-	if err == nil {
-		return a
-	}
-
-	return def
-}
-
-// MustInt guarantees the return of an `int` (with optional default)
-//
-// useful when you explicitly want an `int` in a single value return context:
-//     myFunc(js.Get("param1").MustInt(), js.Get("optional_param").MustInt(5150))
-func (j *Json) MustInt(args ...int) int {
-	var def int
-
-	switch len(args) {
-	case 0:
-	case 1:
-		def = args[0]
-	default:
-		log.Panicf("MustInt() received too many arguments %d", len(args))
-	}
-
-	i, err := j.Int()
-	if err == nil {
-		return i
-	}
-
-	return def
-}
-
-// MustFloat64 guarantees the return of a `float64` (with optional default)
-//
-// useful when you explicitly want a `float64` in a single value return context:
-//     myFunc(js.Get("param1").MustFloat64(), js.Get("optional_param").MustFloat64(5.150))
-func (j *Json) MustFloat64(args ...float64) float64 {
-	var def float64
-
-	switch len(args) {
-	case 0:
-	case 1:
-		def = args[0]
-	default:
-		log.Panicf("MustFloat64() received too many arguments %d", len(args))
-	}
-
-	f, err := j.Float64()
-	if err == nil {
-		return f
-	}
-
-	return def
-}
-
-// MustBool guarantees the return of a `bool` (with optional default)
-//
-// useful when you explicitly want a `bool` in a single value return context:
-//     myFunc(js.Get("param1").MustBool(), js.Get("optional_param").MustBool(true))
-func (j *Json) MustBool(args ...bool) bool {
-	var def bool
-
-	switch len(args) {
-	case 0:
-	case 1:
-		def = args[0]
-	default:
-		log.Panicf("MustBool() received too many arguments %d", len(args))
-	}
-
-	b, err := j.Bool()
-	if err == nil {
-		return b
-	}
-
-	return def
-}
-
-// MustInt64 guarantees the return of an `int64` (with optional default)
-//
-// useful when you explicitly want an `int64` in a single value return context:
-//     myFunc(js.Get("param1").MustInt64(), js.Get("optional_param").MustInt64(5150))
-func (j *Json) MustInt64(args ...int64) int64 {
-	var def int64
-
-	switch len(args) {
-	case 0:
-	case 1:
-		def = args[0]
-	default:
-		log.Panicf("MustInt64() received too many arguments %d", len(args))
-	}
-
-	i, err := j.Int64()
-	if err == nil {
-		return i
-	}
-
-	return def
-}
-
-// MustUInt64 guarantees the return of an `uint64` (with optional default)
-//
-// useful when you explicitly want an `uint64` in a single value return context:
-//     myFunc(js.Get("param1").MustUint64(), js.Get("optional_param").MustUint64(5150))
-func (j *Json) MustUint64(args ...uint64) uint64 {
-	var def uint64
-
-	switch len(args) {
-	case 0:
-	case 1:
-		def = args[0]
-	default:
-		log.Panicf("MustUint64() received too many arguments %d", len(args))
-	}
-
-	i, err := j.Uint64()
-	if err == nil {
-		return i
-	}
-
-	return def
-}

vendor/github.com/bitly/go-simplejson/simplejson_go10.go

@@ -1,75 +0,0 @@
-// +build !go1.1
-
-package simplejson
-
-import (
-	"encoding/json"
-	"errors"
-	"io"
-	"reflect"
-)
-
-// NewFromReader returns a *Json by decoding from an io.Reader
-func NewFromReader(r io.Reader) (*Json, error) {
-	j := new(Json)
-	dec := json.NewDecoder(r)
-	err := dec.Decode(&j.data)
-	return j, err
-}
-
-// Implements the json.Unmarshaler interface.
-func (j *Json) UnmarshalJSON(p []byte) error {
-	return json.Unmarshal(p, &j.data)
-}
-
-// Float64 coerces into a float64
-func (j *Json) Float64() (float64, error) {
-	switch j.data.(type) {
-	case float32, float64:
-		return reflect.ValueOf(j.data).Float(), nil
-	case int, int8, int16, int32, int64:
-		return float64(reflect.ValueOf(j.data).Int()), nil
-	case uint, uint8, uint16, uint32, uint64:
-		return float64(reflect.ValueOf(j.data).Uint()), nil
-	}
-	return 0, errors.New("invalid value type")
-}
-
-// Int coerces into an int
-func (j *Json) Int() (int, error) {
-	switch j.data.(type) {
-	case float32, float64:
-		return int(reflect.ValueOf(j.data).Float()), nil
-	case int, int8, int16, int32, int64:
-		return int(reflect.ValueOf(j.data).Int()), nil
-	case uint, uint8, uint16, uint32, uint64:
-		return int(reflect.ValueOf(j.data).Uint()), nil
-	}
-	return 0, errors.New("invalid value type")
-}
-
-// Int64 coerces into an int64
-func (j *Json) Int64() (int64, error) {
-	switch j.data.(type) {
-	case float32, float64:
-		return int64(reflect.ValueOf(j.data).Float()), nil
-	case int, int8, int16, int32, int64:
-		return reflect.ValueOf(j.data).Int(), nil
-	case uint, uint8, uint16, uint32, uint64:
-		return int64(reflect.ValueOf(j.data).Uint()), nil
-	}
-	return 0, errors.New("invalid value type")
-}
-
-// Uint64 coerces into an uint64
-func (j *Json) Uint64() (uint64, error) {
-	switch j.data.(type) {
-	case float32, float64:
-		return uint64(reflect.ValueOf(j.data).Float()), nil
-	case int, int8, int16, int32, int64:
-		return uint64(reflect.ValueOf(j.data).Int()), nil
-	case uint, uint8, uint16, uint32, uint64:
-		return reflect.ValueOf(j.data).Uint(), nil
-	}
-	return 0, errors.New("invalid value type")
-}

vendor/github.com/bitly/go-simplejson/simplejson_go11.go

@@ -1,89 +0,0 @@
-// +build go1.1
-
-package simplejson
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"io"
-	"reflect"
-	"strconv"
-)
-
-// Implements the json.Unmarshaler interface.
-func (j *Json) UnmarshalJSON(p []byte) error {
-	dec := json.NewDecoder(bytes.NewBuffer(p))
-	dec.UseNumber()
-	return dec.Decode(&j.data)
-}
-
-// NewFromReader returns a *Json by decoding from an io.Reader
-func NewFromReader(r io.Reader) (*Json, error) {
-	j := new(Json)
-	dec := json.NewDecoder(r)
-	dec.UseNumber()
-	err := dec.Decode(&j.data)
-	return j, err
-}
-
-// Float64 coerces into a float64
-func (j *Json) Float64() (float64, error) {
-	switch j.data.(type) {
-	case json.Number:
-		return j.data.(json.Number).Float64()
-	case float32, float64:
-		return reflect.ValueOf(j.data).Float(), nil
-	case int, int8, int16, int32, int64:
-		return float64(reflect.ValueOf(j.data).Int()), nil
-	case uint, uint8, uint16, uint32, uint64:
-		return float64(reflect.ValueOf(j.data).Uint()), nil
-	}
-	return 0, errors.New("invalid value type")
-}
-
-// Int coerces into an int
-func (j *Json) Int() (int, error) {
-	switch j.data.(type) {
-	case json.Number:
-		i, err := j.data.(json.Number).Int64()
-		return int(i), err
-	case float32, float64:
-		return int(reflect.ValueOf(j.data).Float()), nil
-	case int, int8, int16, int32, int64:
-		return int(reflect.ValueOf(j.data).Int()), nil
-	case uint, uint8, uint16, uint32, uint64:
-		return int(reflect.ValueOf(j.data).Uint()), nil
-	}
-	return 0, errors.New("invalid value type")
-}
-
-// Int64 coerces into an int64
-func (j *Json) Int64() (int64, error) {
-	switch j.data.(type) {
-	case json.Number:
-		return j.data.(json.Number).Int64()
-	case float32, float64:
-		return int64(reflect.ValueOf(j.data).Float()), nil
-	case int, int8, int16, int32, int64:
-		return reflect.ValueOf(j.data).Int(), nil
-	case uint, uint8, uint16, uint32, uint64:
-		return int64(reflect.ValueOf(j.data).Uint()), nil
-	}
-	return 0, errors.New("invalid value type")
-}
-
-// Uint64 coerces into an uint64
-func (j *Json) Uint64() (uint64, error) {
-	switch j.data.(type) {
-	case json.Number:
-		return strconv.ParseUint(j.data.(json.Number).String(), 10, 64)
-	case float32, float64:
-		return uint64(reflect.ValueOf(j.data).Float()), nil
-	case int, int8, int16, int32, int64:
-		return uint64(reflect.ValueOf(j.data).Int()), nil
-	case uint, uint8, uint16, uint32, uint64:
-		return reflect.ValueOf(j.data).Uint(), nil
-	}
-	return 0, errors.New("invalid value type")
-}