Bump go-openapi dependencies to preferred version

Signed-off-by: He Xiaoxi <xxhe@alauda.io>

vendor/github.com/go-openapi/swag/.golangci.yml

@@ -18,3 +18,5 @@ linters:
   disable:
     - maligned
     - lll
+    - gochecknoinits
+    - gochecknoglobals

vendor/github.com/go-openapi/swag/.travis.yml

@@ -1,16 +1,15 @@
 after_success:
 - bash <(curl -s https://codecov.io/bash)
 go:
-- '1.9'
-- 1.10.x
 - 1.11.x
+- 1.12.x
 install:
-- go get -u github.com/stretchr/testify
-- go get -u github.com/mailru/easyjson
-- go get -u gopkg.in/yaml.v2
+- GO111MODULE=off go get -u gotest.tools/gotestsum
+env:
+- GO111MODULE=on
 language: go
 notifications:
   slack:
     secure: QUWvCkBBK09GF7YtEvHHVt70JOkdlNBG0nIKu/5qc4/nW5HP8I2w0SEf/XR2je0eED1Qe3L/AfMCWwrEj+IUZc3l4v+ju8X8R3Lomhme0Eb0jd1MTMCuPcBT47YCj0M7RON7vXtbFfm1hFJ/jLe5+9FXz0hpXsR24PJc5ZIi/ogNwkaPqG4BmndzecpSh0vc2FJPZUD9LT0I09REY/vXR0oQAalLkW0asGD5taHZTUZq/kBpsNxaAFrLM23i4mUcf33M5fjLpvx5LRICrX/57XpBrDh2TooBU6Qj3CgoY0uPRYUmSNxbVx1czNzl2JtEpb5yjoxfVPQeg0BvQM00G8LJINISR+ohrjhkZmAqchDupAX+yFrxTtORa78CtnIL6z/aTNlgwwVD8kvL/1pFA/JWYmKDmz93mV/+6wubGzNSQCstzjkFA4/iZEKewKUoRIAi/fxyscP6L/rCpmY/4llZZvrnyTqVbt6URWpopUpH4rwYqreXAtJxJsfBJIeSmUIiDIOMGkCTvyTEW3fWGmGoqWtSHLoaWDyAIGb7azb+KvfpWtEcoPFWfSWU+LGee0A/YsUhBl7ADB9A0CJEuR8q4BPpKpfLwPKSiKSAXL7zDkyjExyhtgqbSl2jS+rKIHOZNL8JkCcTP2MKMVd563C5rC5FMKqu3S9m2b6380E=
 script:
-- go test -v -race -cover -coverprofile=coverage.txt -covermode=atomic ./...
+- gotestsum -f short-verbose -- -race -coverprofile=coverage.txt -covermode=atomic ./...

vendor/github.com/go-openapi/swag/BUILD

@@ -8,12 +8,14 @@ go_library(
         "doc.go",
         "json.go",
         "loading.go",
+        "name_lexem.go",
         "net.go",
         "path.go",
         "post_go18.go",
         "post_go19.go",
         "pre_go18.go",
         "pre_go19.go",
+        "split.go",
         "util.go",
         "yaml.go",
     ],

vendor/github.com/go-openapi/swag/README.md

@@ -19,5 +19,4 @@ You may also use it standalone for your projects.
 
 This repo has only few dependencies outside of the standard library:
 
-* JSON utilities depend on github.com/mailru/easyjson
 * YAML utilities depend on gopkg.in/yaml.v2

vendor/github.com/go-openapi/swag/doc.go

@@ -27,7 +27,6 @@ You may also use it standalone for your projects.
 
 This repo has only few dependencies outside of the standard library:
 
-  * JSON utilities depend on github.com/mailru/easyjson
   * YAML utilities depend on gopkg.in/yaml.v2
 */
 package swag

vendor/github.com/go-openapi/swag/go.mod

@@ -2,8 +2,13 @@ module github.com/go-openapi/swag
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/mailru/easyjson v0.0.0-20180823135443-60711f1a8329
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/stretchr/testify v1.2.2
-	gopkg.in/yaml.v2 v2.2.1
+	github.com/kr/pretty v0.1.0 // indirect
+	github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63
+	github.com/stretchr/testify v1.3.0
+	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
+	gopkg.in/yaml.v2 v2.2.2
 )
