2 | //
3 | // Permission to use, copy, modify, and distribute this software for any
4 | // purpose with or without fee is hereby granted, provided that the above
5 | // copyright notice and this permission notice appear in all copies.
6 | //
7 | // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
8 | // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
9 | // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
10 | // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
11 | // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
12 | // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
13 | // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
14 |
15 | // NOTE: Due to the following build constraints, this file will only be compiled
16 | // when the code is running on Google App Engine, compiled by GopherJS, or
17 | // "-tags safe" is added to the go build command line. The "disableunsafe"
18 | // tag is deprecated and thus should not be used.
19 | // +build js appengine safe disableunsafe
20 |
21 | package spew
22 |
23 | import "reflect"
24 |
25 | const (
26 | // UnsafeDisabled is a build-time constant which specifies whether or
27 | // not access to the unsafe package is available.
28 | UnsafeDisabled = true
29 | )
30 |
31 | // unsafeReflectValue typically converts the passed reflect.Value into a one
32 | // that bypasses the typical safety restrictions preventing access to
33 | // unaddressable and unexported data. However, doing this relies on access to
34 | // the unsafe package. This is a stub version which simply returns the passed
35 | // reflect.Value when the unsafe package is not available.
36 | func unsafeReflectValue(v reflect.Value) reflect.Value {
37 | return v
38 | }
39 |
--------------------------------------------------------------------------------
/vendor/github.com/fatih/camelcase/.travis.yml:
--------------------------------------------------------------------------------
1 | language: go
2 | go: 1.x
3 |
4 |
--------------------------------------------------------------------------------
/vendor/github.com/fatih/camelcase/LICENSE.md:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 |
3 | Copyright (c) 2015 Fatih Arslan
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
6 | this software and associated documentation files (the "Software"), to deal in
7 | the Software without restriction, including without limitation the rights to
8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 |
--------------------------------------------------------------------------------
/vendor/github.com/fatih/camelcase/README.md:
--------------------------------------------------------------------------------
1 | # CamelCase [](http://godoc.org/github.com/fatih/camelcase) [](https://travis-ci.org/fatih/camelcase)
2 |
3 | CamelCase is a Golang (Go) package to split the words of a camelcase type
4 | string into a slice of words. It can be used to convert a camelcase word (lower
5 | or upper case) into any type of word.
6 |
7 | ## Splitting rules:
8 |
9 | 1. If string is not valid UTF-8, return it without splitting as
10 | single item array.
11 | 2. Assign all unicode characters into one of 4 sets: lower case
12 | letters, upper case letters, numbers, and all other characters.
13 | 3. Iterate through characters of string, introducing splits
14 | between adjacent characters that belong to different sets.
15 | 4. Iterate through array of split strings, and if a given string
16 | is upper case:
17 | * if subsequent string is lower case:
18 | * move last character of upper case string to beginning of
19 | lower case string
20 |
21 | ## Install
22 |
23 | ```bash
24 | go get github.com/fatih/camelcase
25 | ```
26 |
27 | ## Usage and examples
28 |
29 | ```go
30 | splitted := camelcase.Split("GolangPackage")
31 |
32 | fmt.Println(splitted[0], splitted[1]) // prints: "Golang", "Package"
33 | ```
34 |
35 | Both lower camel case and upper camel case are supported. For more info please
36 | check: [http://en.wikipedia.org/wiki/CamelCase](http://en.wikipedia.org/wiki/CamelCase)
37 |
38 | Below are some example cases:
39 |
40 | ```
41 | "" => []
42 | "lowercase" => ["lowercase"]
43 | "Class" => ["Class"]
44 | "MyClass" => ["My", "Class"]
45 | "MyC" => ["My", "C"]
46 | "HTML" => ["HTML"]
47 | "PDFLoader" => ["PDF", "Loader"]
48 | "AString" => ["A", "String"]
49 | "SimpleXMLParser" => ["Simple", "XML", "Parser"]
50 | "vimRPCPlugin" => ["vim", "RPC", "Plugin"]
51 | "GL11Version" => ["GL", "11", "Version"]
52 | "99Bottles" => ["99", "Bottles"]
53 | "May5" => ["May", "5"]
54 | "BFG9000" => ["BFG", "9000"]
55 | "BöseÜberraschung" => ["Böse", "Überraschung"]
56 | "Two spaces" => ["Two", " ", "spaces"]
57 | "BadUTF8\xe2\xe2\xa1" => ["BadUTF8\xe2\xe2\xa1"]
58 | ```
59 |
--------------------------------------------------------------------------------
/vendor/github.com/fatih/structs/.gitignore:
--------------------------------------------------------------------------------
1 | # Compiled Object files, Static and Dynamic libs (Shared Objects)
2 | *.o
3 | *.a
4 | *.so
5 |
6 | # Folders
7 | _obj
8 | _test
9 |
10 | # Architecture specific extensions/prefixes
11 | *.[568vq]
12 | [568vq].out
13 |
14 | *.cgo1.go
15 | *.cgo2.c
16 | _cgo_defun.c
17 | _cgo_gotypes.go
18 | _cgo_export.*
19 |
20 | _testmain.go
21 |
22 | *.exe
23 | *.test
24 |
--------------------------------------------------------------------------------
/vendor/github.com/fatih/structs/.travis.yml:
--------------------------------------------------------------------------------
1 | language: go
2 | go:
3 | - 1.7.x
4 | - tip
5 | sudo: false
6 | before_install:
7 | - go get github.com/axw/gocov/gocov
8 | - go get github.com/mattn/goveralls
9 | - if ! go get github.com/golang/tools/cmd/cover; then go get golang.org/x/tools/cmd/cover; fi
10 | script:
11 | - $HOME/gopath/bin/goveralls -service=travis-ci
12 |
--------------------------------------------------------------------------------
/vendor/github.com/fatih/structs/LICENSE:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 |
3 | Copyright (c) 2014 Fatih Arslan
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
--------------------------------------------------------------------------------
/vendor/github.com/fatih/structs/tags.go:
--------------------------------------------------------------------------------
1 | package structs
2 |
3 | import "strings"
4 |
5 | // tagOptions contains a slice of tag options
6 | type tagOptions []string
7 |
8 | // Has returns true if the given optiton is available in tagOptions
9 | func (t tagOptions) Has(opt string) bool {
10 | for _, tagOpt := range t {
11 | if tagOpt == opt {
12 | return true
13 | }
14 | }
15 |
16 | return false
17 | }
18 |
19 | // parseTag splits a struct field's tag into its name and a list of options
20 | // which comes after a name. A tag is in the form of: "name,option1,option2".
21 | // The name can be neglectected.
22 | func parseTag(tag string) (string, tagOptions) {
23 | // tag is one of followings:
24 | // ""
25 | // "name"
26 | // "name,opt"
27 | // "name,opt,opt2"
28 | // ",opt"
29 |
30 | res := strings.Split(tag, ",")
31 | return res[0], res[1:]
32 | }
33 |
--------------------------------------------------------------------------------
/vendor/github.com/go-sql-driver/mysql/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | .DS_Store?
3 | ._*
4 | .Spotlight-V100
5 | .Trashes
6 | Icon?
7 | ehthumbs.db
8 | Thumbs.db
9 | .idea
10 |
--------------------------------------------------------------------------------
/vendor/github.com/go-sql-driver/mysql/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | # Contributing Guidelines
2 |
3 | ## Reporting Issues
4 |
5 | Before creating a new Issue, please check first if a similar Issue [already exists](https://github.com/go-sql-driver/mysql/issues?state=open) or was [recently closed](https://github.com/go-sql-driver/mysql/issues?direction=desc&page=1&sort=updated&state=closed).
6 |
7 | ## Contributing Code
8 |
9 | By contributing to this project, you share your code under the Mozilla Public License 2, as specified in the LICENSE file.
10 | Don't forget to add yourself to the AUTHORS file.
11 |
12 | ### Code Review
13 |
14 | Everyone is invited to review and comment on pull requests.
15 | If it looks fine to you, comment with "LGTM" (Looks good to me).
16 |
17 | If changes are required, notice the reviewers with "PTAL" (Please take another look) after committing the fixes.
18 |
19 | Before merging the Pull Request, at least one [team member](https://github.com/go-sql-driver?tab=members) must have commented with "LGTM".
20 |
21 | ## Development Ideas
22 |
23 | If you are looking for ideas for code contributions, please check our [Development Ideas](https://github.com/go-sql-driver/mysql/wiki/Development-Ideas) Wiki page.
24 |
--------------------------------------------------------------------------------
/vendor/github.com/go-sql-driver/mysql/appengine.go:
--------------------------------------------------------------------------------
1 | // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
2 | //
3 | // Copyright 2013 The Go-MySQL-Driver Authors. All rights reserved.
4 | //
5 | // This Source Code Form is subject to the terms of the Mozilla Public
6 | // License, v. 2.0. If a copy of the MPL was not distributed with this file,
7 | // You can obtain one at http://mozilla.org/MPL/2.0/.
8 |
9 | // +build appengine
10 |
11 | package mysql
12 |
13 | import (
14 | "google.golang.org/appengine/cloudsql"
15 | )
16 |
17 | func init() {
18 | RegisterDial("cloudsql", cloudsql.Dial)
19 | }
20 |
--------------------------------------------------------------------------------
/vendor/github.com/go-sql-driver/mysql/result.go:
--------------------------------------------------------------------------------
1 | // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
2 | //
3 | // Copyright 2012 The Go-MySQL-Driver Authors. All rights reserved.
4 | //
5 | // This Source Code Form is subject to the terms of the Mozilla Public
6 | // License, v. 2.0. If a copy of the MPL was not distributed with this file,
7 | // You can obtain one at http://mozilla.org/MPL/2.0/.
8 |
9 | package mysql
10 |
11 | type mysqlResult struct {
12 | affectedRows int64
13 | insertId int64
14 | }
15 |
16 | func (res *mysqlResult) LastInsertId() (int64, error) {
17 | return res.insertId, nil
18 | }
19 |
20 | func (res *mysqlResult) RowsAffected() (int64, error) {
21 | return res.affectedRows, nil
22 | }
23 |
--------------------------------------------------------------------------------
/vendor/github.com/go-sql-driver/mysql/transaction.go:
--------------------------------------------------------------------------------
1 | // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
2 | //
3 | // Copyright 2012 The Go-MySQL-Driver Authors. All rights reserved.
4 | //
5 | // This Source Code Form is subject to the terms of the Mozilla Public
6 | // License, v. 2.0. If a copy of the MPL was not distributed with this file,
7 | // You can obtain one at http://mozilla.org/MPL/2.0/.
8 |
9 | package mysql
10 |
11 | type mysqlTx struct {
12 | mc *mysqlConn
13 | }
14 |
15 | func (tx *mysqlTx) Commit() (err error) {
16 | if tx.mc == nil || tx.mc.closed.IsSet() {
17 | return ErrInvalidConn
18 | }
19 | err = tx.mc.exec("COMMIT")
20 | tx.mc = nil
21 | return
22 | }
23 |
24 | func (tx *mysqlTx) Rollback() (err error) {
25 | if tx.mc == nil || tx.mc.closed.IsSet() {
26 | return ErrInvalidConn
27 | }
28 | err = tx.mc.exec("ROLLBACK")
29 | tx.mc = nil
30 | return
31 | }
32 |
--------------------------------------------------------------------------------
/vendor/github.com/go-sql-driver/mysql/utils_go17.go:
--------------------------------------------------------------------------------
1 | // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
2 | //
3 | // Copyright 2017 The Go-MySQL-Driver Authors. All rights reserved.
4 | //
5 | // This Source Code Form is subject to the terms of the Mozilla Public
6 | // License, v. 2.0. If a copy of the MPL was not distributed with this file,
7 | // You can obtain one at http://mozilla.org/MPL/2.0/.
8 |
9 | // +build go1.7
10 | // +build !go1.8
11 |
12 | package mysql
13 |
14 | import "crypto/tls"
15 |
16 | func cloneTLSConfig(c *tls.Config) *tls.Config {
17 | return &tls.Config{
18 | Rand: c.Rand,
19 | Time: c.Time,
20 | Certificates: c.Certificates,
21 | NameToCertificate: c.NameToCertificate,
22 | GetCertificate: c.GetCertificate,
23 | RootCAs: c.RootCAs,
24 | NextProtos: c.NextProtos,
25 | ServerName: c.ServerName,
26 | ClientAuth: c.ClientAuth,
27 | ClientCAs: c.ClientCAs,
28 | InsecureSkipVerify: c.InsecureSkipVerify,
29 | CipherSuites: c.CipherSuites,
30 | PreferServerCipherSuites: c.PreferServerCipherSuites,
31 | SessionTicketsDisabled: c.SessionTicketsDisabled,
32 | SessionTicketKey: c.SessionTicketKey,
33 | ClientSessionCache: c.ClientSessionCache,
34 | MinVersion: c.MinVersion,
35 | MaxVersion: c.MaxVersion,
36 | CurvePreferences: c.CurvePreferences,
37 | DynamicRecordSizingDisabled: c.DynamicRecordSizingDisabled,
38 | Renegotiation: c.Renegotiation,
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/vendor/github.com/go-sql-driver/mysql/utils_go18.go:
--------------------------------------------------------------------------------
1 | // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
2 | //
3 | // Copyright 2017 The Go-MySQL-Driver Authors. All rights reserved.
4 | //
5 | // This Source Code Form is subject to the terms of the Mozilla Public
6 | // License, v. 2.0. If a copy of the MPL was not distributed with this file,
7 | // You can obtain one at http://mozilla.org/MPL/2.0/.
8 |
9 | // +build go1.8
10 |
11 | package mysql
12 |
13 | import (
14 | "crypto/tls"
15 | "database/sql"
16 | "database/sql/driver"
17 | "errors"
18 | "fmt"
19 | )
20 |
21 | func cloneTLSConfig(c *tls.Config) *tls.Config {
22 | return c.Clone()
23 | }
24 |
25 | func namedValueToValue(named []driver.NamedValue) ([]driver.Value, error) {
26 | dargs := make([]driver.Value, len(named))
27 | for n, param := range named {
28 | if len(param.Name) > 0 {
29 | // TODO: support the use of Named Parameters #561
30 | return nil, errors.New("mysql: driver does not support the use of Named Parameters")
31 | }
32 | dargs[n] = param.Value
33 | }
34 | return dargs, nil
35 | }
36 |
37 | func mapIsolationLevel(level driver.IsolationLevel) (string, error) {
38 | switch sql.IsolationLevel(level) {
39 | case sql.LevelRepeatableRead:
40 | return "REPEATABLE READ", nil
41 | case sql.LevelReadCommitted:
42 | return "READ COMMITTED", nil
43 | case sql.LevelReadUncommitted:
44 | return "READ UNCOMMITTED", nil
45 | case sql.LevelSerializable:
46 | return "SERIALIZABLE", nil
47 | default:
48 | return "", fmt.Errorf("mysql: unsupported isolation level: %v", level)
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/CHANGELOG.md:
--------------------------------------------------------------------------------
1 | # Change log
2 |
3 | Not all minor changes may be noted here, but all large and/or breaking changes
4 | should be.
5 |
6 | ## v2.0 - 2015-10-09
7 |
8 | ### Added
9 | - PostgreSQL support!
10 | - `Open(driver, dsn string, log EventReceiver)` creates an underlying connection for you based on a supplied driver and dsn string
11 | - All builders are now available without a `Session` facilitating much more complex queries
12 | - More common SQL support: Subqueries, Unions, Joins, Aliases
13 | - More complex condition building support: And/Or/Eq/Neq/Gt/Gte/Lt/Lte
14 |
15 | ### Deprecated
16 | - `NewConnection` is deprecated. It assumes MySQL driver. Please use `Open` instead
17 |
18 | ### Changed
19 | - `NullTime` no longer relies on the mysql package. E.g. instead of `NullTime{mysql.NullTime{Time: t, Valid: true}}` it's now simply `NullTime{Time: t, Valid: true}`
20 | - All `*Builder` structs now embed a corresponding `*Stmt` struct (E.g. `SelectBuilder` embeds `SelectStmt`). All non-`Session` specific properies have been moved the `*Stmt` structs
21 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/LICENSE:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 |
3 | Copyright (c) 2014-2017 Jonathan Novak, Tai-Lin Chu
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
6 | this software and associated documentation files (the "Software"), to deal in
7 | the Software without restriction, including without limitation the rights to
8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/buffer.go:
--------------------------------------------------------------------------------
1 | package dbr
2 |
3 | import "bytes"
4 |
5 | type Buffer interface {
6 | WriteString(s string) (n int, err error)
7 | String() string
8 |
9 | WriteValue(v ...interface{}) (err error)
10 | Value() []interface{}
11 | }
12 |
13 | type buffer struct {
14 | bytes.Buffer
15 | v []interface{}
16 | }
17 |
18 | func NewBuffer() Buffer {
19 | return &buffer{}
20 | }
21 |
22 | func (b *buffer) WriteValue(v ...interface{}) error {
23 | b.v = append(b.v, v...)
24 | return nil
25 | }
26 |
27 | func (b *buffer) Value() []interface{} {
28 | return b.v
29 | }
30 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/builder.go:
--------------------------------------------------------------------------------
1 | package dbr
2 |
3 | // Builder builds sql in one dialect like MySQL/PostgreSQL
4 | // e.g. XxxBuilder
5 | type Builder interface {
6 | Build(Dialect, Buffer) error
7 | }
8 |
9 | type BuildFunc func(Dialect, Buffer) error
10 |
11 | func (b BuildFunc) Build(d Dialect, buf Buffer) error {
12 | return b(d, buf)
13 | }
14 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/delete.go:
--------------------------------------------------------------------------------
1 | package dbr
2 |
3 | // DeleteStmt builds `DELETE ...`
4 | type DeleteStmt struct {
5 | raw
6 |
7 | Table string
8 |
9 | WhereCond []Builder
10 | }
11 |
12 | // Build builds `DELETE ...` in dialect
13 | func (b *DeleteStmt) Build(d Dialect, buf Buffer) error {
14 | if b.raw.Query != "" {
15 | return b.raw.Build(d, buf)
16 | }
17 |
18 | if b.Table == "" {
19 | return ErrTableNotSpecified
20 | }
21 |
22 | buf.WriteString("DELETE FROM ")
23 | buf.WriteString(d.QuoteIdent(b.Table))
24 |
25 | if len(b.WhereCond) > 0 {
26 | buf.WriteString(" WHERE ")
27 | err := And(b.WhereCond...).Build(d, buf)
28 | if err != nil {
29 | return err
30 | }
31 | }
32 | return nil
33 | }
34 |
35 | // DeleteFrom creates a DeleteStmt
36 | func DeleteFrom(table string) *DeleteStmt {
37 | return &DeleteStmt{
38 | Table: table,
39 | }
40 | }
41 |
42 | // DeleteBySql creates a DeleteStmt from raw query
43 | func DeleteBySql(query string, value ...interface{}) *DeleteStmt {
44 | return &DeleteStmt{
45 | raw: raw{
46 | Query: query,
47 | Value: value,
48 | },
49 | }
50 | }
51 |
52 | // Where adds a where condition
53 | func (b *DeleteStmt) Where(query interface{}, value ...interface{}) *DeleteStmt {
54 | switch query := query.(type) {
55 | case string:
56 | b.WhereCond = append(b.WhereCond, Expr(query, value...))
57 | case Builder:
58 | b.WhereCond = append(b.WhereCond, query)
59 | }
60 | return b
61 | }
62 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/delete_builder.go:
--------------------------------------------------------------------------------
1 | package dbr
2 |
3 | import (
4 | "context"
5 | "database/sql"
6 | "fmt"
7 | )
8 |
9 | type DeleteBuilder struct {
10 | runner
11 | EventReceiver
12 | Dialect Dialect
13 |
14 | *DeleteStmt
15 |
16 | LimitCount int64
17 | }
18 |
19 | func (sess *Session) DeleteFrom(table string) *DeleteBuilder {
20 | return &DeleteBuilder{
21 | runner: sess,
22 | EventReceiver: sess,
23 | Dialect: sess.Dialect,
24 | DeleteStmt: DeleteFrom(table),
25 | LimitCount: -1,
26 | }
27 | }
28 |
29 | func (tx *Tx) DeleteFrom(table string) *DeleteBuilder {
30 | return &DeleteBuilder{
31 | runner: tx,
32 | EventReceiver: tx,
33 | Dialect: tx.Dialect,
34 | DeleteStmt: DeleteFrom(table),
35 | LimitCount: -1,
36 | }
37 | }
38 |
39 | func (sess *Session) DeleteBySql(query string, value ...interface{}) *DeleteBuilder {
40 | return &DeleteBuilder{
41 | runner: sess,
42 | EventReceiver: sess,
43 | Dialect: sess.Dialect,
44 | DeleteStmt: DeleteBySql(query, value...),
45 | LimitCount: -1,
46 | }
47 | }
48 |
49 | func (tx *Tx) DeleteBySql(query string, value ...interface{}) *DeleteBuilder {
50 | return &DeleteBuilder{
51 | runner: tx,
52 | EventReceiver: tx,
53 | Dialect: tx.Dialect,
54 | DeleteStmt: DeleteBySql(query, value...),
55 | LimitCount: -1,
56 | }
57 | }
58 |
59 | func (b *DeleteBuilder) Exec() (sql.Result, error) {
60 | return b.ExecContext(context.Background())
61 | }
62 |
63 | func (b *DeleteBuilder) ExecContext(ctx context.Context) (sql.Result, error) {
64 | return exec(ctx, b.runner, b.EventReceiver, b, b.Dialect)
65 | }
66 |
67 | func (b *DeleteBuilder) Where(query interface{}, value ...interface{}) *DeleteBuilder {
68 | b.DeleteStmt.Where(query, value...)
69 | return b
70 | }
71 |
72 | func (b *DeleteBuilder) Limit(n uint64) *DeleteBuilder {
73 | b.LimitCount = int64(n)
74 | return b
75 | }
76 |
77 | func (b *DeleteBuilder) Build(d Dialect, buf Buffer) error {
78 | err := b.DeleteStmt.Build(b.Dialect, buf)
79 | if err != nil {
80 | return err
81 | }
82 | if b.LimitCount >= 0 {
83 | buf.WriteString(" LIMIT ")
84 | buf.WriteString(fmt.Sprint(b.LimitCount))
85 | }
86 | return nil
87 | }
88 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/dialect.go:
--------------------------------------------------------------------------------
1 | package dbr
2 |
3 | import "time"
4 |
5 | // Dialect abstracts database differences
6 | type Dialect interface {
7 | QuoteIdent(id string) string
8 |
9 | EncodeString(s string) string
10 | EncodeBool(b bool) string
11 | EncodeTime(t time.Time) string
12 | EncodeBytes(b []byte) string
13 |
14 | Placeholder(n int) string
15 | }
16 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/dialect/dialect.go:
--------------------------------------------------------------------------------
1 | package dialect
2 |
3 | import "strings"
4 |
5 | var (
6 | // MySQL dialect
7 | MySQL = mysql{}
8 | // PostgreSQL dialect
9 | PostgreSQL = postgreSQL{}
10 | // SQLite3 dialect
11 | SQLite3 = sqlite3{}
12 | )
13 |
14 | const (
15 | timeFormat = "2006-01-02 15:04:05.000000"
16 | )
17 |
18 | func quoteIdent(s, quote string) string {
19 | part := strings.SplitN(s, ".", 2)
20 | if len(part) == 2 {
21 | return quoteIdent(part[0], quote) + "." + quoteIdent(part[1], quote)
22 | }
23 | return quote + s + quote
24 | }
25 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/dialect/mysql.go:
--------------------------------------------------------------------------------
1 | package dialect
2 |
3 | import (
4 | "bytes"
5 | "fmt"
6 | "time"
7 | )
8 |
9 | type mysql struct{}
10 |
11 | func (d mysql) QuoteIdent(s string) string {
12 | return quoteIdent(s, "`")
13 | }
14 |
15 | func (d mysql) EncodeString(s string) string {
16 | buf := new(bytes.Buffer)
17 |
18 | buf.WriteRune('\'')
19 | // https://dev.mysql.com/doc/refman/5.7/en/string-literals.html
20 | for i := 0; i < len(s); i++ {
21 | switch s[i] {
22 | case 0:
23 | buf.WriteString(`\0`)
24 | case '\'':
25 | buf.WriteString(`\'`)
26 | case '"':
27 | buf.WriteString(`\"`)
28 | case '\b':
29 | buf.WriteString(`\b`)
30 | case '\n':
31 | buf.WriteString(`\n`)
32 | case '\r':
33 | buf.WriteString(`\r`)
34 | case '\t':
35 | buf.WriteString(`\t`)
36 | case 26:
37 | buf.WriteString(`\Z`)
38 | case '\\':
39 | buf.WriteString(`\\`)
40 | default:
41 | buf.WriteByte(s[i])
42 | }
43 | }
44 |
45 | buf.WriteRune('\'')
46 | return buf.String()
47 | }
48 |
49 | func (d mysql) EncodeBool(b bool) string {
50 | if b {
51 | return "1"
52 | }
53 | return "0"
54 | }
55 |
56 | func (d mysql) EncodeTime(t time.Time) string {
57 | return `'` + t.UTC().Format(timeFormat) + `'`
58 | }
59 |
60 | func (d mysql) EncodeBytes(b []byte) string {
61 | return fmt.Sprintf(`0x%x`, b)
62 | }
63 |
64 | func (d mysql) Placeholder(_ int) string {
65 | return "?"
66 | }
67 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/dialect/postgresql.go:
--------------------------------------------------------------------------------
1 | package dialect
2 |
3 | import (
4 | "fmt"
5 | "strings"
6 | "time"
7 | )
8 |
9 | type postgreSQL struct{}
10 |
11 | func (d postgreSQL) QuoteIdent(s string) string {
12 | return quoteIdent(s, `"`)
13 | }
14 |
15 | func (d postgreSQL) EncodeString(s string) string {
16 | // http://www.postgresql.org/docs/9.2/static/sql-syntax-lexical.html
17 | return `'` + strings.Replace(s, `'`, `''`, -1) + `'`
18 | }
19 |
20 | func (d postgreSQL) EncodeBool(b bool) string {
21 | if b {
22 | return "TRUE"
23 | }
24 | return "FALSE"
25 | }
26 |
27 | func (d postgreSQL) EncodeTime(t time.Time) string {
28 | return MySQL.EncodeTime(t)
29 | }
30 |
31 | func (d postgreSQL) EncodeBytes(b []byte) string {
32 | return fmt.Sprintf(`E'\\x%x'`, b)
33 | }
34 |
35 | func (d postgreSQL) Placeholder(n int) string {
36 | return fmt.Sprintf("$%d", n+1)
37 | }
38 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/dialect/sqlite3.go:
--------------------------------------------------------------------------------
1 | package dialect
2 |
3 | import (
4 | "fmt"
5 | "strings"
6 | "time"
7 | )
8 |
9 | type sqlite3 struct{}
10 |
11 | func (d sqlite3) QuoteIdent(s string) string {
12 | return quoteIdent(s, `"`)
13 | }
14 |
15 | func (d sqlite3) EncodeString(s string) string {
16 | // https://www.sqlite.org/faq.html
17 | return `'` + strings.Replace(s, `'`, `''`, -1) + `'`
18 | }
19 |
20 | func (d sqlite3) EncodeBool(b bool) string {
21 | // https://www.sqlite.org/lang_expr.html
22 | if b {
23 | return "1"
24 | }
25 | return "0"
26 | }
27 |
28 | func (d sqlite3) EncodeTime(t time.Time) string {
29 | // https://www.sqlite.org/lang_datefunc.html
30 | return MySQL.EncodeTime(t)
31 | }
32 |
33 | func (d sqlite3) EncodeBytes(b []byte) string {
34 | // https://www.sqlite.org/lang_expr.html
35 | return fmt.Sprintf(`X'%x'`, b)
36 | }
37 |
38 | func (d sqlite3) Placeholder(_ int) string {
39 | return "?"
40 | }
41 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/errors.go:
--------------------------------------------------------------------------------
1 | package dbr
2 |
3 | import "errors"
4 |
5 | // package errors
6 | var (
7 | ErrNotFound = errors.New("dbr: not found")
8 | ErrNotSupported = errors.New("dbr: not supported")
9 | ErrTableNotSpecified = errors.New("dbr: table not specified")
10 | ErrColumnNotSpecified = errors.New("dbr: column not specified")
11 | ErrInvalidPointer = errors.New("dbr: attempt to load into an invalid pointer")
12 | ErrPlaceholderCount = errors.New("dbr: wrong placeholder count")
13 | ErrInvalidSliceLength = errors.New("dbr: length of slice is 0. length must be >= 1")
14 | ErrCantConvertToTime = errors.New("dbr: can't convert to time.Time")
15 | ErrInvalidTimestring = errors.New("dbr: invalid time string")
16 | )
17 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/event.go:
--------------------------------------------------------------------------------
1 | package dbr
2 |
3 | // EventReceiver gets events from dbr methods for logging purposes
4 | type EventReceiver interface {
5 | Event(eventName string)
6 | EventKv(eventName string, kvs map[string]string)
7 | EventErr(eventName string, err error) error
8 | EventErrKv(eventName string, err error, kvs map[string]string) error
9 | Timing(eventName string, nanoseconds int64)
10 | TimingKv(eventName string, nanoseconds int64, kvs map[string]string)
11 | }
12 |
13 | type kvs map[string]string
14 |
15 | var nullReceiver = &NullEventReceiver{}
16 |
17 | // NullEventReceiver is a sentinel EventReceiver; use it if the caller doesn't supply one
18 | type NullEventReceiver struct{}
19 |
20 | // Event receives a simple notification when various events occur
21 | func (n *NullEventReceiver) Event(eventName string) {}
22 |
23 | // EventKv receives a notification when various events occur along with
24 | // optional key/value data
25 | func (n *NullEventReceiver) EventKv(eventName string, kvs map[string]string) {}
26 |
27 | // EventErr receives a notification of an error if one occurs
28 | func (n *NullEventReceiver) EventErr(eventName string, err error) error { return err }
29 |
30 | // EventErrKv receives a notification of an error if one occurs along with
31 | // optional key/value data
32 | func (n *NullEventReceiver) EventErrKv(eventName string, err error, kvs map[string]string) error {
33 | return err
34 | }
35 |
36 | // Timing receives the time an event took to happen
37 | func (n *NullEventReceiver) Timing(eventName string, nanoseconds int64) {}
38 |
39 | // TimingKv receives the time an event took to happen along with optional key/value data
40 | func (n *NullEventReceiver) TimingKv(eventName string, nanoseconds int64, kvs map[string]string) {}
41 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/expr.go:
--------------------------------------------------------------------------------
1 | package dbr
2 |
3 | // XxxBuilders all support raw query
4 | type raw struct {
5 | Query string
6 | Value []interface{}
7 | }
8 |
9 | // Expr should be used when sql syntax is not supported
10 | func Expr(query string, value ...interface{}) Builder {
11 | return &raw{Query: query, Value: value}
12 | }
13 |
14 | func (raw *raw) Build(_ Dialect, buf Buffer) error {
15 | buf.WriteString(raw.Query)
16 | buf.WriteValue(raw.Value...)
17 | return nil
18 | }
19 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/ident.go:
--------------------------------------------------------------------------------
1 | package dbr
2 |
3 | // identifier is a type of string
4 | type I string
5 |
6 | func (i I) Build(d Dialect, buf Buffer) error {
7 | buf.WriteString(d.QuoteIdent(string(i)))
8 | return nil
9 | }
10 |
11 | // As creates an alias for expr. e.g. SELECT `a1` AS `a2`
12 | func (i I) As(alias string) Builder {
13 | return as(i, alias)
14 | }
15 |
16 | func as(expr interface{}, alias string) Builder {
17 | return BuildFunc(func(d Dialect, buf Buffer) error {
18 | buf.WriteString(placeholder)
19 | buf.WriteValue(expr)
20 | buf.WriteString(" AS ")
21 | buf.WriteString(d.QuoteIdent(alias))
22 | return nil
23 | })
24 | }
25 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/join.go:
--------------------------------------------------------------------------------
1 | package dbr
2 |
3 | type joinType uint8
4 |
5 | const (
6 | inner joinType = iota
7 | left
8 | right
9 | full
10 | )
11 |
12 | func join(t joinType, table interface{}, on interface{}) Builder {
13 | return BuildFunc(func(d Dialect, buf Buffer) error {
14 | buf.WriteString(" ")
15 | switch t {
16 | case left:
17 | buf.WriteString("LEFT ")
18 | case right:
19 | buf.WriteString("RIGHT ")
20 | case full:
21 | buf.WriteString("FULL ")
22 | }
23 | buf.WriteString("JOIN ")
24 | switch table := table.(type) {
25 | case string:
26 | buf.WriteString(d.QuoteIdent(table))
27 | default:
28 | buf.WriteString(placeholder)
29 | buf.WriteValue(table)
30 | }
31 | buf.WriteString(" ON ")
32 | switch on := on.(type) {
33 | case string:
34 | buf.WriteString(on)
35 | case Builder:
36 | buf.WriteString(placeholder)
37 | buf.WriteValue(on)
38 | }
39 | return nil
40 | })
41 | }
42 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/now.go:
--------------------------------------------------------------------------------
1 | package dbr
2 |
3 | import (
4 | "database/sql/driver"
5 | "time"
6 | )
7 |
8 | // Now is a value that serializes to the current time
9 | var Now = nowSentinel{}
10 |
11 | const timeFormat = "2006-01-02 15:04:05.000000"
12 |
13 | type nowSentinel struct{}
14 |
15 | // Value implements a valuer for compatibility
16 | func (n nowSentinel) Value() (driver.Value, error) {
17 | now := time.Now().UTC().Format(timeFormat)
18 | return now, nil
19 | }
20 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/order.go:
--------------------------------------------------------------------------------
1 | package dbr
2 |
3 | type direction bool
4 |
5 | // orderby directions
6 | // most databases by default use asc
7 | const (
8 | asc direction = false
9 | desc = true
10 | )
11 |
12 | func order(column string, dir direction) Builder {
13 | return BuildFunc(func(d Dialect, buf Buffer) error {
14 | // FIXME: no quote ident
15 | buf.WriteString(column)
16 | switch dir {
17 | case asc:
18 | buf.WriteString(" ASC")
19 | case desc:
20 | buf.WriteString(" DESC")
21 | }
22 | return nil
23 | })
24 | }
25 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/select_return.go:
--------------------------------------------------------------------------------
1 | package dbr
2 |
3 | //
4 | // These are a set of helpers that just call LoadValue and return the value.
5 | // They return (_, ErrNotFound) if nothing was found.
6 | //
7 |
8 | // The inclusion of these helpers in the package is not an obvious choice:
9 | // Benefits:
10 | // - slight increase in code clarity/conciseness b/c you can use ":=" to define the variable
11 | //
12 | // count, err := d.Select("COUNT(*)").From("users").Where("x = ?", x).ReturnInt64()
13 | //
14 | // vs
15 | //
16 | // var count int64
17 | // err := d.Select("COUNT(*)").From("users").Where("x = ?", x).LoadValue(&count)
18 | //
19 | // Downsides:
20 | // - very small increase in code cost, although it's not complex code
21 | // - increase in conceptual model / API footprint when presenting the package to new users
22 | // - no functionality that you can't achieve calling .LoadValue directly.
23 | // - There's a lot of possible types. Do we want to include ALL of them? u?int{8,16,32,64}?, strings, null varieties, etc.
24 | // - Let's just do the common, non-null varieties.
25 |
26 | // ReturnInt64 executes the SelectStmt and returns the value as an int64
27 | func (b *SelectBuilder) ReturnInt64() (int64, error) {
28 | var v int64
29 | err := b.LoadValue(&v)
30 | return v, err
31 | }
32 |
33 | // ReturnInt64s executes the SelectStmt and returns the value as a slice of int64s
34 | func (b *SelectBuilder) ReturnInt64s() ([]int64, error) {
35 | var v []int64
36 | _, err := b.LoadValues(&v)
37 | return v, err
38 | }
39 |
40 | // ReturnUint64 executes the SelectStmt and returns the value as an uint64
41 | func (b *SelectBuilder) ReturnUint64() (uint64, error) {
42 | var v uint64
43 | err := b.LoadValue(&v)
44 | return v, err
45 | }
46 |
47 | // ReturnUint64s executes the SelectStmt and returns the value as a slice of uint64s
48 | func (b *SelectBuilder) ReturnUint64s() ([]uint64, error) {
49 | var v []uint64
50 | _, err := b.LoadValues(&v)
51 | return v, err
52 | }
53 |
54 | // ReturnString executes the SelectStmt and returns the value as a string
55 | func (b *SelectBuilder) ReturnString() (string, error) {
56 | var v string
57 | err := b.LoadValue(&v)
58 | return v, err
59 | }
60 |
61 | // ReturnStrings executes the SelectStmt and returns the value as a slice of strings
62 | func (b *SelectBuilder) ReturnStrings() ([]string, error) {
63 | var v []string
64 | _, err := b.LoadValues(&v)
65 | return v, err
66 | }
67 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/transaction.go:
--------------------------------------------------------------------------------
1 | package dbr
2 |
3 | import (
4 | "context"
5 | "database/sql"
6 | "time"
7 | )
8 |
9 | // Tx is a transaction for the given Session
10 | type Tx struct {
11 | EventReceiver
12 | Dialect Dialect
13 | *sql.Tx
14 | Timeout time.Duration
15 |
16 | // normally we don't call the context cancelFunc.
17 | // however, if we start a tx without explictly tx,
18 | // we will need to call this after the transaction.
19 | Cancel func()
20 | }
21 |
22 | func (tx *Tx) GetTimeout() time.Duration {
23 | return tx.Timeout
24 | }
25 |
26 | func (sess *Session) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) {
27 | tx, err := sess.Connection.BeginTx(ctx, opts)
28 | if err != nil {
29 | return nil, sess.EventErr("dbr.begin.error", err)
30 | }
31 | sess.Event("dbr.begin")
32 |
33 | stx := &Tx{
34 | EventReceiver: sess,
35 | Dialect: sess.Dialect,
36 | Tx: tx,
37 | Cancel: func() {},
38 | }
39 | deadline, ok := ctx.Deadline()
40 | if ok {
41 | stx.Timeout = deadline.Sub(time.Now())
42 | }
43 | return stx, nil
44 | }
45 |
46 | // Begin creates a transaction for the given session
47 | func (sess *Session) Begin() (*Tx, error) {
48 | ctx := context.Background()
49 | var cancel func()
50 | timeout := sess.GetTimeout()
51 | if timeout > 0 {
52 | ctx, cancel = context.WithTimeout(ctx, timeout)
53 | }
54 | stx, err := sess.BeginTx(ctx, nil)
55 | if err != nil {
56 | return nil, err
57 | }
58 | if cancel != nil {
59 | stx.Cancel = cancel
60 | }
61 | return stx, nil
62 | }
63 |
64 | // Commit finishes the transaction
65 | func (tx *Tx) Commit() error {
66 | defer tx.Cancel()
67 | err := tx.Tx.Commit()
68 | if err != nil {
69 | return tx.EventErr("dbr.commit.error", err)
70 | }
71 | tx.Event("dbr.commit")
72 | return nil
73 | }
74 |
75 | // Rollback cancels the transaction
76 | func (tx *Tx) Rollback() error {
77 | defer tx.Cancel()
78 | err := tx.Tx.Rollback()
79 | if err != nil {
80 | return tx.EventErr("dbr.rollback", err)
81 | }
82 | tx.Event("dbr.rollback")
83 | return nil
84 | }
85 |
86 | // RollbackUnlessCommitted rollsback the transaction unless it has already been committed or rolled back.
87 | // Useful to defer tx.RollbackUnlessCommitted() -- so you don't have to handle N failure cases
88 | // Keep in mind the only way to detect an error on the rollback is via the event log.
89 | func (tx *Tx) RollbackUnlessCommitted() {
90 | defer tx.Cancel()
91 | err := tx.Tx.Rollback()
92 | if err == sql.ErrTxDone {
93 | // ok
94 | } else if err != nil {
95 | tx.EventErr("dbr.rollback_unless_committed", err)
96 | } else {
97 | tx.Event("dbr.rollback")
98 | }
99 | }
100 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/union.go:
--------------------------------------------------------------------------------
1 | package dbr
2 |
3 | type union struct {
4 | builder []Builder
5 | all bool
6 | }
7 |
8 | func Union(builder ...Builder) interface {
9 | Builder
10 | As(string) Builder
11 | } {
12 | return &union{
13 | builder: builder,
14 | }
15 | }
16 |
17 | func UnionAll(builder ...Builder) interface {
18 | Builder
19 | As(string) Builder
20 | } {
21 | return &union{
22 | builder: builder,
23 | all: true,
24 | }
25 | }
26 |
27 | func (u *union) Build(d Dialect, buf Buffer) error {
28 | for i, b := range u.builder {
29 | if i > 0 {
30 | buf.WriteString(" UNION ")
31 | if u.all {
32 | buf.WriteString("ALL ")
33 | }
34 | }
35 | buf.WriteString(placeholder)
36 | buf.WriteValue(b)
37 | }
38 | return nil
39 | }
40 |
41 | func (u *union) As(alias string) Builder {
42 | return as(u, alias)
43 | }
44 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/update.go:
--------------------------------------------------------------------------------
1 | package dbr
2 |
3 | // UpdateStmt builds `UPDATE ...`
4 | type UpdateStmt struct {
5 | raw
6 |
7 | Table string
8 | Value map[string]interface{}
9 |
10 | WhereCond []Builder
11 | }
12 |
13 | // Build builds `UPDATE ...` in dialect
14 | func (b *UpdateStmt) Build(d Dialect, buf Buffer) error {
15 | if b.raw.Query != "" {
16 | return b.raw.Build(d, buf)
17 | }
18 |
19 | if b.Table == "" {
20 | return ErrTableNotSpecified
21 | }
22 |
23 | if len(b.Value) == 0 {
24 | return ErrColumnNotSpecified
25 | }
26 |
27 | buf.WriteString("UPDATE ")
28 | buf.WriteString(d.QuoteIdent(b.Table))
29 | buf.WriteString(" SET ")
30 |
31 | i := 0
32 | for col, v := range b.Value {
33 | if i > 0 {
34 | buf.WriteString(", ")
35 | }
36 | buf.WriteString(d.QuoteIdent(col))
37 | buf.WriteString(" = ")
38 | buf.WriteString(placeholder)
39 |
40 | buf.WriteValue(v)
41 | i++
42 | }
43 |
44 | if len(b.WhereCond) > 0 {
45 | buf.WriteString(" WHERE ")
46 | err := And(b.WhereCond...).Build(d, buf)
47 | if err != nil {
48 | return err
49 | }
50 | }
51 | return nil
52 | }
53 |
54 | // Update creates an UpdateStmt
55 | func Update(table string) *UpdateStmt {
56 | return &UpdateStmt{
57 | Table: table,
58 | Value: make(map[string]interface{}),
59 | }
60 | }
61 |
62 | // UpdateBySql creates an UpdateStmt with raw query
63 | func UpdateBySql(query string, value ...interface{}) *UpdateStmt {
64 | return &UpdateStmt{
65 | raw: raw{
66 | Query: query,
67 | Value: value,
68 | },
69 | Value: make(map[string]interface{}),
70 | }
71 | }
72 |
73 | // Where adds a where condition
74 | func (b *UpdateStmt) Where(query interface{}, value ...interface{}) *UpdateStmt {
75 | switch query := query.(type) {
76 | case string:
77 | b.WhereCond = append(b.WhereCond, Expr(query, value...))
78 | case Builder:
79 | b.WhereCond = append(b.WhereCond, query)
80 | }
81 | return b
82 | }
83 |
84 | // Set specifies a key-value pair
85 | func (b *UpdateStmt) Set(column string, value interface{}) *UpdateStmt {
86 | b.Value[column] = value
87 | return b
88 | }
89 |
90 | // SetMap specifies a list of key-value pair
91 | func (b *UpdateStmt) SetMap(m map[string]interface{}) *UpdateStmt {
92 | for col, val := range m {
93 | b.Set(col, val)
94 | }
95 | return b
96 | }
97 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/update_builder.go:
--------------------------------------------------------------------------------
1 | package dbr
2 |
3 | import (
4 | "context"
5 | "database/sql"
6 | "fmt"
7 | )
8 |
9 | type UpdateBuilder struct {
10 | runner
11 | EventReceiver
12 | Dialect Dialect
13 |
14 | *UpdateStmt
15 |
16 | LimitCount int64
17 | }
18 |
19 | func (sess *Session) Update(table string) *UpdateBuilder {
20 | return &UpdateBuilder{
21 | runner: sess,
22 | EventReceiver: sess,
23 | Dialect: sess.Dialect,
24 | UpdateStmt: Update(table),
25 | LimitCount: -1,
26 | }
27 | }
28 |
29 | func (tx *Tx) Update(table string) *UpdateBuilder {
30 | return &UpdateBuilder{
31 | runner: tx,
32 | EventReceiver: tx,
33 | Dialect: tx.Dialect,
34 | UpdateStmt: Update(table),
35 | LimitCount: -1,
36 | }
37 | }
38 |
39 | func (sess *Session) UpdateBySql(query string, value ...interface{}) *UpdateBuilder {
40 | return &UpdateBuilder{
41 | runner: sess,
42 | EventReceiver: sess,
43 | Dialect: sess.Dialect,
44 | UpdateStmt: UpdateBySql(query, value...),
45 | LimitCount: -1,
46 | }
47 | }
48 |
49 | func (tx *Tx) UpdateBySql(query string, value ...interface{}) *UpdateBuilder {
50 | return &UpdateBuilder{
51 | runner: tx,
52 | EventReceiver: tx,
53 | Dialect: tx.Dialect,
54 | UpdateStmt: UpdateBySql(query, value...),
55 | LimitCount: -1,
56 | }
57 | }
58 |
59 | func (b *UpdateBuilder) Exec() (sql.Result, error) {
60 | return b.ExecContext(context.Background())
61 | }
62 |
63 | func (b *UpdateBuilder) ExecContext(ctx context.Context) (sql.Result, error) {
64 | return exec(ctx, b.runner, b.EventReceiver, b, b.Dialect)
65 | }
66 |
67 | func (b *UpdateBuilder) Set(column string, value interface{}) *UpdateBuilder {
68 | b.UpdateStmt.Set(column, value)
69 | return b
70 | }
71 |
72 | func (b *UpdateBuilder) SetMap(m map[string]interface{}) *UpdateBuilder {
73 | b.UpdateStmt.SetMap(m)
74 | return b
75 | }
76 |
77 | func (b *UpdateBuilder) Where(query interface{}, value ...interface{}) *UpdateBuilder {
78 | b.UpdateStmt.Where(query, value...)
79 | return b
80 | }
81 |
82 | func (b *UpdateBuilder) Limit(n uint64) *UpdateBuilder {
83 | b.LimitCount = int64(n)
84 | return b
85 | }
86 |
87 | func (b *UpdateBuilder) Build(d Dialect, buf Buffer) error {
88 | err := b.UpdateStmt.Build(b.Dialect, buf)
89 | if err != nil {
90 | return err
91 | }
92 | if b.LimitCount >= 0 {
93 | buf.WriteString(" LIMIT ")
94 | buf.WriteString(fmt.Sprint(b.LimitCount))
95 | }
96 | return nil
97 | }
98 |
--------------------------------------------------------------------------------
/vendor/github.com/gocraft/dbr/util.go:
--------------------------------------------------------------------------------
1 | package dbr
2 |
3 | import (
4 | "bytes"
5 | "database/sql/driver"
6 | "reflect"
7 | "unicode"
8 | )
9 |
10 | func camelCaseToSnakeCase(name string) string {
11 | buf := new(bytes.Buffer)
12 |
13 | runes := []rune(name)
14 |
15 | for i := 0; i < len(runes); i++ {
16 | buf.WriteRune(unicode.ToLower(runes[i]))
17 | if i != len(runes)-1 && unicode.IsUpper(runes[i+1]) &&
18 | (unicode.IsLower(runes[i]) || unicode.IsDigit(runes[i]) ||
19 | (i != len(runes)-2 && unicode.IsLower(runes[i+2]))) {
20 | buf.WriteRune('_')
21 | }
22 | }
23 |
24 | return buf.String()
25 | }
26 |
27 | func structMap(value reflect.Value) map[string]reflect.Value {
28 | m := make(map[string]reflect.Value)
29 | structValue(m, value)
30 | return m
31 | }
32 |
33 | var (
34 | typeValuer = reflect.TypeOf((*driver.Valuer)(nil)).Elem()
35 | )
36 |
37 | func structValue(m map[string]reflect.Value, value reflect.Value) {
38 | if value.Type().Implements(typeValuer) {
39 | return
40 | }
41 | switch value.Kind() {
42 | case reflect.Ptr:
43 | if value.IsNil() {
44 | return
45 | }
46 | structValue(m, value.Elem())
47 | case reflect.Struct:
48 | t := value.Type()
49 | for i := 0; i < t.NumField(); i++ {
50 | field := t.Field(i)
51 | if field.PkgPath != "" && !field.Anonymous {
52 | // unexported
53 | continue
54 | }
55 | tag := field.Tag.Get("db")
56 | if tag == "-" {
57 | // ignore
58 | continue
59 | }
60 | if tag == "" {
61 | // no tag, but we can record the field name
62 | tag = camelCaseToSnakeCase(field.Name)
63 | }
64 | fieldValue := value.Field(i)
65 | if _, ok := m[tag]; !ok {
66 | m[tag] = fieldValue
67 | }
68 | structValue(m, fieldValue)
69 | }
70 | }
71 | }
72 |
--------------------------------------------------------------------------------
/vendor/github.com/golang/example/stringutil/reverse.go:
--------------------------------------------------------------------------------
1 | /*
2 | Copyright 2014 Google Inc.
3 |
4 | Licensed under the Apache License, Version 2.0 (the "License");
5 | you may not use this file except in compliance with the License.
6 | You may obtain a copy of the License at
7 |
8 | http://www.apache.org/licenses/LICENSE-2.0
9 |
10 | Unless required by applicable law or agreed to in writing, software
11 | distributed under the License is distributed on an "AS IS" BASIS,
12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | See the License for the specific language governing permissions and
14 | limitations under the License.
15 | */
16 |
17 | // Package stringutil contains utility functions for working with strings.
18 | package stringutil
19 |
20 | // Reverse returns its argument string reversed rune-wise left to right.
21 | func Reverse(s string) string {
22 | r := []rune(s)
23 | for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
24 | r[i], r[j] = r[j], r[i]
25 | }
26 | return string(r)
27 | }
28 |
--------------------------------------------------------------------------------
/vendor/github.com/golang/glog/README:
--------------------------------------------------------------------------------
1 | glog
2 | ====
3 |
4 | Leveled execution logs for Go.
5 |
6 | This is an efficient pure Go implementation of leveled logs in the
7 | manner of the open source C++ package
8 | https://github.com/google/glog
9 |
10 | By binding methods to booleans it is possible to use the log package
11 | without paying the expense of evaluating the arguments to the log.
12 | Through the -vmodule flag, the package also provides fine-grained
13 | control over logging at the file level.
14 |
15 | The comment from glog.go introduces the ideas:
16 |
17 | Package glog implements logging analogous to the Google-internal
18 | C++ INFO/ERROR/V setup. It provides functions Info, Warning,
19 | Error, Fatal, plus formatting variants such as Infof. It
20 | also provides V-style logging controlled by the -v and
21 | -vmodule=file=2 flags.
22 |
23 | Basic examples:
24 |
25 | glog.Info("Prepare to repel boarders")
26 |
27 | glog.Fatalf("Initialization failed: %s", err)
28 |
29 | See the documentation for the V function for an explanation
30 | of these examples:
31 |
32 | if glog.V(2) {
33 | glog.Info("Starting transaction...")
34 | }
35 |
36 | glog.V(2).Infoln("Processed", nItems, "elements")
37 |
38 |
39 | The repository contains an open source version of the log package
40 | used inside Google. The master copy of the source lives inside
41 | Google, not here. The code in this repo is for export only and is not itself
42 | under development. Feature requests will be ignored.
43 |
44 | Send bug reports to golang-nuts@googlegroups.com.
45 |
--------------------------------------------------------------------------------
/vendor/github.com/google/go-querystring/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2013 Google. All rights reserved.
2 |
3 | Redistribution and use in source and binary forms, with or without
4 | modification, are permitted provided that the following conditions are
5 | met:
6 |
7 | * Redistributions of source code must retain the above copyright
8 | notice, this list of conditions and the following disclaimer.
9 | * Redistributions in binary form must reproduce the above
10 | copyright notice, this list of conditions and the following disclaimer
11 | in the documentation and/or other materials provided with the
12 | distribution.
13 | * Neither the name of Google Inc. nor the names of its
14 | contributors may be used to endorse or promote products derived from
15 | this software without specific prior written permission.
16 |
17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 |
--------------------------------------------------------------------------------
/vendor/github.com/koding/multiconfig/.gitignore:
--------------------------------------------------------------------------------
1 | # Compiled Object files, Static and Dynamic libs (Shared Objects)
2 | *.o
3 | *.a
4 | *.so
5 |
6 | # Folders
7 | _obj
8 | _test
9 |
10 | # Architecture specific extensions/prefixes
11 | *.[568vq]
12 | [568vq].out
13 |
14 | *.cgo1.go
15 | *.cgo2.c
16 | _cgo_defun.c
17 | _cgo_gotypes.go
18 | _cgo_export.*
19 |
20 | _testmain.go
21 |
22 | *.exe
23 | *.test
24 |
25 | *~
26 |
--------------------------------------------------------------------------------
/vendor/github.com/koding/multiconfig/.travis.yml:
--------------------------------------------------------------------------------
1 | language: go
2 | go: 1.3
3 | script: go test ./...
4 |
5 |
--------------------------------------------------------------------------------
/vendor/github.com/koding/multiconfig/LICENSE:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 |
3 | Copyright (c) 2014 Koding, Inc.
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/vendor/github.com/koding/multiconfig/doc.go:
--------------------------------------------------------------------------------
1 | // Package multiconfig provides a way to load and read configurations from
2 | // multiple sources. You can read from TOML file, JSON file, YAML file, Environment
3 | // Variables and flags. You can set the order of reader with MultiLoader. Package
4 | // is extensible, you can add your custom Loader by implementing the Load interface.
5 | package multiconfig
6 |
--------------------------------------------------------------------------------
/vendor/github.com/koding/multiconfig/multiloader.go:
--------------------------------------------------------------------------------
1 | package multiconfig
2 |
3 | type multiLoader []Loader
4 |
5 | // MultiLoader creates a loader that executes the loaders one by one in order
6 | // and returns on the first error.
7 | func MultiLoader(loader ...Loader) Loader {
8 | return multiLoader(loader)
9 | }
10 |
11 | // Load loads the source into the config defined by struct s
12 | func (m multiLoader) Load(s interface{}) error {
13 | for _, loader := range m {
14 | if err := loader.Load(s); err != nil {
15 | return err
16 | }
17 | }
18 |
19 | return nil
20 | }
21 |
22 | // MustLoad loads the source into the struct, it panics if gets any error
23 | func (m multiLoader) MustLoad(s interface{}) {
24 | if err := m.Load(s); err != nil {
25 | panic(err)
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/vendor/github.com/koding/multiconfig/multivalidator.go:
--------------------------------------------------------------------------------
1 | package multiconfig
2 |
3 | type multiValidator []Validator
4 |
5 | // MultiValidator accepts variadic validators and satisfies Validator interface.
6 | func MultiValidator(validators ...Validator) Validator {
7 | return multiValidator(validators)
8 | }
9 |
10 | // Validate tries to validate given struct with all the validators. If it doesn't
11 | // have any Validator it will simply skip the validation step. If any of the
12 | // given validators return err, it will stop validating and return it.
13 | func (d multiValidator) Validate(s interface{}) error {
14 | for _, validator := range d {
15 | if err := validator.Validate(s); err != nil {
16 | return err
17 | }
18 | }
19 |
20 | return nil
21 | }
22 |
23 | // MustValidate validates the struct, it panics if gets any error
24 | func (d multiValidator) MustValidate(s interface{}) {
25 | if err := d.Validate(s); err != nil {
26 | panic(err)
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/vendor/github.com/koding/multiconfig/tag.go:
--------------------------------------------------------------------------------
1 | package multiconfig
2 |
3 | import (
4 | "reflect"
5 |
6 | "github.com/fatih/structs"
7 | )
8 |
9 | // TagLoader satisfies the loader interface. It parses a struct's field tags
10 | // and populates the each field with that given tag.
11 | type TagLoader struct {
12 | // DefaultTagName is the default tag name for struct fields to define
13 | // default values for a field. Example:
14 | //
15 | // // Field's default value is "koding".
16 | // Name string `default:"koding"`
17 | //
18 | // The default value is "default" if it's not set explicitly.
19 | DefaultTagName string
20 | }
21 |
22 | func (t *TagLoader) Load(s interface{}) error {
23 | if t.DefaultTagName == "" {
24 | t.DefaultTagName = "default"
25 | }
26 |
27 | for _, field := range structs.Fields(s) {
28 |
29 | if err := t.processField(t.DefaultTagName, field); err != nil {
30 | return err
31 | }
32 | }
33 |
34 | return nil
35 | }
36 |
37 | // processField gets tagName and the field, recursively checks if the field has the given
38 | // tag, if yes, sets it otherwise ignores
39 | func (t *TagLoader) processField(tagName string, field *structs.Field) error {
40 | switch field.Kind() {
41 | case reflect.Struct:
42 | for _, f := range field.Fields() {
43 | if err := t.processField(tagName, f); err != nil {
44 | return err
45 | }
46 | }
47 | default:
48 | defaultVal := field.Tag(t.DefaultTagName)
49 | if defaultVal == "" {
50 | return nil
51 | }
52 |
53 | err := fieldSet(field, defaultVal)
54 | if err != nil {
55 | return err
56 | }
57 | }
58 |
59 | return nil
60 | }
61 |
--------------------------------------------------------------------------------
/vendor/github.com/koding/multiconfig/validator.go:
--------------------------------------------------------------------------------
1 | package multiconfig
2 |
3 | import (
4 | "fmt"
5 | "reflect"
6 |
7 | "github.com/fatih/structs"
8 | )
9 |
10 | // Validator validates the config against any predefined rules, those predefined
11 | // rules should be given to this package. The implementer will be responsible
12 | // for the logic.
13 | type Validator interface {
14 | // Validate validates the config struct
15 | Validate(s interface{}) error
16 | }
17 |
18 | // RequiredValidator validates the struct against zero values.
19 | type RequiredValidator struct {
20 | // TagName holds the validator tag name. The default is "required"
21 | TagName string
22 |
23 | // TagValue holds the expected value of the validator. The default is "true"
24 | TagValue string
25 | }
26 |
27 | // Validate validates the given struct agaist field's zero values. If
28 | // intentionaly, the value of a field is `zero-valued`(e.g false, 0, "")
29 | // required tag should not be set for that field.
30 | func (e *RequiredValidator) Validate(s interface{}) error {
31 | if e.TagName == "" {
32 | e.TagName = "required"
33 | }
34 |
35 | if e.TagValue == "" {
36 | e.TagValue = "true"
37 | }
38 |
39 | for _, field := range structs.Fields(s) {
40 | if err := e.processField("", field); err != nil {
41 | return err
42 | }
43 | }
44 |
45 | return nil
46 | }
47 |
48 | func (e *RequiredValidator) processField(fieldName string, field *structs.Field) error {
49 | fieldName += field.Name()
50 | switch field.Kind() {
51 | case reflect.Struct:
52 | // this is used for error messages below, when we have an error at the
53 | // child properties add parent properties into the error message as well
54 | fieldName += "."
55 |
56 | for _, f := range field.Fields() {
57 | if err := e.processField(fieldName, f); err != nil {
58 | return err
59 | }
60 | }
61 | default:
62 | val := field.Tag(e.TagName)
63 | if val != e.TagValue {
64 | return nil
65 | }
66 |
67 | if field.IsZero() {
68 | return fmt.Errorf("multiconfig: field '%s' is required", fieldName)
69 | }
70 | }
71 |
72 | return nil
73 | }
74 |
--------------------------------------------------------------------------------
/vendor/github.com/kubesphere/sonargo/sonar/duplications_service.go:
--------------------------------------------------------------------------------
1 | // Get duplication information for a project.
2 | package sonargo
3 |
4 | import "net/http"
5 |
6 | type DuplicationsService struct {
7 | client *Client
8 | }
9 |
10 | type DuplicationsShowObject struct {
11 | Duplications []*Duplication `json:"duplications,omitempty"`
12 | Files *Files `json:"files,omitempty"`
13 | }
14 |
15 | type Block struct {
16 | Ref string `json:"_ref,omitempty"`
17 | From int64 `json:"from,omitempty"`
18 | Size int64 `json:"size,omitempty"`
19 | }
20 |
21 | type Duplication struct {
22 | Blocks []*Block `json:"blocks,omitempty"`
23 | }
24 |
25 | type Files struct {
26 | One *File `json:"1,omitempty"`
27 | Two *File `json:"2,omitempty"`
28 | Three *File `json:"3,omitempty"`
29 | }
30 |
31 | type File struct {
32 | Key string `json:"key,omitempty"`
33 | Name string `json:"name,omitempty"`
34 | ProjectName string `json:"projectName,omitempty"`
35 | }
36 |
37 | type DuplicationsShowOption struct {
38 | Key string `url:"key,omitempty"` // Description:"File key",ExampleValue:"my_project:/src/foo/Bar.php"
39 | Uuid string `url:"uuid,omitempty"` // Description:"File ID. If provided, 'key' must not be provided.",ExampleValue:"584a89f2-8037-4f7b-b82c-8b45d2d63fb2"
40 | }
41 |
42 | // Show Get duplications. Require Browse permission on file's project
43 | func (s *DuplicationsService) Show(opt *DuplicationsShowOption) (v *DuplicationsShowObject, resp *http.Response, err error) {
44 | err = s.ValidateShowOpt(opt)
45 | if err != nil {
46 | return
47 | }
48 | req, err := s.client.NewRequest("GET", "duplications/show", opt)
49 | if err != nil {
50 | return
51 | }
52 | v = new(DuplicationsShowObject)
53 | resp, err = s.client.Do(req, v)
54 | if err != nil {
55 | return nil, resp, err
56 | }
57 | return
58 | }
59 |
--------------------------------------------------------------------------------
/vendor/github.com/kubesphere/sonargo/sonar/languages_service.go:
--------------------------------------------------------------------------------
1 | // Get the list of programming languages supported in this instance.
2 | package sonargo
3 |
4 | import "net/http"
5 |
6 | type LanguagesService struct {
7 | client *Client
8 | }
9 |
10 | type LanguagesListObject struct {
11 | Languages []*Language `json:"languages,omitempty"`
12 | }
13 |
14 | type Language struct {
15 | Key string `json:"key,omitempty"`
16 | Name string `json:"name,omitempty"`
17 | }
18 |
19 | type LanguagesListOption struct {
20 | Ps int `url:"ps,omitempty"` // Description:"The size of the list to return, 0 for all languages",ExampleValue:"25"
21 | Q string `url:"q,omitempty"` // Description:"A pattern to match language keys/names against",ExampleValue:"java"
22 | }
23 |
24 | // List List supported programming languages
25 | func (s *LanguagesService) List(opt *LanguagesListOption) (v *LanguagesListObject, resp *http.Response, err error) {
26 | err = s.ValidateListOpt(opt)
27 | if err != nil {
28 | return
29 | }
30 | req, err := s.client.NewRequest("GET", "languages/list", opt)
31 | if err != nil {
32 | return
33 | }
34 | v = new(LanguagesListObject)
35 | resp, err = s.client.Do(req, v)
36 | if err != nil {
37 | return nil, resp, err
38 | }
39 | return
40 | }
41 |
--------------------------------------------------------------------------------
/vendor/github.com/kubesphere/sonargo/sonar/project_badges_service.go:
--------------------------------------------------------------------------------
1 | // Generate badges based on quality gates or measures
2 | package sonargo
3 |
4 | import "net/http"
5 |
6 | type ProjectBadgesService struct {
7 | client *Client
8 | }
9 |
10 | type ProjectBadgesMeasureOption struct {
11 | Branch string `url:"branch,omitempty"` // Description:"Branch key",ExampleValue:"feature/my_branch"
12 | Metric string `url:"metric,omitempty"` // Description:"Metric key",ExampleValue:""
13 | Project string `url:"project,omitempty"` // Description:"Project key",ExampleValue:"my_project"
14 | PullRequest string `url:"pullRequest,omitempty"` // Description:"Pull request id",ExampleValue:"5461"
15 | }
16 |
17 | // Measure Generate badge for project's measure as an SVG.
Requires 'Browse' permission on the specified project.
18 | func (s *ProjectBadgesService) Measure(opt *ProjectBadgesMeasureOption) (v *string, resp *http.Response, err error) {
19 | err = s.ValidateMeasureOpt(opt)
20 | if err != nil {
21 | return
22 | }
23 | req, err := s.client.NewRequest("GET", "project_badges/measure", opt)
24 | if err != nil {
25 | return
26 | }
27 | v = new(string)
28 | resp, err = s.client.Do(req, v)
29 | if err != nil {
30 | return nil, resp, err
31 | }
32 | return
33 | }
34 |
35 | type ProjectBadgesQualityGateOption struct {
36 | Branch string `url:"branch,omitempty"` // Description:"Branch key",ExampleValue:"feature/my_branch"
37 | Project string `url:"project,omitempty"` // Description:"Project key",ExampleValue:"my_project"
38 | PullRequest string `url:"pullRequest,omitempty"` // Description:"Pull request id",ExampleValue:"5461"
39 | }
40 |
41 | // QualityGate Generate badge for project's quality gate as an SVG.
Requires 'Browse' permission on the specified project.
42 | func (s *ProjectBadgesService) QualityGate(opt *ProjectBadgesQualityGateOption) (v *string, resp *http.Response, err error) {
43 | err = s.ValidateQualityGateOpt(opt)
44 | if err != nil {
45 | return
46 | }
47 | req, err := s.client.NewRequest("GET", "project_badges/quality_gate", opt)
48 | if err != nil {
49 | return
50 | }
51 | v = new(string)
52 | resp, err = s.client.Do(req, v)
53 | if err != nil {
54 | return nil, resp, err
55 | }
56 | return
57 | }
58 |
--------------------------------------------------------------------------------
/vendor/github.com/kubesphere/sonargo/sonar/project_pull_requests_service.go:
--------------------------------------------------------------------------------
1 | // Manage pull request (only available when the Branch plugin is installed)
2 | package sonargo
3 |
4 | import "net/http"
5 |
6 | type ProjectPullRequestsService struct {
7 | client *Client
8 | }
9 |
10 | type ProjectPullRequestsListObject struct {
11 | PullRequests []*PullRequest `json:"pullRequests,omitempty"`
12 | }
13 |
14 | type PullRequest struct {
15 | AnalysisDate string `json:"analysisDate,omitempty"`
16 | Base string `json:"base,omitempty"`
17 | Branch string `json:"branch,omitempty"`
18 | Key string `json:"key,omitempty"`
19 | Status Status `json:"status,omitempty"`
20 | Title string `json:"title,omitempty"`
21 | URL string `json:"url,omitempty"`
22 | }
23 |
24 | type ProjectPullRequestsDeleteOption struct {
25 | Project string `url:"project,omitempty"` // Description:"Project key",ExampleValue:"my_project"
26 | PullRequest int `url:"pullRequest,omitempty"` // Description:"Pull request id",ExampleValue:"1543"
27 | }
28 |
29 | // Delete Delete a pull request.
Requires 'Administer' rights on the specified project.
30 | func (s *ProjectPullRequestsService) Delete(opt *ProjectPullRequestsDeleteOption) (resp *http.Response, err error) {
31 | err = s.ValidateDeleteOpt(opt)
32 | if err != nil {
33 | return
34 | }
35 | req, err := s.client.NewRequest("POST", "project_pull_requests/delete", opt)
36 | if err != nil {
37 | return
38 | }
39 | resp, err = s.client.Do(req, nil)
40 | if err != nil {
41 | return
42 | }
43 | return
44 | }
45 |
46 | type ProjectPullRequestsListOption struct {
47 | Project string `url:"project,omitempty"` // Description:"Project key",ExampleValue:"my_project"
48 | }
49 |
50 | // List List the pull requests of a project.
One of the following permissions is required: - 'Browse' rights on the specified project
- 'Execute Analysis' rights on the specified project
51 | func (s *ProjectPullRequestsService) List(opt *ProjectPullRequestsListOption) (v *ProjectPullRequestsListObject, resp *http.Response, err error) {
52 | err = s.ValidateListOpt(opt)
53 | if err != nil {
54 | return
55 | }
56 | req, err := s.client.NewRequest("GET", "project_pull_requests/list", opt)
57 | if err != nil {
58 | return
59 | }
60 | v = new(ProjectPullRequestsListObject)
61 | resp, err = s.client.Do(req, v)
62 | if err != nil {
63 | return nil, resp, err
64 | }
65 | return
66 | }
67 |
--------------------------------------------------------------------------------
/vendor/github.com/kubesphere/sonargo/sonar/project_tags_service.go:
--------------------------------------------------------------------------------
1 | // Manage project tags
2 | package sonargo
3 |
4 | import "net/http"
5 |
6 | type ProjectTagsService struct {
7 | client *Client
8 | }
9 |
10 | type ProjectTagsSearchOption struct {
11 | Ps int `url:"ps,omitempty"` // Description:"Page size. Must be greater than 0 and less or equal than 100",ExampleValue:"20"
12 | Q string `url:"q,omitempty"` // Description:"Limit search to tags that contain the supplied string.",ExampleValue:"off"
13 | }
14 |
15 | // Search Search tags
16 | func (s *ProjectTagsService) Search(opt *ProjectTagsSearchOption) (v *IssuesTagsObject, resp *http.Response, err error) {
17 | err = s.ValidateSearchOpt(opt)
18 | if err != nil {
19 | return
20 | }
21 | req, err := s.client.NewRequest("GET", "project_tags/search", opt)
22 | if err != nil {
23 | return
24 | }
25 | v = new(IssuesTagsObject)
26 | resp, err = s.client.Do(req, v)
27 | if err != nil {
28 | return nil, resp, err
29 | }
30 | return
31 | }
32 |
33 | type ProjectTagsSetOption struct {
34 | Project string `url:"project,omitempty"` // Description:"Project key",ExampleValue:"my_project"
35 | Tags *string `url:"tags,omitempty"` // Description:"Comma-separated list of tags",ExampleValue:"finance, offshore"
36 | }
37 |
38 | // Set Set tags on a project.
Requires the following permission: 'Administer' rights on the specified project
39 | func (s *ProjectTagsService) Set(opt *ProjectTagsSetOption) (resp *http.Response, err error) {
40 | err = s.ValidateSetOpt(opt)
41 | if err != nil {
42 | return
43 | }
44 | req, err := s.client.NewRequest("POST", "project_tags/set", opt)
45 | if err != nil {
46 | return
47 | }
48 | resp, err = s.client.Do(req, nil)
49 | if err != nil {
50 | return
51 | }
52 | return
53 | }
54 |
--------------------------------------------------------------------------------
/vendor/github.com/kubesphere/sonargo/sonar/server_service.go:
--------------------------------------------------------------------------------
1 | //
2 | package sonargo
3 |
4 | import "net/http"
5 |
6 | type ServerService struct {
7 | client *Client
8 | }
9 |
10 | // Version Version of SonarQube in plain text
11 | func (s *ServerService) Version() (v *string, resp *http.Response, err error) {
12 | req, err := s.client.NewRequest("GET", "server/version", nil)
13 | if err != nil {
14 | return
15 | }
16 | v = new(string)
17 | resp, err = s.client.Do(req, v)
18 | if err != nil {
19 | return nil, resp, err
20 | }
21 | return
22 | }
23 |
--------------------------------------------------------------------------------
/vendor/github.com/mitchellh/mapstructure/.travis.yml:
--------------------------------------------------------------------------------
1 | language: go
2 |
3 | go:
4 | - 1.9.x
5 | - tip
6 |
7 | script:
8 | - go test
9 |
--------------------------------------------------------------------------------
/vendor/github.com/mitchellh/mapstructure/LICENSE:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 |
3 | Copyright (c) 2013 Mitchell Hashimoto
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 |
--------------------------------------------------------------------------------
/vendor/github.com/mitchellh/mapstructure/README.md:
--------------------------------------------------------------------------------
1 | # mapstructure [](https://godoc.org/github.com/mitchellh/mapstructure)
2 |
3 | mapstructure is a Go library for decoding generic map values to structures
4 | and vice versa, while providing helpful error handling.
5 |
6 | This library is most useful when decoding values from some data stream (JSON,
7 | Gob, etc.) where you don't _quite_ know the structure of the underlying data
8 | until you read a part of it. You can therefore read a `map[string]interface{}`
9 | and use this library to decode it into the proper underlying native Go
10 | structure.
11 |
12 | ## Installation
13 |
14 | Standard `go get`:
15 |
16 | ```
17 | $ go get github.com/mitchellh/mapstructure
18 | ```
19 |
20 | ## Usage & Example
21 |
22 | For usage and examples see the [Godoc](http://godoc.org/github.com/mitchellh/mapstructure).
23 |
24 | The `Decode` function has examples associated with it there.
25 |
26 | ## But Why?!
27 |
28 | Go offers fantastic standard libraries for decoding formats such as JSON.
29 | The standard method is to have a struct pre-created, and populate that struct
30 | from the bytes of the encoded format. This is great, but the problem is if
31 | you have configuration or an encoding that changes slightly depending on
32 | specific fields. For example, consider this JSON:
33 |
34 | ```json
35 | {
36 | "type": "person",
37 | "name": "Mitchell"
38 | }
39 | ```
40 |
41 | Perhaps we can't populate a specific structure without first reading
42 | the "type" field from the JSON. We could always do two passes over the
43 | decoding of the JSON (reading the "type" first, and the rest later).
44 | However, it is much simpler to just decode this into a `map[string]interface{}`
45 | structure, read the "type" key, then use something like this library
46 | to decode it into the proper structure.
47 |
--------------------------------------------------------------------------------
/vendor/github.com/mitchellh/mapstructure/error.go:
--------------------------------------------------------------------------------
1 | package mapstructure
2 |
3 | import (
4 | "errors"
5 | "fmt"
6 | "sort"
7 | "strings"
8 | )
9 |
10 | // Error implements the error interface and can represents multiple
11 | // errors that occur in the course of a single decode.
12 | type Error struct {
13 | Errors []string
14 | }
15 |
16 | func (e *Error) Error() string {
17 | points := make([]string, len(e.Errors))
18 | for i, err := range e.Errors {
19 | points[i] = fmt.Sprintf("* %s", err)
20 | }
21 |
22 | sort.Strings(points)
23 | return fmt.Sprintf(
24 | "%d error(s) decoding:\n\n%s",
25 | len(e.Errors), strings.Join(points, "\n"))
26 | }
27 |
28 | // WrappedErrors implements the errwrap.Wrapper interface to make this
29 | // return value more useful with the errwrap and go-multierror libraries.
30 | func (e *Error) WrappedErrors() []error {
31 | if e == nil {
32 | return nil
33 | }
34 |
35 | result := make([]error, len(e.Errors))
36 | for i, e := range e.Errors {
37 | result[i] = errors.New(e)
38 | }
39 |
40 | return result
41 | }
42 |
43 | func appendErrors(errors []string, err error) []string {
44 | switch e := err.(type) {
45 | case *Error:
46 | return append(errors, e.Errors...)
47 | default:
48 | return append(errors, e.Error())
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/vendor/github.com/mitchellh/mapstructure/go.mod:
--------------------------------------------------------------------------------
1 | module github.com/mitchellh/mapstructure
2 |
--------------------------------------------------------------------------------
/vendor/github.com/pmezard/go-difflib/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2013, Patrick Mezard
2 | All rights reserved.
3 |
4 | Redistribution and use in source and binary forms, with or without
5 | modification, are permitted provided that the following conditions are
6 | met:
7 |
8 | Redistributions of source code must retain the above copyright
9 | notice, this list of conditions and the following disclaimer.
10 | Redistributions in binary form must reproduce the above copyright
11 | notice, this list of conditions and the following disclaimer in the
12 | documentation and/or other materials provided with the distribution.
13 | The names of its contributors may not be used to endorse or promote
14 | products derived from this software without specific prior written
15 | permission.
16 |
17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
18 | IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19 | TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
20 | PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 | HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
23 | TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24 | PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25 | LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26 | NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 |
--------------------------------------------------------------------------------
/vendor/github.com/sony/sonyflake/.gitignore:
--------------------------------------------------------------------------------
1 | example/sonyflake_server
2 |
--------------------------------------------------------------------------------
/vendor/github.com/sony/sonyflake/.travis.yml:
--------------------------------------------------------------------------------
1 | language: go
2 | go:
3 | - 1.5
4 | - 1.6
5 | sudo: false
6 | before_install:
7 | - go get -u github.com/golang/lint/golint
8 | - go get github.com/axw/gocov/gocov
9 | - go get github.com/mattn/goveralls
10 | script:
11 | - test -z "`gofmt -l .`"
12 | - test -z "`golint ./...`"
13 | - $GOPATH/bin/goveralls -service=travis-ci
14 | - cd example && ./linux64_build.sh
15 |
--------------------------------------------------------------------------------
/vendor/github.com/sony/sonyflake/LICENSE:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 |
3 | Copyright 2015 Sony Corporation
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 |
--------------------------------------------------------------------------------
/vendor/github.com/speps/go-hashids/.editorconfig:
--------------------------------------------------------------------------------
1 | root = true
2 |
3 | [*]
4 | indent_style = tab
5 | indent_size = 4
--------------------------------------------------------------------------------
/vendor/github.com/speps/go-hashids/.gitignore:
--------------------------------------------------------------------------------
1 | # Compiled Object files, Static and Dynamic libs (Shared Objects)
2 | *.o
3 | *.a
4 | *.so
5 |
6 | # Folders
7 | _obj
8 | _test
9 |
10 | # Architecture specific extensions/prefixes
11 | *.[568vq]
12 | [568vq].out
13 |
14 | *.cgo1.go
15 | *.cgo2.c
16 | _cgo_defun.c
17 | _cgo_gotypes.go
18 | _cgo_export.*
19 |
20 | _testmain.go
21 |
22 | *.exe
23 |
--------------------------------------------------------------------------------
/vendor/github.com/speps/go-hashids/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2014 Remi Gillig
2 |
3 | Permission is hereby granted, free of charge, to any person
4 | obtaining a copy of this software and associated documentation
5 | files (the "Software"), to deal in the Software without
6 | restriction, including without limitation the rights to use,
7 | copy, modify, merge, publish, distribute, sublicense, and/or sell
8 | copies of the Software, and to permit persons to whom the
9 | Software is furnished to do so, subject to the following
10 | conditions:
11 |
12 | The above copyright notice and this permission notice shall be
13 | included in all copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
17 | OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
19 | HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
20 | WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 | OTHER DEALINGS IN THE SOFTWARE.
23 |
--------------------------------------------------------------------------------
/vendor/github.com/speps/go-hashids/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | go-hashids [](https://ci.appveyor.com/project/speps/go-hashids) [](https://godoc.org/github.com/speps/go-hashids)
4 | ==========
5 |
6 | Go (golang) v1 implementation of http://www.hashids.org
7 | under MIT License (same as the original implementations)
8 |
9 | Original implementations by [Ivan Akimov](https://github.com/ivanakimov)
10 |
11 | ### Setup
12 | go get github.com/speps/go-hashids
13 |
14 | CLI tool :
15 |
16 | go get github.com/speps/go-hashids/cmd/hashid
17 |
18 | ### Example
19 | ```go
20 | package main
21 |
22 | import "fmt"
23 | import "github.com/speps/go-hashids"
24 |
25 | func main() {
26 | hd := hashids.NewData()
27 | hd.Salt = "this is my salt"
28 | hd.MinLength = 30
29 | h, _ := hashids.NewWithData(hd)
30 | e, _ := h.Encode([]int{45, 434, 1313, 99})
31 | fmt.Println(e)
32 | d, _ := h.DecodeWithError(e)
33 | fmt.Println(d)
34 | }
35 | ```
36 |
37 | ### Thanks to all the contributors
38 |
39 | * [Harm Aarts](https://github.com/haarts)
40 | * [Christoffer G. Thomsen](https://github.com/cgt)
41 | * [Peter Hellberg](https://github.com/peterhellberg)
42 | * [Rémy Oudompheng](https://github.com/remyoudompheng)
43 | * [Mart Roosmaa](https://github.com/roosmaa)
44 | * [Jakub Kramarz](https://github.com/jkramarz)
45 | * [Zou Xifeng](https://github.com/zouxifeng)
46 | * [Per Persson](https://github.com/md2perpe)
47 | * [Baiju Muthukadan](https://github.com/baijum)
48 | * [Pablo de la Concepción Sanz](https://github.com/pconcepcion)
49 | * [Olivier Mengué](https://github.com/dolmen)
50 | * [Matthew Valimaki](https://github.com/matthewvalimaki)
51 | * [Cody Maloney](https://github.com/cmaloney)
52 |
53 | Let me know if I forgot anyone of course.
54 |
55 | ### Changelog
56 |
57 | 2017/05/09
58 |
59 | * Changed API
60 | * `New` methods now return errors
61 | * Added sanity check in `Decode` that makes sure that the salt is consistent
62 |
63 | 2014/09/13
64 |
65 | * Updated to Hashids v1.0.0 (should be compatible with other implementations, let me know if not, was checked against the Javascript version)
66 | * Changed API
67 | * Encrypt/Decrypt are now Encode/Decode
68 | * HashID is now constructed from HashIDData containing alphabet, salt and minimum length
69 |
--------------------------------------------------------------------------------
/vendor/github.com/stretchr/testify/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2012 - 2013 Mat Ryer and Tyler Bunnell
2 |
3 | Please consider promoting this project if you find it useful.
4 |
5 | Permission is hereby granted, free of charge, to any person
6 | obtaining a copy of this software and associated documentation
7 | files (the "Software"), to deal in the Software without restriction,
8 | including without limitation the rights to use, copy, modify, merge,
9 | publish, distribute, sublicense, and/or sell copies of the Software,
10 | and to permit persons to whom the Software is furnished to do so,
11 | subject to the following conditions:
12 |
13 | The above copyright notice and this permission notice shall be included
14 | in all copies or substantial portions of the Software.
15 |
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
18 | OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
20 | DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
21 | OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
22 | OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 |
--------------------------------------------------------------------------------
/vendor/github.com/stretchr/testify/assert/assertion_format.go.tmpl:
--------------------------------------------------------------------------------
1 | {{.CommentFormat}}
2 | func {{.DocInfo.Name}}f(t TestingT, {{.ParamsFormat}}) bool {
3 | if h, ok := t.(tHelper); ok { h.Helper() }
4 | return {{.DocInfo.Name}}(t, {{.ForwardedParamsFormat}})
5 | }
6 |
--------------------------------------------------------------------------------
/vendor/github.com/stretchr/testify/assert/assertion_forward.go.tmpl:
--------------------------------------------------------------------------------
1 | {{.CommentWithoutT "a"}}
2 | func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) bool {
3 | if h, ok := a.t.(tHelper); ok { h.Helper() }
4 | return {{.DocInfo.Name}}(a.t, {{.ForwardedParams}})
5 | }
6 |
--------------------------------------------------------------------------------
/vendor/github.com/stretchr/testify/assert/doc.go:
--------------------------------------------------------------------------------
1 | // Package assert provides a set of comprehensive testing tools for use with the normal Go testing system.
2 | //
3 | // Example Usage
4 | //
5 | // The following is a complete example using assert in a standard test function:
6 | // import (
7 | // "testing"
8 | // "github.com/stretchr/testify/assert"
9 | // )
10 | //
11 | // func TestSomething(t *testing.T) {
12 | //
13 | // var a string = "Hello"
14 | // var b string = "Hello"
15 | //
16 | // assert.Equal(t, a, b, "The two words should be the same.")
17 | //
18 | // }
19 | //
20 | // if you assert many times, use the format below:
21 | //
22 | // import (
23 | // "testing"
24 | // "github.com/stretchr/testify/assert"
25 | // )
26 | //
27 | // func TestSomething(t *testing.T) {
28 | // assert := assert.New(t)
29 | //
30 | // var a string = "Hello"
31 | // var b string = "Hello"
32 | //
33 | // assert.Equal(a, b, "The two words should be the same.")
34 | // }
35 | //
36 | // Assertions
37 | //
38 | // Assertions allow you to easily write test code, and are global funcs in the `assert` package.
39 | // All assertion functions take, as the first argument, the `*testing.T` object provided by the
40 | // testing framework. This allows the assertion funcs to write the failings and other details to
41 | // the correct place.
42 | //
43 | // Every assertion function also takes an optional string message as the final argument,
44 | // allowing custom error messages to be appended to the message the assertion method outputs.
45 | package assert
46 |
--------------------------------------------------------------------------------
/vendor/github.com/stretchr/testify/assert/errors.go:
--------------------------------------------------------------------------------
1 | package assert
2 |
3 | import (
4 | "errors"
5 | )
6 |
7 | // AnError is an error instance useful for testing. If the code does not care
8 | // about error specifics, and only needs to return the error for example, this
9 | // error should be used to make the test code more readable.
10 | var AnError = errors.New("assert.AnError general error for testing")
11 |
--------------------------------------------------------------------------------
/vendor/github.com/stretchr/testify/assert/forward_assertions.go:
--------------------------------------------------------------------------------
1 | package assert
2 |
3 | // Assertions provides assertion methods around the
4 | // TestingT interface.
5 | type Assertions struct {
6 | t TestingT
7 | }
8 |
9 | // New makes a new Assertions object for the specified TestingT.
10 | func New(t TestingT) *Assertions {
11 | return &Assertions{
12 | t: t,
13 | }
14 | }
15 |
16 | //go:generate go run ../_codegen/main.go -output-package=assert -template=assertion_forward.go.tmpl -include-format-funcs
17 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/AUTHORS:
--------------------------------------------------------------------------------
1 | # This source code refers to The Go Authors for copyright purposes.
2 | # The master list of authors is in the main Go distribution,
3 | # visible at http://tip.golang.org/AUTHORS.
4 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/CONTRIBUTORS:
--------------------------------------------------------------------------------
1 | # This source code was written by the Go contributors.
2 | # The master list of contributors is in the main Go distribution,
3 | # visible at http://tip.golang.org/CONTRIBUTORS.
4 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2009 The Go Authors. All rights reserved.
2 |
3 | Redistribution and use in source and binary forms, with or without
4 | modification, are permitted provided that the following conditions are
5 | met:
6 |
7 | * Redistributions of source code must retain the above copyright
8 | notice, this list of conditions and the following disclaimer.
9 | * Redistributions in binary form must reproduce the above
10 | copyright notice, this list of conditions and the following disclaimer
11 | in the documentation and/or other materials provided with the
12 | distribution.
13 | * Neither the name of Google Inc. nor the names of its
14 | contributors may be used to endorse or promote products derived from
15 | this software without specific prior written permission.
16 |
17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/PATENTS:
--------------------------------------------------------------------------------
1 | Additional IP Rights Grant (Patents)
2 |
3 | "This implementation" means the copyrightable works distributed by
4 | Google as part of the Go project.
5 |
6 | Google hereby grants to You a perpetual, worldwide, non-exclusive,
7 | no-charge, royalty-free, irrevocable (except as stated in this section)
8 | patent license to make, have made, use, offer to sell, sell, import,
9 | transfer and otherwise run, modify and propagate the contents of this
10 | implementation of Go, where such license applies only to those patent
11 | claims, both currently owned or controlled by Google and acquired in
12 | the future, licensable by Google that are necessarily infringed by this
13 | implementation of Go. This grant does not include claims that would be
14 | infringed only as a consequence of further modification of this
15 | implementation. If you or your agent or exclusive licensee institute or
16 | order or agree to the institution of patent litigation against any
17 | entity (including a cross-claim or counterclaim in a lawsuit) alleging
18 | that this implementation of Go or any code incorporated within this
19 | implementation of Go constitutes direct or contributory patent
20 | infringement, or inducement of patent infringement, then any patent
21 | rights granted to you under this License for this implementation of Go
22 | shall terminate as of the date such litigation is filed.
23 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/atom/atom.go:
--------------------------------------------------------------------------------
1 | // Copyright 2012 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // Package atom provides integer codes (also known as atoms) for a fixed set of
6 | // frequently occurring HTML strings: tag names and attribute keys such as "p"
7 | // and "id".
8 | //
9 | // Sharing an atom's name between all elements with the same tag can result in
10 | // fewer string allocations when tokenizing and parsing HTML. Integer
11 | // comparisons are also generally faster than string comparisons.
12 | //
13 | // The value of an atom's particular code is not guaranteed to stay the same
14 | // between versions of this package. Neither is any ordering guaranteed:
15 | // whether atom.H1 < atom.H2 may also change. The codes are not guaranteed to
16 | // be dense. The only guarantees are that e.g. looking up "div" will yield
17 | // atom.Div, calling atom.Div.String will return "div", and atom.Div != 0.
18 | package atom // import "golang.org/x/net/html/atom"
19 |
20 | // Atom is an integer code for a string. The zero value maps to "".
21 | type Atom uint32
22 |
23 | // String returns the atom's name.
24 | func (a Atom) String() string {
25 | start := uint32(a >> 8)
26 | n := uint32(a & 0xff)
27 | if start+n > uint32(len(atomText)) {
28 | return ""
29 | }
30 | return atomText[start : start+n]
31 | }
32 |
33 | func (a Atom) string() string {
34 | return atomText[a>>8 : a>>8+a&0xff]
35 | }
36 |
37 | // fnv computes the FNV hash with an arbitrary starting value h.
38 | func fnv(h uint32, s []byte) uint32 {
39 | for i := range s {
40 | h ^= uint32(s[i])
41 | h *= 16777619
42 | }
43 | return h
44 | }
45 |
46 | func match(s string, t []byte) bool {
47 | for i, c := range t {
48 | if s[i] != c {
49 | return false
50 | }
51 | }
52 | return true
53 | }
54 |
55 | // Lookup returns the atom whose name is s. It returns zero if there is no
56 | // such atom. The lookup is case sensitive.
57 | func Lookup(s []byte) Atom {
58 | if len(s) == 0 || len(s) > maxAtomLen {
59 | return 0
60 | }
61 | h := fnv(hash0, s)
62 | if a := table[h&uint32(len(table)-1)]; int(a&0xff) == len(s) && match(a.string(), s) {
63 | return a
64 | }
65 | if a := table[(h>>16)&uint32(len(table)-1)]; int(a&0xff) == len(s) && match(a.string(), s) {
66 | return a
67 | }
68 | return 0
69 | }
70 |
71 | // String returns a string whose contents are equal to s. In that sense, it is
72 | // equivalent to string(s) but may be more efficient.
73 | func String(s []byte) string {
74 | if a := Lookup(s); a != 0 {
75 | return a.String()
76 | }
77 | return string(s)
78 | }
79 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/appengine/cloudsql/cloudsql.go:
--------------------------------------------------------------------------------
1 | // Copyright 2013 Google Inc. All rights reserved.
2 | // Use of this source code is governed by the Apache 2.0
3 | // license that can be found in the LICENSE file.
4 |
5 | /*
6 | Package cloudsql exposes access to Google Cloud SQL databases.
7 |
8 | This package does not work in App Engine "flexible environment".
9 |
10 | This package is intended for MySQL drivers to make App Engine-specific
11 | connections. Applications should use this package through database/sql:
12 | Select a pure Go MySQL driver that supports this package, and use sql.Open
13 | with protocol "cloudsql" and an address of the Cloud SQL instance.
14 |
15 | A Go MySQL driver that has been tested to work well with Cloud SQL
16 | is the go-sql-driver:
17 | import "database/sql"
18 | import _ "github.com/go-sql-driver/mysql"
19 |
20 | db, err := sql.Open("mysql", "user@cloudsql(project-id:instance-name)/dbname")
21 |
22 |
23 | Another driver that works well with Cloud SQL is the mymysql driver:
24 | import "database/sql"
25 | import _ "github.com/ziutek/mymysql/godrv"
26 |
27 | db, err := sql.Open("mymysql", "cloudsql:instance-name*dbname/user/password")
28 |
29 |
30 | Using either of these drivers, you can perform a standard SQL query.
31 | This example assumes there is a table named 'users' with
32 | columns 'first_name' and 'last_name':
33 |
34 | rows, err := db.Query("SELECT first_name, last_name FROM users")
35 | if err != nil {
36 | log.Errorf(ctx, "db.Query: %v", err)
37 | }
38 | defer rows.Close()
39 |
40 | for rows.Next() {
41 | var firstName string
42 | var lastName string
43 | if err := rows.Scan(&firstName, &lastName); err != nil {
44 | log.Errorf(ctx, "rows.Scan: %v", err)
45 | continue
46 | }
47 | log.Infof(ctx, "First: %v - Last: %v", firstName, lastName)
48 | }
49 | if err := rows.Err(); err != nil {
50 | log.Errorf(ctx, "Row error: %v", err)
51 | }
52 | */
53 | package cloudsql
54 |
55 | import (
56 | "net"
57 | )
58 |
59 | // Dial connects to the named Cloud SQL instance.
60 | func Dial(instance string) (net.Conn, error) {
61 | return connect(instance)
62 | }
63 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/appengine/cloudsql/cloudsql_classic.go:
--------------------------------------------------------------------------------
1 | // Copyright 2013 Google Inc. All rights reserved.
2 | // Use of this source code is governed by the Apache 2.0
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build appengine
6 |
7 | package cloudsql
8 |
9 | import (
10 | "net"
11 |
12 | "appengine/cloudsql"
13 | )
14 |
15 | func connect(instance string) (net.Conn, error) {
16 | return cloudsql.Dial(instance)
17 | }
18 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/appengine/cloudsql/cloudsql_vm.go:
--------------------------------------------------------------------------------
1 | // Copyright 2013 Google Inc. All rights reserved.
2 | // Use of this source code is governed by the Apache 2.0
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !appengine
6 |
7 | package cloudsql
8 |
9 | import (
10 | "errors"
11 | "net"
12 | )
13 |
14 | func connect(instance string) (net.Conn, error) {
15 | return nil, errors.New(`cloudsql: not supported in App Engine "flexible environment"`)
16 | }
17 |
--------------------------------------------------------------------------------
/vendor/gopkg.in/yaml.v2/.travis.yml:
--------------------------------------------------------------------------------
1 | language: go
2 |
3 | go:
4 | - 1.4
5 | - 1.5
6 | - 1.6
7 | - 1.7
8 | - 1.8
9 | - 1.9
10 | - tip
11 |
12 | go_import_path: gopkg.in/yaml.v2
13 |
--------------------------------------------------------------------------------
/vendor/gopkg.in/yaml.v2/LICENSE.libyaml:
--------------------------------------------------------------------------------
1 | The following files were ported to Go from C files of libyaml, and thus
2 | are still covered by their original copyright and license:
3 |
4 | apic.go
5 | emitterc.go
6 | parserc.go
7 | readerc.go
8 | scannerc.go
9 | writerc.go
10 | yamlh.go
11 | yamlprivateh.go
12 |
13 | Copyright (c) 2006 Kirill Simonov
14 |
15 | Permission is hereby granted, free of charge, to any person obtaining a copy of
16 | this software and associated documentation files (the "Software"), to deal in
17 | the Software without restriction, including without limitation the rights to
18 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
19 | of the Software, and to permit persons to whom the Software is furnished to do
20 | so, subject to the following conditions:
21 |
22 | The above copyright notice and this permission notice shall be included in all
23 | copies or substantial portions of the Software.
24 |
25 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
26 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
27 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
28 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
29 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
30 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31 | SOFTWARE.
32 |
--------------------------------------------------------------------------------
/vendor/gopkg.in/yaml.v2/NOTICE:
--------------------------------------------------------------------------------
1 | Copyright 2011-2016 Canonical Ltd.
2 |
3 | Licensed under the Apache License, Version 2.0 (the "License");
4 | you may not use this file except in compliance with the License.
5 | You may obtain a copy of the License at
6 |
7 | http://www.apache.org/licenses/LICENSE-2.0
8 |
9 | Unless required by applicable law or agreed to in writing, software
10 | distributed under the License is distributed on an "AS IS" BASIS,
11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | See the License for the specific language governing permissions and
13 | limitations under the License.
14 |
--------------------------------------------------------------------------------
/vendor/gopkg.in/yaml.v2/go.mod:
--------------------------------------------------------------------------------
1 | module "gopkg.in/yaml.v2"
2 |
3 | require (
4 | "gopkg.in/check.v1" v0.0.0-20161208181325-20d25e280405
5 | )
6 |
--------------------------------------------------------------------------------
/vendor/gopkg.in/yaml.v2/writerc.go:
--------------------------------------------------------------------------------
1 | package yaml
2 |
3 | // Set the writer error and return false.
4 | func yaml_emitter_set_writer_error(emitter *yaml_emitter_t, problem string) bool {
5 | emitter.error = yaml_WRITER_ERROR
6 | emitter.problem = problem
7 | return false
8 | }
9 |
10 | // Flush the output buffer.
11 | func yaml_emitter_flush(emitter *yaml_emitter_t) bool {
12 | if emitter.write_handler == nil {
13 | panic("write handler not set")
14 | }
15 |
16 | // Check if the buffer is empty.
17 | if emitter.buffer_pos == 0 {
18 | return true
19 | }
20 |
21 | if err := emitter.write_handler(emitter, emitter.buffer[:emitter.buffer_pos]); err != nil {
22 | return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error())
23 | }
24 | emitter.buffer_pos = 0
25 | return true
26 | }
27 |
--------------------------------------------------------------------------------