+
+replace github.com/golang/lint => golang.org/x/lint v0.0.0-20190409202823-959b441ac422
+
+replace sourcegraph.com/sourcegraph/go-diff => github.com/sourcegraph/go-diff v0.5.1

vendor/github.com/go-openapi/swag/go.sum

@@ -1,9 +1,20 @@
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/mailru/easyjson v0.0.0-20180823135443-60711f1a8329 h1:2gxZ0XQIU/5z3Z3bUBu+FXuk2pFbkN6tcwi/pjyaDic=
-github.com/mailru/easyjson v0.0.0-20180823135443-60711f1a8329/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63 h1:nTT4s92Dgz2HlrB2NaMgvlfqHH39OgMhA7z3PK7PGD4=
+github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

vendor/github.com/go-openapi/swag/json.go

@@ -68,15 +68,16 @@ func WriteJSON(data interface{}) ([]byte, error) {
 // ReadJSON reads json data, prefers finding an appropriate interface to short-circuit the unmarshaller
 // so it takes the fastes option available
 func ReadJSON(data []byte, value interface{}) error {
+	trimmedData := bytes.Trim(data, "\x00")
 	if d, ok := value.(ejUnmarshaler); ok {
-		jl := &jlexer.Lexer{Data: data}
+		jl := &jlexer.Lexer{Data: trimmedData}
 		d.UnmarshalEasyJSON(jl)
 		return jl.Error()
 	}
 	if d, ok := value.(json.Unmarshaler); ok {
-		return d.UnmarshalJSON(data)
+		return d.UnmarshalJSON(trimmedData)
 	}
-	return json.Unmarshal(data, value)
+	return json.Unmarshal(trimmedData, value)
 }
 
 // DynamicJSONToStruct converts an untyped json structure into a struct

vendor/github.com/go-openapi/swag/name_lexem.go

@@ -0,0 +1,87 @@
+// Copyright 2015 go-swagger maintainers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package swag
+
+import "unicode"
+
+type (
+	nameLexem interface {
+		GetUnsafeGoName() string
+		GetOriginal() string
+		IsInitialism() bool
+	}
+
+	initialismNameLexem struct {
+		original          string
+		matchedInitialism string
+	}
+
+	casualNameLexem struct {
+		original string
+	}
+)
+
+func newInitialismNameLexem(original, matchedInitialism string) *initialismNameLexem {
+	return &initialismNameLexem{
+		original:          original,
+		matchedInitialism: matchedInitialism,
+	}
+}
+
+func newCasualNameLexem(original string) *casualNameLexem {
+	return &casualNameLexem{
+		original: original,
+	}
+}
+
+func (l *initialismNameLexem) GetUnsafeGoName() string {
+	return l.matchedInitialism
+}
+
+func (l *casualNameLexem) GetUnsafeGoName() string {
+	var first rune
+	var rest string
+	for i, orig := range l.original {
+		if i == 0 {
+			first = orig
+			continue
+		}
+		if i > 0 {
+			rest = l.original[i:]
+			break
+		}
+	}
+	if len(l.original) > 1 {
+		return string(unicode.ToUpper(first)) + lower(rest)
+	}
+
+	return l.original
+}
+
+func (l *initialismNameLexem) GetOriginal() string {
+	return l.original
+}
+
+func (l *casualNameLexem) GetOriginal() string {
+	return l.original
+}
+
+func (l *initialismNameLexem) IsInitialism() bool {
+	return true
+}
+
+func (l *casualNameLexem) IsInitialism() bool {
+	return false
+}

vendor/github.com/go-openapi/swag/net.go

@@ -1,3 +1,17 @@
+// Copyright 2015 go-swagger maintainers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package swag
 
 import (

vendor/github.com/go-openapi/swag/post_go18.go

@@ -1,3 +1,17 @@
+// Copyright 2015 go-swagger maintainers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 // +build go1.8
 
 package swag

vendor/github.com/go-openapi/swag/post_go19.go

@@ -1,3 +1,17 @@
+// Copyright 2015 go-swagger maintainers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 // +build go1.9
 
 package swag
@@ -48,6 +62,6 @@ func (m *indexOfInitialisms) sorted() (result []string) {
 		result = append(result, k)
 		return true
 	})
-	sort.Sort(sort.Reverse(byLength(result)))
+	sort.Sort(sort.Reverse(byInitialism(result)))
 	return
 }

vendor/github.com/go-openapi/swag/pre_go18.go

@@ -1,3 +1,17 @@
+// Copyright 2015 go-swagger maintainers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 // +build !go1.8
 
 package swag

vendor/github.com/go-openapi/swag/pre_go19.go

@@ -1,3 +1,17 @@
+// Copyright 2015 go-swagger maintainers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 // +build !go1.9
 
 package swag
@@ -50,6 +64,6 @@ func (m *indexOfInitialisms) sorted() (result []string) {
 	for k := range m.index {
 		result = append(result, k)
 	}
-	sort.Sort(sort.Reverse(byLength(result)))
+	sort.Sort(sort.Reverse(byInitialism(result)))
 	return
 }

vendor/github.com/go-openapi/swag/split.go

@@ -0,0 +1,262 @@
+// Copyright 2015 go-swagger maintainers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package swag
+
+import (
+	"unicode"
+)
+
+var nameReplaceTable = map[rune]string{
+	'@': "At ",
+	'&': "And ",
+	'|': "Pipe ",
+	'$': "Dollar ",
+	'!': "Bang ",
+	'-': "",
+	'_': "",
+}
+
+type (
+	splitter struct {
+		postSplitInitialismCheck bool
+		initialisms              []string
+	}
+
+	splitterOption func(*splitter) *splitter
+)
+
+// split calls the splitter; splitter provides more control and post options
+func split(str string) []string {
+	lexems := newSplitter().split(str)
+	result := make([]string, 0, len(lexems))
+
+	for _, lexem := range lexems {
+		result = append(result, lexem.GetOriginal())
+	}
+
+	return result
+
+}
+
+func (s *splitter) split(str string) []nameLexem {
+	return s.toNameLexems(str)
+}
+
+func newSplitter(options ...splitterOption) *splitter {
+	splitter := &splitter{
+		postSplitInitialismCheck: false,
+		initialisms:              initialisms,
+	}
+
+	for _, option := range options {
+		splitter = option(splitter)
+	}
+
+	return splitter
+}
+
+// withPostSplitInitialismCheck allows to catch initialisms after main split process
+func withPostSplitInitialismCheck(s *splitter) *splitter {
+	s.postSplitInitialismCheck = true
+	return s
+}
+
+type (
+	initialismMatch struct {
+		start, end int
+		body       []rune
+		complete   bool
+	}
+	initialismMatches []*initialismMatch
+)
+
+func (s *splitter) toNameLexems(name string) []nameLexem {
+	nameRunes := []rune(name)
+	matches := s.gatherInitialismMatches(nameRunes)
+	return s.mapMatchesToNameLexems(nameRunes, matches)
+}
+
+func (s *splitter) gatherInitialismMatches(nameRunes []rune) initialismMatches {
+	matches := make(initialismMatches, 0)
+
+	for currentRunePosition, currentRune := range nameRunes {
+		newMatches := make(initialismMatches, 0, len(matches))
+
+		// check current initialism matches
+		for _, match := range matches {
+			if keepCompleteMatch := match.complete; keepCompleteMatch {
+				newMatches = append(newMatches, match)
+				continue
+			}
+
+			// drop failed match
+			currentMatchRune := match.body[currentRunePosition-match.start]
+			if !s.initialismRuneEqual(currentMatchRune, currentRune) {
+				continue
+			}
+
+			// try to complete ongoing match
+			if currentRunePosition-match.start == len(match.body)-1 {
+				// we are close; the next step is to check the symbol ahead
+				// if it is a small letter, then it is not the end of match
+				// but beginning of the next word
+
+				if currentRunePosition < len(nameRunes)-1 {
+					nextRune := nameRunes[currentRunePosition+1]
+					if newWord := unicode.IsLower(nextRune); newWord {
+						// oh ok, it was the start of a new word
+						continue
+					}
+				}
+
+				match.complete = true
+				match.end = currentRunePosition
+			}
+
+			newMatches = append(newMatches, match)
+		}
+
+		// check for new initialism matches
+		for _, initialism := range s.initialisms {
+			initialismRunes := []rune(initialism)
+			if s.initialismRuneEqual(initialismRunes[0], currentRune) {
+				newMatches = append(newMatches, &initialismMatch{
+					start:    currentRunePosition,
+					body:     initialismRunes,
+					complete: false,
+				})
+			}
+		}
+
+		matches = newMatches
+	}
+
+	return matches
+}
+
+func (s *splitter) mapMatchesToNameLexems(nameRunes []rune, matches initialismMatches) []nameLexem {
+	nameLexems := make([]nameLexem, 0)
+
+	var lastAcceptedMatch *initialismMatch
+	for _, match := range matches {
+		if !match.complete {
+			continue
+		}
+
+		if firstMatch := lastAcceptedMatch == nil; firstMatch {
+			nameLexems = append(nameLexems, s.breakCasualString(nameRunes[:match.start])...)
+			nameLexems = append(nameLexems, s.breakInitialism(string(match.body)))
+
+			lastAcceptedMatch = match
+
+			continue
+		}
+
+		if overlappedMatch := match.start <= lastAcceptedMatch.end; overlappedMatch {
+			continue
+		}
+
+		middle := nameRunes[lastAcceptedMatch.end+1 : match.start]
+		nameLexems = append(nameLexems, s.breakCasualString(middle)...)
+		nameLexems = append(nameLexems, s.breakInitialism(string(match.body)))
+
+		lastAcceptedMatch = match
+	}
+
+	// we have not found any accepted matches
+	if lastAcceptedMatch == nil {
+		return s.breakCasualString(nameRunes)
+	}
+
+	if lastAcceptedMatch.end+1 != len(nameRunes) {
+		rest := nameRunes[lastAcceptedMatch.end+1:]
+		nameLexems = append(nameLexems, s.breakCasualString(rest)...)
+	}
+
+	return nameLexems
+}
+
+func (s *splitter) initialismRuneEqual(a, b rune) bool {
+	return a == b
+}
+
+func (s *splitter) breakInitialism(original string) nameLexem {
+	return newInitialismNameLexem(original, original)
+}
+
+func (s *splitter) breakCasualString(str []rune) []nameLexem {
+	segments := make([]nameLexem, 0)
+	currentSegment := ""
+
+	addCasualNameLexem := func(original string) {
+		segments = append(segments, newCasualNameLexem(original))
+	}
+
+	addInitialismNameLexem := func(original, match string) {
+		segments = append(segments, newInitialismNameLexem(original, match))
+	}
+
+	addNameLexem := func(original string) {
+		if s.postSplitInitialismCheck {
+			for _, initialism := range s.initialisms {
+				if upper(initialism) == upper(original) {
+					addInitialismNameLexem(original, initialism)
+					return
+				}
+			}
+		}
+
+		addCasualNameLexem(original)
+	}
+
+	for _, rn := range string(str) {
+		if replace, found := nameReplaceTable[rn]; found {
+			if currentSegment != "" {
+				addNameLexem(currentSegment)
+				currentSegment = ""
+			}
+
+			if replace != "" {
+				addNameLexem(replace)
+			}
+
+			continue
+		}
+
+		if !unicode.In(rn, unicode.L, unicode.M, unicode.N, unicode.Pc) {
+			if currentSegment != "" {
+				addNameLexem(currentSegment)
+				currentSegment = ""
+			}
+
+			continue
+		}
+
+		if unicode.IsUpper(rn) {
+			if currentSegment != "" {
+				addNameLexem(currentSegment)
+			}
+			currentSegment = ""
+		}
+
+		currentSegment += string(rn)
+	}
+
+	if currentSegment != "" {
+		addNameLexem(currentSegment)
+	}
+
+	return segments
+}

vendor/github.com/go-openapi/swag/util.go

@@ -15,11 +15,8 @@
 package swag
 
 import (
-	"math"
 	"reflect"
-	"regexp"
 	"strings"
-	"sync"
 	"unicode"
 )
 
@@ -29,8 +26,6 @@ var commonInitialisms *indexOfInitialisms
 // initialisms is a slice of sorted initialisms
 var initialisms []string
 
-var once sync.Once
-
 var isInitialism func(string) bool
 
 func init() {
@@ -49,6 +44,8 @@ func init() {
 		"HTTP":  true,
 		"ID":    true,
 		"IP":    true,
+		"IPv4":  true,
+		"IPv6":  true,
 		"JSON":  true,
 		"LHS":   true,
 		"OAI":   true,
@@ -79,15 +76,12 @@ func init() {
 
 	// a thread-safe index of initialisms
 	commonInitialisms = newIndexOfInitialisms().load(configuredInitialisms)
+	initialisms = commonInitialisms.sorted()
 
 	// a test function
 	isInitialism = commonInitialisms.isInitialism
 }
 
-func ensureSorted() {
-	initialisms = commonInitialisms.sorted()
-}
-
 const (
 	//collectionFormatComma = "csv"
 	collectionFormatSpace = "ssv"
@@ -153,49 +147,20 @@ func SplitByFormat(data, format string) []string {
 	return result
 }
 
-type byLength []string
+type byInitialism []string
 
-func (s byLength) Len() int {
+func (s byInitialism) Len() int {
 	return len(s)
 }
-func (s byLength) Swap(i, j int) {
+func (s byInitialism) Swap(i, j int) {
 	s[i], s[j] = s[j], s[i]
 }
-func (s byLength) Less(i, j int) bool {
-	return len(s[i]) < len(s[j])
-}
-
-// Prepares strings by splitting by caps, spaces, dashes, and underscore
-func split(str string) []string {
-	repl := strings.NewReplacer(
-		"@", "At ",
-		"&", "And ",
-		"|", "Pipe ",
-		"$", "Dollar ",
-		"!", "Bang ",
-		"-", " ",
-		"_", " ",
-	)
-
-	rex1 := regexp.MustCompile(`(\p{Lu})`)
-	rex2 := regexp.MustCompile(`(\pL|\pM|\pN|\p{Pc})+`)
-
-	str = trim(str)
-
-	// Convert dash and underscore to spaces
-	str = repl.Replace(str)
-
-	// Split when uppercase is found (needed for Snake)
-	str = rex1.ReplaceAllString(str, " $1")
-
-	// check if consecutive single char things make up an initialism
-	once.Do(ensureSorted)
-	for _, k := range initialisms {
-		str = strings.Replace(str, rex1.ReplaceAllString(k, " $1"), " "+k, -1)
+func (s byInitialism) Less(i, j int) bool {
+	if len(s[i]) != len(s[j]) {
+		return len(s[i]) < len(s[j])
 	}
-	// Get the final list of words
-	//words = rex2.FindAllString(str, -1)
-	return rex2.FindAllString(str, -1)
+
+	return strings.Compare(s[i], s[j]) > 0
 }
 
 // Removes leading whitespaces
@@ -215,7 +180,7 @@ func lower(str string) string {
 
 // Camelize an uppercased word
 func Camelize(word string) (camelized string) {
-	for pos, ru := range word {
+	for pos, ru := range []rune(word) {
 		if pos > 0 {
 			camelized += string(unicode.ToLower(ru))
 		} else {
@@ -250,30 +215,31 @@ func ToCommandName(name string) string {
 
 // ToHumanNameLower represents a code name as a human series of words
 func ToHumanNameLower(name string) string {
-	in := split(name)
+	in := newSplitter(withPostSplitInitialismCheck).split(name)
 	out := make([]string, 0, len(in))
 
 	for _, w := range in {
-		if !isInitialism(upper(w)) {
-			out = append(out, lower(w))
+		if !w.IsInitialism() {
+			out = append(out, lower(w.GetOriginal()))
 		} else {
-			out = append(out, w)
+			out = append(out, w.GetOriginal())
 		}
 	}
+
 	return strings.Join(out, " ")
 }
 
 // ToHumanNameTitle represents a code name as a human series of words with the first letters titleized
 func ToHumanNameTitle(name string) string {
-	in := split(name)
-	out := make([]string, 0, len(in))
+	in := newSplitter(withPostSplitInitialismCheck).split(name)
 
+	out := make([]string, 0, len(in))
 	for _, w := range in {
-		uw := upper(w)
-		if !isInitialism(uw) {
-			out = append(out, upper(w[:1])+lower(w[1:]))
+		original := w.GetOriginal()
+		if !w.IsInitialism() {
+			out = append(out, Camelize(original))
 		} else {
-			out = append(out, w)
+			out = append(out, original)
 		}
 	}
 	return strings.Join(out, " ")
@@ -289,7 +255,7 @@ func ToJSONName(name string) string {
 			out = append(out, lower(w))
 			continue
 		}
-		out = append(out, upper(w[:1])+lower(w[1:]))
+		out = append(out, Camelize(w))
 	}
 	return strings.Join(out, "")
 }
@@ -308,28 +274,25 @@ func ToVarName(name string) string {
 
 // ToGoName translates a swagger name which can be underscored or camel cased to a name that golint likes
 func ToGoName(name string) string {
-	in := split(name)
-	out := make([]string, 0, len(in))
+	lexems := newSplitter(withPostSplitInitialismCheck).split(name)
 
-	for _, w := range in {
-		uw := upper(w)
-		mod := int(math.Min(float64(len(uw)), 2))
-		if !isInitialism(uw) && !isInitialism(uw[:len(uw)-mod]) {
-			uw = upper(w[:1]) + lower(w[1:])
+	result := ""
+	for _, lexem := range lexems {
+		goName := lexem.GetUnsafeGoName()
+
+		// to support old behavior
+		if lexem.IsInitialism() {
+			goName = upper(goName)
 		}
-		out = append(out, uw)
+		result += goName
 	}
 
-	result := strings.Join(out, "")
 	if len(result) > 0 {
-		ud := upper(result[:1])
-		ru := []rune(ud)
-		if unicode.IsUpper(ru[0]) {
-			result = ud + result[1:]
-		} else {
-			result = "X" + ud + result[1:]
+		if !unicode.IsUpper([]rune(result)[0]) {
+			result = "X" + result
 		}
 	}
+
 	return result
 }
 

vendor/github.com/go-openapi/swag/yaml.go

@@ -22,7 +22,6 @@ import (
 
 	"github.com/mailru/easyjson/jlexer"
 	"github.com/mailru/easyjson/jwriter"
-
 	yaml "gopkg.in/yaml.v2"
 )