-
-
-
-
-
-
-
-The `github.com/gobuffalo/flect` package contains "basic" inflection tools, like pluralization, singularization, etc...
-
-### The `Ident` Type
-
-In addition to helpful methods that take in a `string` and return a `string`, there is an `Ident` type that can be used to create new, custom, inflection rules.
-
-The `Ident` type contains two fields.
-
-* `Original` - This is the original `string` that was used to create the `Ident`
-* `Parts` - This is a `[]string` that represents all of the "parts" of the string, that have been split apart, making the segments easier to work with
-
-Examples of creating new inflection rules using `Ident` can be found in the `github.com/gobuffalo/flect/name` package.
-
-## `github.com/gobuffalo/flect/name`
-
-
-The `github.com/gobuffalo/flect/name` package contains more "business" inflection rules like creating proper names, table names, etc...
diff --git a/vendor/github.com/gobuffalo/flect/acronyms.go b/vendor/github.com/gobuffalo/flect/acronyms.go
deleted file mode 100644
index 0208f59..0000000
--- a/vendor/github.com/gobuffalo/flect/acronyms.go
+++ /dev/null
@@ -1,148 +0,0 @@
-package flect
-
-var baseAcronyms = map[string]bool{
- "OK": true,
- "UTF8": true,
- "HTML": true,
- "JSON": true,
- "JWT": true,
- "ID": true,
- "UUID": true,
- "SQL": true,
- "ACK": true,
- "ACL": true,
- "ADSL": true,
- "AES": true,
- "ANSI": true,
- "API": true,
- "ARP": true,
- "ATM": true,
- "BGP": true,
- "BSS": true,
- "CCITT": true,
- "CHAP": true,
- "CIDR": true,
- "CIR": true,
- "CLI": true,
- "CPE": true,
- "CPU": true,
- "CRC": true,
- "CRT": true,
- "CSMA": true,
- "CMOS": true,
- "DCE": true,
- "DEC": true,
- "DES": true,
- "DHCP": true,
- "DNS": true,
- "DRAM": true,
- "DSL": true,
- "DSLAM": true,
- "DTE": true,
- "DMI": true,
- "EHA": true,
- "EIA": true,
- "EIGRP": true,
- "EOF": true,
- "ESS": true,
- "FCC": true,
- "FCS": true,
- "FDDI": true,
- "FTP": true,
- "GBIC": true,
- "gbps": true,
- "GEPOF": true,
- "HDLC": true,
- "HTTP": true,
- "HTTPS": true,
- "IANA": true,
- "ICMP": true,
- "IDF": true,
- "IDS": true,
- "IEEE": true,
- "IETF": true,
- "IMAP": true,
- "IP": true,
- "IPS": true,
- "ISDN": true,
- "ISP": true,
- "kbps": true,
- "LACP": true,
- "LAN": true,
- "LAPB": true,
- "LAPF": true,
- "LLC": true,
- "MAC": true,
- "Mbps": true,
- "MC": true,
- "MDF": true,
- "MIB": true,
- "MoCA": true,
- "MPLS": true,
- "MTU": true,
- "NAC": true,
- "NAT": true,
- "NBMA": true,
- "NIC": true,
- "NRZ": true,
- "NRZI": true,
- "NVRAM": true,
- "OSI": true,
- "OSPF": true,
- "OUI": true,
- "PAP": true,
- "PAT": true,
- "PC": true,
- "PIM": true,
- "PCM": true,
- "PDU": true,
- "POP3": true,
- "POTS": true,
- "PPP": true,
- "PPTP": true,
- "PTT": true,
- "PVST": true,
- "RAM": true,
- "RARP": true,
- "RFC": true,
- "RIP": true,
- "RLL": true,
- "ROM": true,
- "RSTP": true,
- "RTP": true,
- "RCP": true,
- "SDLC": true,
- "SFD": true,
- "SFP": true,
- "SLARP": true,
- "SLIP": true,
- "SMTP": true,
- "SNA": true,
- "SNAP": true,
- "SNMP": true,
- "SOF": true,
- "SRAM": true,
- "SSH": true,
- "SSID": true,
- "STP": true,
- "SYN": true,
- "TDM": true,
- "TFTP": true,
- "TIA": true,
- "TOFU": true,
- "UDP": true,
- "URL": true,
- "URI": true,
- "USB": true,
- "UTP": true,
- "VC": true,
- "VLAN": true,
- "VLSM": true,
- "VPN": true,
- "W3C": true,
- "WAN": true,
- "WEP": true,
- "WiFi": true,
- "WPA": true,
- "WWW": true,
-}
diff --git a/vendor/github.com/gobuffalo/flect/camelize.go b/vendor/github.com/gobuffalo/flect/camelize.go
deleted file mode 100644
index d8851c8..0000000
--- a/vendor/github.com/gobuffalo/flect/camelize.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package flect
-
-import (
- "strings"
- "unicode"
-)
-
-// Camelize returns a camelize version of a string
-// bob dylan = bobDylan
-// widget_id = widgetID
-// WidgetID = widgetID
-func Camelize(s string) string {
- return New(s).Camelize().String()
-}
-
-// Camelize returns a camelize version of a string
-// bob dylan = bobDylan
-// widget_id = widgetID
-// WidgetID = widgetID
-func (i Ident) Camelize() Ident {
- var out []string
- for i, part := range i.Parts {
- var x string
- var capped bool
- for _, c := range part {
- if unicode.IsLetter(c) || unicode.IsDigit(c) {
- if i == 0 {
- x += string(unicode.ToLower(c))
- continue
- }
- if !capped {
- capped = true
- x += string(unicode.ToUpper(c))
- continue
- }
- x += string(c)
- }
- }
- if x != "" {
- out = append(out, x)
- }
- }
- return New(strings.Join(out, ""))
-}
diff --git a/vendor/github.com/gobuffalo/flect/capitalize.go b/vendor/github.com/gobuffalo/flect/capitalize.go
deleted file mode 100644
index 42ecc16..0000000
--- a/vendor/github.com/gobuffalo/flect/capitalize.go
+++ /dev/null
@@ -1,27 +0,0 @@
-package flect
-
-import "unicode"
-
-// Capitalize will cap the first letter of string
-// user = User
-// bob dylan = Bob dylan
-// widget_id = Widget_id
-func Capitalize(s string) string {
- return New(s).Capitalize().String()
-}
-
-// Capitalize will cap the first letter of string
-// user = User
-// bob dylan = Bob dylan
-// widget_id = Widget_id
-func (i Ident) Capitalize() Ident {
- var x string
- if len(i.Parts) == 0 {
- return New("")
- }
- x = string(unicode.ToTitle(rune(i.Original[0])))
- if len(i.Original) > 1 {
- x += i.Original[1:]
- }
- return New(x)
-}
diff --git a/vendor/github.com/gobuffalo/flect/dasherize.go b/vendor/github.com/gobuffalo/flect/dasherize.go
deleted file mode 100644
index c7a8a33..0000000
--- a/vendor/github.com/gobuffalo/flect/dasherize.go
+++ /dev/null
@@ -1,34 +0,0 @@
-package flect
-
-import (
- "strings"
- "unicode"
-)
-
-// Dasherize returns an alphanumeric, lowercased, dashed string
-// Donald E. Knuth = donald-e-knuth
-// Test with + sign = test-with-sign
-// admin/WidgetID = admin-widget-id
-func Dasherize(s string) string {
- return New(s).Dasherize().String()
-}
-
-// Dasherize returns an alphanumeric, lowercased, dashed string
-// Donald E. Knuth = donald-e-knuth
-// Test with + sign = test-with-sign
-// admin/WidgetID = admin-widget-id
-func (i Ident) Dasherize() Ident {
- var parts []string
-
- for _, part := range i.Parts {
- var x string
- for _, c := range part {
- if unicode.IsLetter(c) || unicode.IsDigit(c) {
- x += string(c)
- }
- }
- parts = xappend(parts, x)
- }
-
- return New(strings.ToLower(strings.Join(parts, "-")))
-}
diff --git a/vendor/github.com/gobuffalo/flect/flect.go b/vendor/github.com/gobuffalo/flect/flect.go
deleted file mode 100644
index 4af966b..0000000
--- a/vendor/github.com/gobuffalo/flect/flect.go
+++ /dev/null
@@ -1,84 +0,0 @@
-package flect
-
-import (
- "bytes"
- "encoding/json"
- "fmt"
- "io"
- "io/ioutil"
- "os"
- "path/filepath"
- "strings"
- "unicode"
-)
-
-func init() {
- pwd, _ := os.Getwd()
- cfg := filepath.Join(pwd, "inflections.json")
- if p := os.Getenv("INFLECT_PATH"); p != "" {
- cfg = p
- }
- if _, err := os.Stat(cfg); err == nil {
- b, err := ioutil.ReadFile(cfg)
- if err != nil {
- fmt.Printf("could not read inflection file %s (%s)\n", cfg, err)
- return
- }
- if err = LoadReader(bytes.NewReader(b)); err != nil {
- fmt.Println(err)
- }
- }
-}
-
-//LoadReader loads rules from io.Reader param
-func LoadReader(r io.Reader) error {
- m := map[string]string{}
- err := json.NewDecoder(r).Decode(&m)
- if err != nil {
- return fmt.Errorf("could not decode inflection JSON from reader: %s", err)
- }
- pluralMoot.Lock()
- defer pluralMoot.Unlock()
- singularMoot.Lock()
- defer singularMoot.Unlock()
-
- for s, p := range m {
- singleToPlural[s] = p
- pluralToSingle[p] = s
- }
- return nil
-}
-
-var spaces = []rune{'_', ' ', ':', '-', '/'}
-
-func isSpace(c rune) bool {
- for _, r := range spaces {
- if r == c {
- return true
- }
- }
- return unicode.IsSpace(c)
-}
-
-func xappend(a []string, ss ...string) []string {
- for _, s := range ss {
- s = strings.TrimSpace(s)
- for _, x := range spaces {
- s = strings.Trim(s, string(x))
- }
- if _, ok := baseAcronyms[strings.ToUpper(s)]; ok {
- s = strings.ToUpper(s)
- }
- if s != "" {
- a = append(a, s)
- }
- }
- return a
-}
-
-func abs(x int) int {
- if x < 0 {
- return -x
- }
- return x
-}
diff --git a/vendor/github.com/gobuffalo/flect/go.mod b/vendor/github.com/gobuffalo/flect/go.mod
deleted file mode 100644
index affc9f6..0000000
--- a/vendor/github.com/gobuffalo/flect/go.mod
+++ /dev/null
@@ -1,7 +0,0 @@
-module github.com/gobuffalo/flect
-
-require (
- github.com/davecgh/go-spew v1.1.1 // indirect
- github.com/pmezard/go-difflib v1.0.0 // indirect
- github.com/stretchr/testify v1.2.2
-)
diff --git a/vendor/github.com/gobuffalo/flect/go.sum b/vendor/github.com/gobuffalo/flect/go.sum
deleted file mode 100644
index e03ee77..0000000
--- a/vendor/github.com/gobuffalo/flect/go.sum
+++ /dev/null
@@ -1,6 +0,0 @@
-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/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=
diff --git a/vendor/github.com/gobuffalo/flect/ident.go b/vendor/github.com/gobuffalo/flect/ident.go
deleted file mode 100644
index 171abbc..0000000
--- a/vendor/github.com/gobuffalo/flect/ident.go
+++ /dev/null
@@ -1,86 +0,0 @@
-package flect
-
-import (
- "regexp"
- "strings"
- "unicode"
- "unicode/utf8"
-)
-
-// Ident represents the string and it's parts
-type Ident struct {
- Original string
- Parts []string
-}
-
-// String implements fmt.Stringer and returns the original string
-func (i Ident) String() string {
- return i.Original
-}
-
-// New creates a new Ident from the string
-func New(s string) Ident {
- i := Ident{
- Original: s,
- Parts: toParts(s),
- }
-
- return i
-}
-
-var splitRx = regexp.MustCompile("[^\\p{L}]")
-
-func toParts(s string) []string {
- parts := []string{}
- s = strings.TrimSpace(s)
- if len(s) == 0 {
- return parts
- }
- if _, ok := baseAcronyms[strings.ToUpper(s)]; ok {
- return []string{strings.ToUpper(s)}
- }
- var prev rune
- var x string
- for _, c := range s {
- cs := string(c)
- // fmt.Println("### cs ->", cs)
- // fmt.Println("### unicode.IsControl(c) ->", unicode.IsControl(c))
- // fmt.Println("### unicode.IsDigit(c) ->", unicode.IsDigit(c))
- // fmt.Println("### unicode.IsGraphic(c) ->", unicode.IsGraphic(c))
- // fmt.Println("### unicode.IsLetter(c) ->", unicode.IsLetter(c))
- // fmt.Println("### unicode.IsLower(c) ->", unicode.IsLower(c))
- // fmt.Println("### unicode.IsMark(c) ->", unicode.IsMark(c))
- // fmt.Println("### unicode.IsPrint(c) ->", unicode.IsPrint(c))
- // fmt.Println("### unicode.IsPunct(c) ->", unicode.IsPunct(c))
- // fmt.Println("### unicode.IsSpace(c) ->", unicode.IsSpace(c))
- // fmt.Println("### unicode.IsTitle(c) ->", unicode.IsTitle(c))
- // fmt.Println("### unicode.IsUpper(c) ->", unicode.IsUpper(c))
- if !utf8.ValidRune(c) {
- continue
- }
-
- if isSpace(c) {
- parts = xappend(parts, x)
- x = cs
- prev = c
- continue
- }
- if unicode.IsUpper(c) && !unicode.IsUpper(prev) {
- parts = xappend(parts, x)
- x = cs
- prev = c
- continue
- }
- if unicode.IsLetter(c) || unicode.IsDigit(c) || unicode.IsPunct(c) || c == '`' {
- prev = c
- x += cs
- continue
- }
- parts = xappend(parts, x)
- x = ""
- prev = c
- }
- parts = xappend(parts, x)
-
- return parts
-}
diff --git a/vendor/github.com/gobuffalo/flect/lower_upper.go b/vendor/github.com/gobuffalo/flect/lower_upper.go
deleted file mode 100644
index 930da58..0000000
--- a/vendor/github.com/gobuffalo/flect/lower_upper.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package flect
-
-import "strings"
-
-// ToUpper is a convience wrapper for strings.ToUpper
-func (i Ident) ToUpper() Ident {
- return New(strings.ToUpper(i.Original))
-}
-
-// ToLower is a convience wrapper for strings.ToLower
-func (i Ident) ToLower() Ident {
- return New(strings.ToLower(i.Original))
-}
diff --git a/vendor/github.com/gobuffalo/flect/name/char.go b/vendor/github.com/gobuffalo/flect/name/char.go
deleted file mode 100644
index 64b2cb8..0000000
--- a/vendor/github.com/gobuffalo/flect/name/char.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package name
-
-import "unicode"
-
-// Char returns the first letter, lowered
-// "" = "x"
-// "foo" = "f"
-// "123d456" = "d"
-func Char(s string) string {
- return New(s).Char().String()
-}
-
-// Char returns the first letter, lowered
-// "" = "x"
-// "foo" = "f"
-// "123d456" = "d"
-func (i Ident) Char() Ident {
- for _, c := range i.Original {
- if unicode.IsLetter(c) {
- return New(string(unicode.ToLower(c)))
- }
- }
- return New("x")
-}
diff --git a/vendor/github.com/gobuffalo/flect/name/file.go b/vendor/github.com/gobuffalo/flect/name/file.go
deleted file mode 100644
index ec5cdae..0000000
--- a/vendor/github.com/gobuffalo/flect/name/file.go
+++ /dev/null
@@ -1,28 +0,0 @@
-package name
-
-import (
- "strings"
-
- "github.com/gobuffalo/flect"
-)
-
-// File creates a suitable file name
-// admin/widget = admin/widget
-// foo_bar = foo_bar
-// U$ser = u_ser
-func File(s string, exts ...string) string {
- return New(s).File(exts...).String()
-}
-
-// File creates a suitable file name
-// admin/widget = admin/widget
-// foo_bar = foo_bar
-// U$ser = u_ser
-func (i Ident) File(exts ...string) Ident {
- var parts []string
-
- for _, part := range strings.Split(i.Original, "/") {
- parts = append(parts, flect.Underscore(part))
- }
- return New(strings.Join(parts, "/") + strings.Join(exts, ""))
-}
diff --git a/vendor/github.com/gobuffalo/flect/name/ident.go b/vendor/github.com/gobuffalo/flect/name/ident.go
deleted file mode 100644
index 91f5d8b..0000000
--- a/vendor/github.com/gobuffalo/flect/name/ident.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package name
-
-import "github.com/gobuffalo/flect"
-
-// Ident represents the string and it's parts
-type Ident struct {
- flect.Ident
-}
-
-// New creates a new Ident from the string
-func New(s string) Ident {
- return Ident{flect.New(s)}
-}
diff --git a/vendor/github.com/gobuffalo/flect/name/join.go b/vendor/github.com/gobuffalo/flect/name/join.go
deleted file mode 100644
index de84883..0000000
--- a/vendor/github.com/gobuffalo/flect/name/join.go
+++ /dev/null
@@ -1,20 +0,0 @@
-package name
-
-import "path/filepath"
-
-func FilePathJoin(names ...string) string {
- var ni = make([]Ident, len(names))
- for i, n := range names {
- ni[i] = New(n)
- }
- base := New("")
- return base.FilePathJoin(ni...).String()
-}
-
-func (i Ident) FilePathJoin(ni ...Ident) Ident {
- var s = make([]string, len(ni))
- for i, n := range ni {
- s[i] = n.OsPath().String()
- }
- return New(filepath.Join(s...))
-}
diff --git a/vendor/github.com/gobuffalo/flect/name/key.go b/vendor/github.com/gobuffalo/flect/name/key.go
deleted file mode 100644
index 5fbf9ad..0000000
--- a/vendor/github.com/gobuffalo/flect/name/key.go
+++ /dev/null
@@ -1,14 +0,0 @@
-package name
-
-import (
- "strings"
-)
-
-func Key(s string) string {
- return New(s).Key().String()
-}
-
-func (i Ident) Key() Ident {
- s := strings.Replace(i.String(), "\\", "/", -1)
- return New(strings.ToLower(s))
-}
diff --git a/vendor/github.com/gobuffalo/flect/name/name.go b/vendor/github.com/gobuffalo/flect/name/name.go
deleted file mode 100644
index fd14e0c..0000000
--- a/vendor/github.com/gobuffalo/flect/name/name.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package name
-
-import (
- "strings"
-
- "github.com/gobuffalo/flect"
-)
-
-// Proper pascalizes and singularizes the string
-// person = Person
-// foo_bar = FooBar
-// admin/widgets = AdminWidget
-func Proper(s string) string {
- return New(s).Proper().String()
-}
-
-// Proper pascalizes and singularizes the string
-// person = Person
-// foo_bar = FooBar
-// admin/widgets = AdminWidget
-func (i Ident) Proper() Ident {
- return Ident{i.Singularize().Pascalize()}
-}
-
-// Group pascalizes and pluralizes the string
-// person = People
-// foo_bar = FooBars
-// admin/widget = AdminWidgets
-func Group(s string) string {
- return New(s).Group().String()
-}
-
-// Group pascalizes and pluralizes the string
-// person = People
-// foo_bar = FooBars
-// admin/widget = AdminWidgets
-func (i Ident) Group() Ident {
- var parts []string
- if len(i.Original) == 0 {
- return i
- }
- last := i.Parts[len(i.Parts)-1]
- for _, part := range i.Parts[:len(i.Parts)-1] {
- parts = append(parts, flect.Pascalize(part))
- }
- last = New(last).Pluralize().Pascalize().String()
- parts = append(parts, last)
- return New(strings.Join(parts, ""))
-}
diff --git a/vendor/github.com/gobuffalo/flect/name/os_path.go b/vendor/github.com/gobuffalo/flect/name/os_path.go
deleted file mode 100644
index 2a85723..0000000
--- a/vendor/github.com/gobuffalo/flect/name/os_path.go
+++ /dev/null
@@ -1,21 +0,0 @@
-package name
-
-import (
- "path/filepath"
- "runtime"
- "strings"
-)
-
-func OsPath(s string) string {
- return New(s).OsPath().String()
-}
-
-func (i Ident) OsPath() Ident {
- s := i.String()
- if runtime.GOOS == "windows" {
- s = strings.Replace(s, "/", string(filepath.Separator), -1)
- } else {
- s = strings.Replace(s, "\\", string(filepath.Separator), -1)
- }
- return New(s)
-}
diff --git a/vendor/github.com/gobuffalo/flect/name/package.go b/vendor/github.com/gobuffalo/flect/name/package.go
deleted file mode 100644
index 86f66f2..0000000
--- a/vendor/github.com/gobuffalo/flect/name/package.go
+++ /dev/null
@@ -1,42 +0,0 @@
-package name
-
-import (
- "os"
- "os/exec"
- "path/filepath"
- "strings"
-)
-
-// Package will attempt to return a package version of the name
-// $GOPATH/src/foo/bar = foo/bar
-// $GOPATH\src\foo\bar = foo/bar
-// foo/bar = foo/bar
-func Package(s string) string {
- return New(s).Package().String()
-}
-
-// Package will attempt to return a package version of the name
-// $GOPATH/src/foo/bar = foo/bar
-// $GOPATH\src\foo\bar = foo/bar
-// foo/bar = foo/bar
-func (i Ident) Package() Ident {
- gp := goPath()
- s := i.Original
- slash := string(filepath.Separator)
- trims := []string{gp, slash, "src", slash}
- for _, pre := range trims {
- s = strings.TrimPrefix(s, pre)
- }
- s = strings.Replace(s, "\\", "/", -1)
- s = strings.Replace(s, "_", "", -1)
- return Ident{New(s).ToLower()}
-}
-
-func goPath() string {
- cmd := exec.Command("go", "env", "GOPATH")
- b, err := cmd.CombinedOutput()
- if err != nil {
- return filepath.Join(os.Getenv("HOME"), "go")
- }
- return strings.TrimSpace(string(b))
-}
diff --git a/vendor/github.com/gobuffalo/flect/name/param_id.go b/vendor/github.com/gobuffalo/flect/name/param_id.go
deleted file mode 100644
index 2a30021..0000000
--- a/vendor/github.com/gobuffalo/flect/name/param_id.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package name
-
-import "strings"
-
-// ParamID returns the string as parameter with _id added
-// user = user_id
-// UserID = user_id
-// admin/widgets = admin_widgets_id
-func ParamID(s string) string {
- return New(s).ParamID().String()
-}
-
-// ParamID returns the string as parameter with _id added
-// user = user_id
-// UserID = user_id
-// admin/widgets = admin_widgets_id
-func (i Ident) ParamID() Ident {
- s := i.Underscore().String()
- s = strings.ToLower(s)
- if strings.HasSuffix(s, "_id") {
- return New(s)
- }
- return New(s + "_id")
-}
diff --git a/vendor/github.com/gobuffalo/flect/name/resource.go b/vendor/github.com/gobuffalo/flect/name/resource.go
deleted file mode 100644
index c794809..0000000
--- a/vendor/github.com/gobuffalo/flect/name/resource.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package name
-
-import (
- "strings"
-)
-
-// Resource version of a name
-func (n Ident) Resource() Ident {
- name := n.Underscore().String()
- x := strings.FieldsFunc(name, func(r rune) bool {
- return r == '_' || r == '/'
- })
-
- for i, w := range x {
- if i == len(x)-1 {
- x[i] = New(w).Pluralize().Pascalize().String()
- continue
- }
-
- x[i] = New(w).Pascalize().String()
- }
-
- return New(strings.Join(x, ""))
-}
diff --git a/vendor/github.com/gobuffalo/flect/name/tablize.go b/vendor/github.com/gobuffalo/flect/name/tablize.go
deleted file mode 100644
index e03fe21..0000000
--- a/vendor/github.com/gobuffalo/flect/name/tablize.go
+++ /dev/null
@@ -1,17 +0,0 @@
-package name
-
-// Tableize returns an underscore, pluralized string
-// User = users
-// Person = persons
-// Admin/Widget = admin_widgets
-func Tableize(s string) string {
- return New(s).Tableize().String()
-}
-
-// Tableize returns an underscore, pluralized string
-// User = users
-// Person = persons
-// Admin/Widget = admin_widgets
-func (i Ident) Tableize() Ident {
- return Ident{i.Pluralize().Underscore()}
-}
diff --git a/vendor/github.com/gobuffalo/flect/name/url.go b/vendor/github.com/gobuffalo/flect/name/url.go
deleted file mode 100644
index f5f0641..0000000
--- a/vendor/github.com/gobuffalo/flect/name/url.go
+++ /dev/null
@@ -1,5 +0,0 @@
-package name
-
-func (n Ident) URL() Ident {
- return Ident{n.Pluralize().Underscore()}
-}
diff --git a/vendor/github.com/gobuffalo/flect/name/var_case.go b/vendor/github.com/gobuffalo/flect/name/var_case.go
deleted file mode 100644
index 804ce10..0000000
--- a/vendor/github.com/gobuffalo/flect/name/var_case.go
+++ /dev/null
@@ -1,33 +0,0 @@
-package name
-
-// VarCaseSingle version of a name.
-// foo_bar = fooBar
-// admin/widget = adminWidget
-// User = users
-func VarCaseSingle(s string) string {
- return New(s).VarCaseSingle().String()
-}
-
-// VarCaseSingle version of a name.
-// foo_bar = fooBar
-// admin/widget = adminWidget
-// User = users
-func (i Ident) VarCaseSingle() Ident {
- return Ident{i.Group().Singularize().Camelize()}
-}
-
-// VarCasePlural version of a name.
-// foo_bar = fooBars
-// admin/widget = adminWidgets
-// User = users
-func VarCasePlural(s string) string {
- return New(s).VarCasePlural().String()
-}
-
-// VarCasePlural version of a name.
-// foo_bar = fooBars
-// admin/widget = adminWidgets
-// User = users
-func (i Ident) VarCasePlural() Ident {
- return Ident{i.Group().Pluralize().Camelize()}
-}
diff --git a/vendor/github.com/gobuffalo/flect/ordinalize.go b/vendor/github.com/gobuffalo/flect/ordinalize.go
deleted file mode 100644
index 1ce27b3..0000000
--- a/vendor/github.com/gobuffalo/flect/ordinalize.go
+++ /dev/null
@@ -1,43 +0,0 @@
-package flect
-
-import (
- "fmt"
- "strconv"
-)
-
-// Ordinalize converts a number to an ordinal version
-// 42 = 42nd
-// 45 = 45th
-// 1 = 1st
-func Ordinalize(s string) string {
- return New(s).Ordinalize().String()
-}
-
-// Ordinalize converts a number to an ordinal version
-// 42 = 42nd
-// 45 = 45th
-// 1 = 1st
-func (i Ident) Ordinalize() Ident {
- number, err := strconv.Atoi(i.Original)
- if err != nil {
- return i
- }
- var s string
- switch abs(number) % 100 {
- case 11, 12, 13:
- s = fmt.Sprintf("%dth", number)
- default:
- switch abs(number) % 10 {
- case 1:
- s = fmt.Sprintf("%dst", number)
- case 2:
- s = fmt.Sprintf("%dnd", number)
- case 3:
- s = fmt.Sprintf("%drd", number)
- }
- }
- if s != "" {
- return New(s)
- }
- return New(fmt.Sprintf("%dth", number))
-}
diff --git a/vendor/github.com/gobuffalo/flect/pascalize.go b/vendor/github.com/gobuffalo/flect/pascalize.go
deleted file mode 100644
index 76f0c6a..0000000
--- a/vendor/github.com/gobuffalo/flect/pascalize.go
+++ /dev/null
@@ -1,25 +0,0 @@
-package flect
-
-import (
- "unicode"
-)
-
-// Pascalize returns a string with each segment capitalized
-// user = User
-// bob dylan = BobDylan
-// widget_id = WidgetID
-func Pascalize(s string) string {
- return New(s).Pascalize().String()
-}
-
-// Pascalize returns a string with each segment capitalized
-// user = User
-// bob dylan = BobDylan
-// widget_id = WidgetID
-func (i Ident) Pascalize() Ident {
- c := i.Camelize()
- if len(c.String()) == 0 {
- return c
- }
- return New(string(unicode.ToUpper(rune(c.Original[0]))) + c.Original[1:])
-}
diff --git a/vendor/github.com/gobuffalo/flect/plural_rules.go b/vendor/github.com/gobuffalo/flect/plural_rules.go
deleted file mode 100644
index 6abfd67..0000000
--- a/vendor/github.com/gobuffalo/flect/plural_rules.go
+++ /dev/null
@@ -1,238 +0,0 @@
-package flect
-
-var pluralRules = []rule{}
-
-// AddPlural adds a rule that will replace the given suffix with the replacement suffix.
-func AddPlural(suffix string, repl string) {
- pluralMoot.Lock()
- defer pluralMoot.Unlock()
- pluralRules = append(pluralRules, rule{
- suffix: suffix,
- fn: func(s string) string {
- s = s[:len(s)-len(suffix)]
- return s + repl
- },
- })
-
- pluralRules = append(pluralRules, rule{
- suffix: repl,
- fn: noop,
- })
-}
-
-var singleToPlural = map[string]string{
- "matrix": "matrices",
- "vertix": "vertices",
- "index": "indices",
- "mouse": "mice",
- "louse": "lice",
- "ress": "resses",
- "ox": "oxen",
- "quiz": "quizzes",
- "series": "series",
- "octopus": "octopi",
- "equipment": "equipment",
- "information": "information",
- "rice": "rice",
- "money": "money",
- "species": "species",
- "fish": "fish",
- "sheep": "sheep",
- "jeans": "jeans",
- "police": "police",
- "dear": "dear",
- "goose": "geese",
- "tooth": "teeth",
- "foot": "feet",
- "bus": "buses",
- "fez": "fezzes",
- "piano": "pianos",
- "halo": "halos",
- "photo": "photos",
- "aircraft": "aircraft",
- "alumna": "alumnae",
- "alumnus": "alumni",
- "analysis": "analyses",
- "antenna": "antennas",
- "antithesis": "antitheses",
- "apex": "apexes",
- "appendix": "appendices",
- "axis": "axes",
- "bacillus": "bacilli",
- "bacterium": "bacteria",
- "basis": "bases",
- "beau": "beaus",
- "bison": "bison",
- "bureau": "bureaus",
- "château": "châteaux",
- "codex": "codices",
- "concerto": "concertos",
- "corpus": "corpora",
- "crisis": "crises",
- "curriculum": "curriculums",
- "deer": "deer",
- "diagnosis": "diagnoses",
- "die": "dice",
- "dwarf": "dwarves",
- "ellipsis": "ellipses",
- "erratum": "errata",
- "faux pas": "faux pas",
- "focus": "foci",
- "formula": "formulas",
- "fungus": "fungi",
- "genus": "genera",
- "graffito": "graffiti",
- "grouse": "grouse",
- "half": "halves",
- "hoof": "hooves",
- "hypothesis": "hypotheses",
- "larva": "larvae",
- "libretto": "librettos",
- "loaf": "loaves",
- "locus": "loci",
- "minutia": "minutiae",
- "moose": "moose",
- "nebula": "nebulae",
- "nucleus": "nuclei",
- "oasis": "oases",
- "offspring": "offspring",
- "opus": "opera",
- "parenthesis": "parentheses",
- "phenomenon": "phenomena",
- "phylum": "phyla",
- "prognosis": "prognoses",
- "radius": "radiuses",
- "referendum": "referendums",
- "salmon": "salmon",
- "shrimp": "shrimp",
- "stimulus": "stimuli",
- "stratum": "strata",
- "swine": "swine",
- "syllabus": "syllabi",
- "symposium": "symposiums",
- "synopsis": "synopses",
- "tableau": "tableaus",
- "thesis": "theses",
- "thief": "thieves",
- "trout": "trout",
- "tuna": "tuna",
- "vertebra": "vertebrae",
- "vita": "vitae",
- "vortex": "vortices",
- "wharf": "wharves",
- "wife": "wives",
- "wolf": "wolves",
- "datum": "data",
- "testis": "testes",
- "alias": "aliases",
- "house": "houses",
- "shoe": "shoes",
- "news": "news",
- "ovum": "ova",
- "foo": "foos",
-}
-
-var pluralToSingle = map[string]string{}
-
-func init() {
- for k, v := range singleToPlural {
- pluralToSingle[v] = k
- }
-}
-func init() {
- AddPlural("man", "men")
- AddPlural("tz", "tzes")
- AddPlural("alias", "aliases")
- AddPlural("oasis", "oasis")
- AddPlural("wife", "wives")
- AddPlural("basis", "basis")
- AddPlural("atum", "ata")
- AddPlural("adium", "adia")
- AddPlural("actus", "acti")
- AddPlural("irus", "iri")
- AddPlural("iterion", "iteria")
- AddPlural("dium", "diums")
- AddPlural("ovum", "ova")
- AddPlural("ize", "izes")
- AddPlural("dge", "dges")
- AddPlural("focus", "foci")
- AddPlural("child", "children")
- AddPlural("oaf", "oaves")
- AddPlural("randum", "randa")
- AddPlural("base", "bases")
- AddPlural("atus", "atuses")
- AddPlural("ode", "odes")
- AddPlural("person", "people")
- AddPlural("va", "vae")
- AddPlural("leus", "li")
- AddPlural("ld", "ldren")
- AddPlural("oot", "eet")
- AddPlural("oose", "eese")
- AddPlural("box", "boxes")
- AddPlural("ium", "ia")
- AddPlural("sis", "ses")
- AddPlural("nna", "nnas")
- AddPlural("eses", "esis")
- AddPlural("stis", "stes")
- AddPlural("ex", "ices")
- AddPlural("ula", "ulae")
- AddPlural("isis", "ises")
- AddPlural("ouses", "ouse")
- AddPlural("olves", "olf")
- AddPlural("lf", "lves")
- AddPlural("rf", "rves")
- AddPlural("afe", "aves")
- AddPlural("bfe", "bves")
- AddPlural("cfe", "cves")
- AddPlural("dfe", "dves")
- AddPlural("efe", "eves")
- AddPlural("gfe", "gves")
- AddPlural("hfe", "hves")
- AddPlural("ife", "ives")
- AddPlural("jfe", "jves")
- AddPlural("kfe", "kves")
- AddPlural("lfe", "lves")
- AddPlural("mfe", "mves")
- AddPlural("nfe", "nves")
- AddPlural("ofe", "oves")
- AddPlural("pfe", "pves")
- AddPlural("qfe", "qves")
- AddPlural("rfe", "rves")
- AddPlural("sfe", "sves")
- AddPlural("tfe", "tves")
- AddPlural("ufe", "uves")
- AddPlural("vfe", "vves")
- AddPlural("wfe", "wves")
- AddPlural("xfe", "xves")
- AddPlural("yfe", "yves")
- AddPlural("zfe", "zves")
- AddPlural("hive", "hives")
- AddPlural("quy", "quies")
- AddPlural("by", "bies")
- AddPlural("cy", "cies")
- AddPlural("dy", "dies")
- AddPlural("fy", "fies")
- AddPlural("gy", "gies")
- AddPlural("hy", "hies")
- AddPlural("jy", "jies")
- AddPlural("ky", "kies")
- AddPlural("ly", "lies")
- AddPlural("my", "mies")
- AddPlural("ny", "nies")
- AddPlural("py", "pies")
- AddPlural("qy", "qies")
- AddPlural("ry", "ries")
- AddPlural("sy", "sies")
- AddPlural("ty", "ties")
- AddPlural("vy", "vies")
- AddPlural("wy", "wies")
- AddPlural("xy", "xies")
- AddPlural("zy", "zies")
- AddPlural("x", "xes")
- AddPlural("ch", "ches")
- AddPlural("ss", "sses")
- AddPlural("sh", "shes")
- AddPlural("oe", "oes")
- AddPlural("io", "ios")
- AddPlural("o", "oes")
-}
diff --git a/vendor/github.com/gobuffalo/flect/pluralize.go b/vendor/github.com/gobuffalo/flect/pluralize.go
deleted file mode 100644
index 1b9d43e..0000000
--- a/vendor/github.com/gobuffalo/flect/pluralize.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package flect
-
-import (
- "strings"
- "sync"
-)
-
-var pluralMoot = &sync.RWMutex{}
-
-// Pluralize returns a plural version of the string
-// user = users
-// person = people
-// datum = data
-func Pluralize(s string) string {
- return New(s).Pluralize().String()
-}
-
-// Pluralize returns a plural version of the string
-// user = users
-// person = people
-// datum = data
-func (i Ident) Pluralize() Ident {
- s := i.Original
- if len(s) == 0 {
- return New("")
- }
-
- pluralMoot.RLock()
- defer pluralMoot.RUnlock()
-
- ls := strings.ToLower(s)
- if _, ok := pluralToSingle[ls]; ok {
- return i
- }
- if p, ok := singleToPlural[ls]; ok {
- return New(p)
- }
- for _, r := range pluralRules {
- if strings.HasSuffix(ls, r.suffix) {
- return New(r.fn(s))
- }
- }
-
- if strings.HasSuffix(ls, "s") {
- return i
- }
-
- return New(i.String() + "s")
-}
diff --git a/vendor/github.com/gobuffalo/flect/rule.go b/vendor/github.com/gobuffalo/flect/rule.go
deleted file mode 100644
index dc616b3..0000000
--- a/vendor/github.com/gobuffalo/flect/rule.go
+++ /dev/null
@@ -1,10 +0,0 @@
-package flect
-
-type ruleFn func(string) string
-
-type rule struct {
- suffix string
- fn ruleFn
-}
-
-func noop(s string) string { return s }
diff --git a/vendor/github.com/gobuffalo/flect/singular_rules.go b/vendor/github.com/gobuffalo/flect/singular_rules.go
deleted file mode 100644
index 14b471c..0000000
--- a/vendor/github.com/gobuffalo/flect/singular_rules.go
+++ /dev/null
@@ -1,122 +0,0 @@
-package flect
-
-var singularRules = []rule{}
-
-// AddSingular adds a rule that will replace the given suffix with the replacement suffix.
-func AddSingular(ext string, repl string) {
- singularMoot.Lock()
- defer singularMoot.Unlock()
- singularRules = append(singularRules, rule{
- suffix: ext,
- fn: func(s string) string {
- s = s[:len(s)-len(ext)]
- return s + repl
- },
- })
-
- singularRules = append(singularRules, rule{
- suffix: repl,
- fn: func(s string) string {
- return s
- },
- })
-}
-
-func init() {
- AddSingular("ria", "rion")
- AddSingular("news", "news")
- AddSingular("halves", "half")
- AddSingular("appendix", "appendix")
- AddSingular("zzes", "zz")
- AddSingular("ulas", "ula")
- AddSingular("psis", "pse")
- AddSingular("genus", "genera")
- AddSingular("phyla", "phylum")
- AddSingular("odice", "odex")
- AddSingular("oxen", "ox")
- AddSingular("ianos", "iano")
- AddSingular("ulus", "uli")
- AddSingular("mice", "mouse")
- AddSingular("ouses", "ouse")
- AddSingular("mni", "mnus")
- AddSingular("ocus", "oci")
- AddSingular("shoes", "shoe")
- AddSingular("oasis", "oasis")
- AddSingular("lice", "louse")
- AddSingular("men", "man")
- AddSingular("ta", "tum")
- AddSingular("ia", "ium")
- AddSingular("tives", "tive")
- AddSingular("ldren", "ld")
- AddSingular("people", "person")
- AddSingular("aves", "afe")
- AddSingular("uses", "us")
- AddSingular("bves", "bfe")
- AddSingular("cves", "cfe")
- AddSingular("dves", "dfe")
- AddSingular("eves", "efe")
- AddSingular("gves", "gfe")
- AddSingular("hves", "hfe")
- AddSingular("chives", "chive")
- AddSingular("ives", "ife")
- AddSingular("movies", "movie")
- AddSingular("jeans", "jeans")
- AddSingular("cesses", "cess")
- AddSingular("cess", "cess")
- AddSingular("acti", "actus")
- AddSingular("itzes", "itz")
- AddSingular("usses", "uss")
- AddSingular("uss", "uss")
- AddSingular("jves", "jfe")
- AddSingular("kves", "kfe")
- AddSingular("mves", "mfe")
- AddSingular("nves", "nfe")
- AddSingular("moves", "move")
- AddSingular("oves", "ofe")
- AddSingular("pves", "pfe")
- AddSingular("qves", "qfe")
- AddSingular("sves", "sfe")
- AddSingular("tves", "tfe")
- AddSingular("uves", "ufe")
- AddSingular("vves", "vfe")
- AddSingular("wves", "wfe")
- AddSingular("xves", "xfe")
- AddSingular("yves", "yfe")
- AddSingular("zves", "zfe")
- AddSingular("hives", "hive")
- AddSingular("lves", "lf")
- AddSingular("rves", "rf")
- AddSingular("quies", "quy")
- AddSingular("bies", "by")
- AddSingular("cies", "cy")
- AddSingular("dies", "dy")
- AddSingular("fies", "fy")
- AddSingular("gies", "gy")
- AddSingular("hies", "hy")
- AddSingular("jies", "jy")
- AddSingular("kies", "ky")
- AddSingular("lies", "ly")
- AddSingular("mies", "my")
- AddSingular("nies", "ny")
- AddSingular("pies", "py")
- AddSingular("qies", "qy")
- AddSingular("ries", "ry")
- AddSingular("sies", "sy")
- AddSingular("ties", "ty")
- AddSingular("vies", "vy")
- AddSingular("wies", "wy")
- AddSingular("xies", "xy")
- AddSingular("zies", "zy")
- AddSingular("xes", "x")
- AddSingular("ches", "ch")
- AddSingular("sses", "ss")
- AddSingular("shes", "sh")
- AddSingular("oes", "o")
- AddSingular("ress", "ress")
- AddSingular("iri", "irus")
- AddSingular("irus", "irus")
- AddSingular("tuses", "tus")
- AddSingular("tus", "tus")
- AddSingular("s", "")
- AddSingular("ss", "ss")
-}
diff --git a/vendor/github.com/gobuffalo/flect/singularize.go b/vendor/github.com/gobuffalo/flect/singularize.go
deleted file mode 100644
index a08cbd5..0000000
--- a/vendor/github.com/gobuffalo/flect/singularize.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package flect
-
-import (
- "strings"
- "sync"
-)
-
-var singularMoot = &sync.RWMutex{}
-
-// Singularize returns a singular version of the string
-// users = user
-// data = datum
-// people = person
-func Singularize(s string) string {
- return New(s).Singularize().String()
-}
-
-// Singularize returns a singular version of the string
-// users = user
-// data = datum
-// people = person
-func (i Ident) Singularize() Ident {
- s := i.Original
- if len(s) == 0 {
- return i
- }
-
- singularMoot.RLock()
- defer singularMoot.RUnlock()
- ls := strings.ToLower(s)
- if p, ok := pluralToSingle[ls]; ok {
- return New(p)
- }
- if _, ok := singleToPlural[ls]; ok {
- return i
- }
- for _, r := range singularRules {
- if strings.HasSuffix(ls, r.suffix) {
- return New(r.fn(s))
- }
- }
-
- return i
-}
diff --git a/vendor/github.com/gobuffalo/flect/titleize.go b/vendor/github.com/gobuffalo/flect/titleize.go
deleted file mode 100644
index e7a20d3..0000000
--- a/vendor/github.com/gobuffalo/flect/titleize.go
+++ /dev/null
@@ -1,31 +0,0 @@
-package flect
-
-import (
- "strings"
- "unicode"
-)
-
-// Titleize will capitalize the start of each part
-// "Nice to see you!" = "Nice To See You!"
-// "i've read a book! have you?" = "I've Read A Book! Have You?"
-// "This is `code` ok" = "This Is `code` OK"
-func Titleize(s string) string {
- return New(s).Titleize().String()
-}
-
-// Titleize will capitalize the start of each part
-// "Nice to see you!" = "Nice To See You!"
-// "i've read a book! have you?" = "I've Read A Book! Have You?"
-// "This is `code` ok" = "This Is `code` OK"
-func (i Ident) Titleize() Ident {
- var parts []string
- for _, part := range i.Parts {
- var x string
- x = string(unicode.ToTitle(rune(part[0])))
- if len(part) > 1 {
- x += part[1:]
- }
- parts = append(parts, x)
- }
- return New(strings.Join(parts, " "))
-}
diff --git a/vendor/github.com/gobuffalo/flect/underscore.go b/vendor/github.com/gobuffalo/flect/underscore.go
deleted file mode 100644
index b92488a..0000000
--- a/vendor/github.com/gobuffalo/flect/underscore.go
+++ /dev/null
@@ -1,34 +0,0 @@
-package flect
-
-import (
- "strings"
- "unicode"
-)
-
-// Underscore a string
-// bob dylan = bob_dylan
-// Nice to see you! = nice_to_see_you
-// widgetID = widget_id
-func Underscore(s string) string {
- return New(s).Underscore().String()
-}
-
-// Underscore a string
-// bob dylan = bob_dylan
-// Nice to see you! = nice_to_see_you
-// widgetID = widget_id
-func (i Ident) Underscore() Ident {
- var out []string
- for _, part := range i.Parts {
- var x string
- for _, c := range part {
- if unicode.IsLetter(c) || unicode.IsDigit(c) {
- x += string(c)
- }
- }
- if x != "" {
- out = append(out, x)
- }
- }
- return New(strings.ToLower(strings.Join(out, "_")))
-}
diff --git a/vendor/github.com/gobuffalo/genny/.codeclimate.yml b/vendor/github.com/gobuffalo/genny/.codeclimate.yml
deleted file mode 100644
index 3d77930..0000000
--- a/vendor/github.com/gobuffalo/genny/.codeclimate.yml
+++ /dev/null
@@ -1,14 +0,0 @@
----
-version: "2"
-plugins:
- golint:
- enabled: true
- checks:
- GoLint/Naming/MixedCaps:
- enabled: false
- govet:
- enabled: true
- gofmt:
- enabled: true
- fixme:
- enabled: true
diff --git a/vendor/github.com/gobuffalo/genny/.gitignore b/vendor/github.com/gobuffalo/genny/.gitignore
deleted file mode 100644
index 3689718..0000000
--- a/vendor/github.com/gobuffalo/genny/.gitignore
+++ /dev/null
@@ -1,29 +0,0 @@
-*.log
-.DS_Store
-doc
-tmp
-pkg
-*.gem
-*.pid
-coverage
-coverage.data
-build/*
-*.pbxuser
-*.mode1v3
-.svn
-profile
-.console_history
-.sass-cache/*
-.rake_tasks~
-*.log.lck
-solr/
-.jhw-cache/
-jhw.*
-*.sublime*
-node_modules/
-dist/
-generated/
-.vendor/
-bin/*
-gin-bin
-.idea/
diff --git a/vendor/github.com/gobuffalo/genny/.gometalinter.json b/vendor/github.com/gobuffalo/genny/.gometalinter.json
deleted file mode 100644
index e4f65a3..0000000
--- a/vendor/github.com/gobuffalo/genny/.gometalinter.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
- "Enable": ["vet", "golint", "goimports", "deadcode", "gotype", "ineffassign", "misspell", "nakedret", "unconvert", "megacheck", "varcheck"]
-}
diff --git a/vendor/github.com/gobuffalo/genny/.goreleaser.yml b/vendor/github.com/gobuffalo/genny/.goreleaser.yml
deleted file mode 100644
index ba2dc82..0000000
--- a/vendor/github.com/gobuffalo/genny/.goreleaser.yml
+++ /dev/null
@@ -1,28 +0,0 @@
-builds:
--
- goos:
- - darwin
- - linux
- - windows
- env:
- - CGO_ENABLED=0
- # main: ./genny/main.go
- # binary: {{.Binary}}
- # hooks:
- # pre: packr
- # post: packr clean
-
-checksum:
- name_template: 'checksums.txt'
-snapshot:
- name_template: "{{ .Tag }}-next"
-changelog:
- sort: asc
- filters:
- exclude:
- - '^docs:'
- - '^test:'
-brew:
- github:
- owner: markbates
- name: homebrew-tap
diff --git a/vendor/github.com/gobuffalo/genny/.travis.yml b/vendor/github.com/gobuffalo/genny/.travis.yml
deleted file mode 100644
index 405a8d8..0000000
--- a/vendor/github.com/gobuffalo/genny/.travis.yml
+++ /dev/null
@@ -1,18 +0,0 @@
-language: go
-
-sudo: false
-
-go:
- - 1.9.x
- - 1.10.x
- - 1.11.x
- - tip
-
-install: make deps
-
-script: make ci-test
-
-matrix:
- allow_failures:
- - go: 'tip'
-
diff --git a/vendor/github.com/gobuffalo/genny/LICENSE.txt b/vendor/github.com/gobuffalo/genny/LICENSE.txt
deleted file mode 100644
index 123ddc0..0000000
--- a/vendor/github.com/gobuffalo/genny/LICENSE.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-The MIT License (MIT)
-Copyright (c) 2018 Mark Bates
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/github.com/gobuffalo/genny/Makefile b/vendor/github.com/gobuffalo/genny/Makefile
deleted file mode 100644
index 4e586e5..0000000
--- a/vendor/github.com/gobuffalo/genny/Makefile
+++ /dev/null
@@ -1,46 +0,0 @@
-TAGS ?= "sqlite"
-GO_BIN ?= go
-
-install:
- packr
- $(GO_BIN) install -v ./genny
-
-deps:
- $(GO_BIN) get github.com/gobuffalo/release
- $(GO_BIN) get github.com/gobuffalo/packr/packr
- $(GO_BIN) get -tags ${TAGS} -t ./...
-ifeq ($(GO111MODULE),on)
- $(GO_BIN) mod tidy
-endif
-
-build:
- packr
- $(GO_BIN) build -v .
-
-test:
- packr
- $(GO_BIN) test -tags ${TAGS} ./...
-
-ci-test:
- $(GO_BIN) test -tags ${TAGS} -race ./...
-
-lint:
- gometalinter --vendor ./... --deadline=1m --skip=internal
-
-update:
- $(GO_BIN) get -u -tags ${TAGS}
-ifeq ($(GO111MODULE),on)
- $(GO_BIN) mod tidy
-endif
- packr
- make test
- make install
-ifeq ($(GO111MODULE),on)
- $(GO_BIN) mod tidy
-endif
-
-release-test:
- $(GO_BIN) test -tags ${TAGS} -race ./...
-
-release:
- release -y -f version.go
diff --git a/vendor/github.com/gobuffalo/genny/README.md b/vendor/github.com/gobuffalo/genny/README.md
deleted file mode 100644
index 6b6f1a0..0000000
--- a/vendor/github.com/gobuffalo/genny/README.md
+++ /dev/null
@@ -1,20 +0,0 @@
-
-
-
-
-
-
-```
-
-To pass through mostly unaltered (it gained a rel="nofollow" which is a good thing for user generated content):
-```html
-
-
-
-```
-
-It protects sites from [XSS](http://en.wikipedia.org/wiki/Cross-site_scripting) attacks. There are many [vectors for an XSS attack](https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet) and the best way to mitigate the risk is to sanitize user input against a known safe list of HTML elements and attributes.
-
-You should **always** run bluemonday **after** any other processing.
-
-If you use [blackfriday](https://github.com/russross/blackfriday) or [Pandoc](http://johnmacfarlane.net/pandoc/) then bluemonday should be run after these steps. This ensures that no insecure HTML is introduced later in your process.
-
-bluemonday is heavily inspired by both the [OWASP Java HTML Sanitizer](https://code.google.com/p/owasp-java-html-sanitizer/) and the [HTML Purifier](http://htmlpurifier.org/).
-
-## Technical Summary
-
-Whitelist based, you need to either build a policy describing the HTML elements and attributes to permit (and the `regexp` patterns of attributes), or use one of the supplied policies representing good defaults.
-
-The policy containing the whitelist is applied using a fast non-validating, forward only, token-based parser implemented in the [Go net/html library](https://godoc.org/golang.org/x/net/html) by the core Go team.
-
-We expect to be supplied with well-formatted HTML (closing elements for every applicable open element, nested correctly) and so we do not focus on repairing badly nested or incomplete HTML. We focus on simply ensuring that whatever elements do exist are described in the policy whitelist and that attributes and links are safe for use on your web page. [GIGO](http://en.wikipedia.org/wiki/Garbage_in,_garbage_out) does apply and if you feed it bad HTML bluemonday is not tasked with figuring out how to make it good again.
-
-### Supported Go Versions
-
-bluemonday is tested against Go 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, and tip.
-
-We do not support Go 1.0 as we depend on `golang.org/x/net/html` which includes a reference to `io.ErrNoProgress` which did not exist in Go 1.0.
-
-## Is it production ready?
-
-*Yes*
-
-We are using bluemonday in production having migrated from the widely used and heavily field tested OWASP Java HTML Sanitizer.
-
-We are passing our extensive test suite (including AntiSamy tests as well as tests for any issues raised). Check for any [unresolved issues](https://github.com/microcosm-cc/bluemonday/issues?page=1&state=open) to see whether anything may be a blocker for you.
-
-We invite pull requests and issues to help us ensure we are offering comprehensive protection against various attacks via user generated content.
-
-## Usage
-
-Install in your `${GOPATH}` using `go get -u github.com/microcosm-cc/bluemonday`
-
-Then call it:
-```go
-package main
-
-import (
- "fmt"
-
- "github.com/microcosm-cc/bluemonday"
-)
-
-func main() {
- // Do this once for each unique policy, and use the policy for the life of the program
- // Policy creation/editing is not safe to use in multiple goroutines
- p := bluemonday.UGCPolicy()
-
- // The policy can then be used to sanitize lots of input and it is safe to use the policy in multiple goroutines
- html := p.Sanitize(
- `Google`,
- )
-
- // Output:
- // Google
- fmt.Println(html)
-}
-```
-
-We offer three ways to call Sanitize:
-```go
-p.Sanitize(string) string
-p.SanitizeBytes([]byte) []byte
-p.SanitizeReader(io.Reader) bytes.Buffer
-```
-
-If you are obsessed about performance, `p.SanitizeReader(r).Bytes()` will return a `[]byte` without performing any unnecessary casting of the inputs or outputs. Though the difference is so negligible you should never need to care.
-
-You can build your own policies:
-```go
-package main
-
-import (
- "fmt"
-
- "github.com/microcosm-cc/bluemonday"
-)
-
-func main() {
- p := bluemonday.NewPolicy()
-
- // Require URLs to be parseable by net/url.Parse and either:
- // mailto: http:// or https://
- p.AllowStandardURLs()
-
- // We only allow and
- p.AllowAttrs("href").OnElements("a")
- p.AllowElements("p")
-
- html := p.Sanitize(
- `Google`,
- )
-
- // Output:
- // Google
- fmt.Println(html)
-}
-```
-
-We ship two default policies:
-
-1. `bluemonday.StrictPolicy()` which can be thought of as equivalent to stripping all HTML elements and their attributes as it has nothing on its whitelist. An example usage scenario would be blog post titles where HTML tags are not expected at all and if they are then the elements *and* the content of the elements should be stripped. This is a *very* strict policy.
-2. `bluemonday.UGCPolicy()` which allows a broad selection of HTML elements and attributes that are safe for user generated content. Note that this policy does *not* whitelist iframes, object, embed, styles, script, etc. An example usage scenario would be blog post bodies where a variety of formatting is expected along with the potential for TABLEs and IMGs.
-
-## Policy Building
-
-The essence of building a policy is to determine which HTML elements and attributes are considered safe for your scenario. OWASP provide an [XSS prevention cheat sheet](https://www.owasp.org/index.php/XSS_(Cross_Site_Scripting)_Prevention_Cheat_Sheet) to help explain the risks, but essentially:
-
-1. Avoid anything other than the standard HTML elements
-1. Avoid `script`, `style`, `iframe`, `object`, `embed`, `base` elements that allow code to be executed by the client or third party content to be included that can execute code
-1. Avoid anything other than plain HTML attributes with values matched to a regexp
-
-Basically, you should be able to describe what HTML is fine for your scenario. If you do not have confidence that you can describe your policy please consider using one of the shipped policies such as `bluemonday.UGCPolicy()`.
-
-To create a new policy:
-```go
-p := bluemonday.NewPolicy()
-```
-
-To add elements to a policy either add just the elements:
-```go
-p.AllowElements("b", "strong")
-```
-
-Or add elements as a virtue of adding an attribute:
-```go
-// Not the recommended pattern, see the recommendation on using .Matching() below
-p.AllowAttrs("nowrap").OnElements("td", "th")
-```
-
-Attributes can either be added to all elements:
-```go
-p.AllowAttrs("dir").Matching(regexp.MustCompile("(?i)rtl|ltr")).Globally()
-```
-
-Or attributes can be added to specific elements:
-```go
-// Not the recommended pattern, see the recommendation on using .Matching() below
-p.AllowAttrs("value").OnElements("li")
-```
-
-It is **always** recommended that an attribute be made to match a pattern. XSS in HTML attributes is very easy otherwise:
-```go
-// \p{L} matches unicode letters, \p{N} matches unicode numbers
-p.AllowAttrs("title").Matching(regexp.MustCompile(`[\p{L}\p{N}\s\-_',:\[\]!\./\\\(\)&]*`)).Globally()
-```
-
-You can stop at any time and call .Sanitize():
-```go
-// string htmlIn passed in from a HTTP POST
-htmlOut := p.Sanitize(htmlIn)
-```
-
-And you can take any existing policy and extend it:
-```go
-p := bluemonday.UGCPolicy()
-p.AllowElements("fieldset", "select", "option")
-```
-
-### Links
-
-Links are difficult beasts to sanitise safely and also one of the biggest attack vectors for malicious content.
-
-It is possible to do this:
-```go
-p.AllowAttrs("href").Matching(regexp.MustCompile(`(?i)mailto|https?`)).OnElements("a")
-```
-
-But that will not protect you as the regular expression is insufficient in this case to have prevented a malformed value doing something unexpected.
-
-We provide some additional global options for safely working with links.
-
-`RequireParseableURLs` will ensure that URLs are parseable by Go's `net/url` package:
-```go
-p.RequireParseableURLs(true)
-```
-
-If you have enabled parseable URLs then the following option will `AllowRelativeURLs`. By default this is disabled (bluemonday is a whitelist tool... you need to explicitly tell us to permit things) and when disabled it will prevent all local and scheme relative URLs (i.e. `href="localpage.html"`, `href="../home.html"` and even `href="//www.google.com"` are relative):
-```go
-p.AllowRelativeURLs(true)
-```
-
-If you have enabled parseable URLs then you can whitelist the schemes (commonly called protocol when thinking of `http` and `https`) that are permitted. Bear in mind that allowing relative URLs in the above option will allow for a blank scheme:
-```go
-p.AllowURLSchemes("mailto", "http", "https")
-```
-
-Regardless of whether you have enabled parseable URLs, you can force all URLs to have a rel="nofollow" attribute. This will be added if it does not exist, but only when the `href` is valid:
-```go
-// This applies to "a" "area" "link" elements that have a "href" attribute
-p.RequireNoFollowOnLinks(true)
-```
-
-We provide a convenience method that applies all of the above, but you will still need to whitelist the linkable elements for the URL rules to be applied to:
-```go
-p.AllowStandardURLs()
-p.AllowAttrs("cite").OnElements("blockquote", "q")
-p.AllowAttrs("href").OnElements("a", "area")
-p.AllowAttrs("src").OnElements("img")
-```
-
-An additional complexity regarding links is the data URI as defined in [RFC2397](http://tools.ietf.org/html/rfc2397). The data URI allows for images to be served inline using this format:
-
-```html
- Hello World
-```
-
-We have provided a helper to verify the mimetype followed by base64 content of data URIs links:
-
-```go
-p.AllowDataURIImages()
-```
-
-That helper will enable GIF, JPEG, PNG and WEBP images.
-
-It should be noted that there is a potential [security](http://palizine.plynt.com/issues/2010Oct/bypass-xss-filters/) [risk](https://capec.mitre.org/data/definitions/244.html) with the use of data URI links. You should only enable data URI links if you already trust the content.
-
-We also have some features to help deal with user generated content:
-```go
-p.AddTargetBlankToFullyQualifiedLinks(true)
-```
-
-This will ensure that anchor `` links that are fully qualified (the href destination includes a host name) will get `target="_blank"` added to them.
-
-Additionally any link that has `target="_blank"` after the policy has been applied will also have the `rel` attribute adjusted to add `noopener`. This means a link may start like `` and will end up as ``. It is important to note that the addition of `noopener` is a security feature and not an issue. There is an unfortunate feature to browsers that a browser window opened as a result of `target="_blank"` can still control the opener (your web page) and this protects against that. The background to this can be found here: [https://dev.to/ben/the-targetblank-vulnerability-by-example](https://dev.to/ben/the-targetblank-vulnerability-by-example)
-
-### Policy Building Helpers
-
-We also bundle some helpers to simplify policy building:
-```go
-
-// Permits the "dir", "id", "lang", "title" attributes globally
-p.AllowStandardAttributes()
-
-// Permits the "img" element and its standard attributes
-p.AllowImages()
-
-// Permits ordered and unordered lists, and also definition lists
-p.AllowLists()
-
-// Permits HTML tables and all applicable elements and non-styling attributes
-p.AllowTables()
-```
-
-### Invalid Instructions
-
-The following are invalid:
-```go
-// This does not say where the attributes are allowed, you need to add
-// .Globally() or .OnElements(...)
-// This will be ignored without error.
-p.AllowAttrs("value")
-
-// This does not say where the attributes are allowed, you need to add
-// .Globally() or .OnElements(...)
-// This will be ignored without error.
-p.AllowAttrs(
- "type",
-).Matching(
- regexp.MustCompile("(?i)^(circle|disc|square|a|A|i|I|1)$"),
-)
-```
-
-Both examples exhibit the same issue, they declare attributes but do not then specify whether they are whitelisted globally or only on specific elements (and which elements). Attributes belong to one or more elements, and the policy needs to declare this.
-
-## Limitations
-
-We are not yet including any tools to help whitelist and sanitize CSS. Which means that unless you wish to do the heavy lifting in a single regular expression (inadvisable), **you should not allow the "style" attribute anywhere**.
-
-It is not the job of bluemonday to fix your bad HTML, it is merely the job of bluemonday to prevent malicious HTML getting through. If you have mismatched HTML elements, or non-conforming nesting of elements, those will remain. But if you have well-structured HTML bluemonday will not break it.
-
-## TODO
-
-* Add support for CSS sanitisation to allow some CSS properties based on a whitelist, possibly using the [Gorilla CSS3 scanner](http://www.gorillatoolkit.org/pkg/css/scanner) - PRs welcome so long as testing covers XSS and demonstrates safety first
-* Investigate whether devs want to blacklist elements and attributes. This would allow devs to take an existing policy (such as the `bluemonday.UGCPolicy()` ) that encapsulates 90% of what they're looking for but does more than they need, and to remove the extra things they do not want to make it 100% what they want
-* Investigate whether devs want a validating HTML mode, in which the HTML elements are not just transformed into a balanced tree (every start tag has a closing tag at the correct depth) but also that elements and character data appear only in their allowed context (i.e. that a `table` element isn't a descendent of a `caption`, that `colgroup`, `thead`, `tbody`, `tfoot` and `tr` are permitted, and that character data is not permitted)
-
-## Development
-
-If you have cloned this repo you will probably need the dependency:
-
-`go get golang.org/x/net/html`
-
-Gophers can use their familiar tools:
-
-`go build`
-
-`go test`
-
-I personally use a Makefile as it spares typing the same args over and over whilst providing consistency for those of us who jump from language to language and enjoy just typing `make` in a project directory and watch magic happen.
-
-`make` will build, vet, test and install the library.
-
-`make clean` will remove the library from a *single* `${GOPATH}/pkg` directory tree
-
-`make test` will run the tests
-
-`make cover` will run the tests and *open a browser window* with the coverage report
-
-`make lint` will run golint (install via `go get github.com/golang/lint/golint`)
-
-## Long term goals
-
-1. Open the code to adversarial peer review similar to the [Attack Review Ground Rules](https://code.google.com/p/owasp-java-html-sanitizer/wiki/AttackReviewGroundRules)
-1. Raise funds and pay for an external security review
diff --git a/vendor/github.com/microcosm-cc/bluemonday/doc.go b/vendor/github.com/microcosm-cc/bluemonday/doc.go
deleted file mode 100644
index 71dab60..0000000
--- a/vendor/github.com/microcosm-cc/bluemonday/doc.go
+++ /dev/null
@@ -1,104 +0,0 @@
-// Copyright (c) 2014, David Kitchen
-
-
-To pass through mostly unaltered (it gained a rel="nofollow"):
-
-
-
-
-
-The primary purpose of bluemonday is to take potentially unsafe user generated
-content (from things like Markdown, HTML WYSIWYG tools, etc) and make it safe
-for you to put on your website.
-
-It protects sites against XSS (http://en.wikipedia.org/wiki/Cross-site_scripting)
-and other malicious content that a user interface may deliver. There are many
-vectors for an XSS attack (https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet)
-and the safest thing to do is to sanitize user input against a known safe list
-of HTML elements and attributes.
-
-Note: You should always run bluemonday after any other processing.
-
-If you use blackfriday (https://github.com/russross/blackfriday) or
-Pandoc (http://johnmacfarlane.net/pandoc/) then bluemonday should be run after
-these steps. This ensures that no insecure HTML is introduced later in your
-process.
-
-bluemonday is heavily inspired by both the OWASP Java HTML Sanitizer
-(https://code.google.com/p/owasp-java-html-sanitizer/) and the HTML Purifier
-(http://htmlpurifier.org/).
-
-We ship two default policies, one is bluemonday.StrictPolicy() and can be
-thought of as equivalent to stripping all HTML elements and their attributes as
-it has nothing on its whitelist.
-
-The other is bluemonday.UGCPolicy() and allows a broad selection of HTML
-elements and attributes that are safe for user generated content. Note that
-this policy does not whitelist iframes, object, embed, styles, script, etc.
-
-The essence of building a policy is to determine which HTML elements and
-attributes are considered safe for your scenario. OWASP provide an XSS
-prevention cheat sheet ( https://www.google.com/search?q=xss+prevention+cheat+sheet )
-to help explain the risks, but essentially:
-
- 1. Avoid whitelisting anything other than plain HTML elements
- 2. Avoid whitelisting `script`, `style`, `iframe`, `object`, `embed`, `base`
- elements
- 3. Avoid whitelisting anything other than plain HTML elements with simple
- values that you can match to a regexp
-*/
-package bluemonday
diff --git a/vendor/github.com/microcosm-cc/bluemonday/helpers.go b/vendor/github.com/microcosm-cc/bluemonday/helpers.go
deleted file mode 100644
index dfa5868..0000000
--- a/vendor/github.com/microcosm-cc/bluemonday/helpers.go
+++ /dev/null
@@ -1,297 +0,0 @@
-// Copyright (c) 2014, David Kitchen . To prevent those being removed we maintain
- // a list of elements that are allowed to have no attributes and that will
- // be maintained in the output HTML.
- setOfElementsAllowedWithoutAttrs map[string]struct{}
-
- setOfElementsToSkipContent map[string]struct{}
-}
-
-type attrPolicy struct {
-
- // optional pattern to match, when not nil the regexp needs to match
- // otherwise the attribute is removed
- regexp *regexp.Regexp
-}
-
-type attrPolicyBuilder struct {
- p *Policy
-
- attrNames []string
- regexp *regexp.Regexp
- allowEmpty bool
-}
-
-type urlPolicy func(url *url.URL) (allowUrl bool)
-
-// init initializes the maps if this has not been done already
-func (p *Policy) init() {
- if !p.initialized {
- p.elsAndAttrs = make(map[string]map[string]attrPolicy)
- p.globalAttrs = make(map[string]attrPolicy)
- p.allowURLSchemes = make(map[string]urlPolicy)
- p.setOfElementsAllowedWithoutAttrs = make(map[string]struct{})
- p.setOfElementsToSkipContent = make(map[string]struct{})
- p.initialized = true
- }
-}
-
-// NewPolicy returns a blank policy with nothing whitelisted or permitted. This
-// is the recommended way to start building a policy and you should now use
-// AllowAttrs() and/or AllowElements() to construct the whitelist of HTML
-// elements and attributes.
-func NewPolicy() *Policy {
-
- p := Policy{}
-
- p.addDefaultElementsWithoutAttrs()
- p.addDefaultSkipElementContent()
-
- return &p
-}
-
-// AllowAttrs takes a range of HTML attribute names and returns an
-// attribute policy builder that allows you to specify the pattern and scope of
-// the whitelisted attribute.
-//
-// The attribute policy is only added to the core policy when either Globally()
-// or OnElements(...) are called.
-func (p *Policy) AllowAttrs(attrNames ...string) *attrPolicyBuilder {
-
- p.init()
-
- abp := attrPolicyBuilder{
- p: p,
- allowEmpty: false,
- }
-
- for _, attrName := range attrNames {
- abp.attrNames = append(abp.attrNames, strings.ToLower(attrName))
- }
-
- return &abp
-}
-
-// AllowDataAttributes whitelists all data attributes. We can't specify the name
-// of each attribute exactly as they are customized.
-//
-// NOTE: These values are not sanitized and applications that evaluate or process
-// them without checking and verification of the input may be at risk if this option
-// is enabled. This is a 'caveat emptor' option and the person enabling this option
-// needs to fully understand the potential impact with regards to whatever application
-// will be consuming the sanitized HTML afterwards, i.e. if you know you put a link in a
-// data attribute and use that to automatically load some new window then you're giving
-// the author of a HTML fragment the means to open a malicious destination automatically.
-// Use with care!
-func (p *Policy) AllowDataAttributes() {
- p.allowDataAttributes = true
-}
-
-// AllowNoAttrs says that attributes on element are optional.
-//
-// The attribute policy is only added to the core policy when OnElements(...)
-// are called.
-func (p *Policy) AllowNoAttrs() *attrPolicyBuilder {
-
- p.init()
-
- abp := attrPolicyBuilder{
- p: p,
- allowEmpty: true,
- }
- return &abp
-}
-
-// AllowNoAttrs says that attributes on element are optional.
-//
-// The attribute policy is only added to the core policy when OnElements(...)
-// are called.
-func (abp *attrPolicyBuilder) AllowNoAttrs() *attrPolicyBuilder {
-
- abp.allowEmpty = true
-
- return abp
-}
-
-// Matching allows a regular expression to be applied to a nascent attribute
-// policy, and returns the attribute policy. Calling this more than once will
-// replace the existing regexp.
-func (abp *attrPolicyBuilder) Matching(regex *regexp.Regexp) *attrPolicyBuilder {
-
- abp.regexp = regex
-
- return abp
-}
-
-// OnElements will bind an attribute policy to a given range of HTML elements
-// and return the updated policy
-func (abp *attrPolicyBuilder) OnElements(elements ...string) *Policy {
-
- for _, element := range elements {
- element = strings.ToLower(element)
-
- for _, attr := range abp.attrNames {
-
- if _, ok := abp.p.elsAndAttrs[element]; !ok {
- abp.p.elsAndAttrs[element] = make(map[string]attrPolicy)
- }
-
- ap := attrPolicy{}
- if abp.regexp != nil {
- ap.regexp = abp.regexp
- }
-
- abp.p.elsAndAttrs[element][attr] = ap
- }
-
- if abp.allowEmpty {
- abp.p.setOfElementsAllowedWithoutAttrs[element] = struct{}{}
-
- if _, ok := abp.p.elsAndAttrs[element]; !ok {
- abp.p.elsAndAttrs[element] = make(map[string]attrPolicy)
- }
- }
- }
-
- return abp.p
-}
-
-// Globally will bind an attribute policy to all HTML elements and return the
-// updated policy
-func (abp *attrPolicyBuilder) Globally() *Policy {
-
- for _, attr := range abp.attrNames {
- if _, ok := abp.p.globalAttrs[attr]; !ok {
- abp.p.globalAttrs[attr] = attrPolicy{}
- }
-
- ap := attrPolicy{}
- if abp.regexp != nil {
- ap.regexp = abp.regexp
- }
-
- abp.p.globalAttrs[attr] = ap
- }
-
- return abp.p
-}
-
-// AllowElements will append HTML elements to the whitelist without applying an
-// attribute policy to those elements (the elements are permitted
-// sans-attributes)
-func (p *Policy) AllowElements(names ...string) *Policy {
- p.init()
-
- for _, element := range names {
- element = strings.ToLower(element)
-
- if _, ok := p.elsAndAttrs[element]; !ok {
- p.elsAndAttrs[element] = make(map[string]attrPolicy)
- }
- }
-
- return p
-}
-
-// RequireNoFollowOnLinks will result in all tags having a rel="nofollow"
-// added to them if one does not already exist
-//
-// Note: This requires p.RequireParseableURLs(true) and will enable it.
-func (p *Policy) RequireNoFollowOnLinks(require bool) *Policy {
-
- p.requireNoFollow = require
- p.requireParseableURLs = true
-
- return p
-}
-
-// RequireNoFollowOnFullyQualifiedLinks will result in all tags that point
-// to a non-local destination (i.e. starts with a protocol and has a host)
-// having a rel="nofollow" added to them if one does not already exist
-//
-// Note: This requires p.RequireParseableURLs(true) and will enable it.
-func (p *Policy) RequireNoFollowOnFullyQualifiedLinks(require bool) *Policy {
-
- p.requireNoFollowFullyQualifiedLinks = require
- p.requireParseableURLs = true
-
- return p
-}
-
-// AddTargetBlankToFullyQualifiedLinks will result in all tags that point
-// to a non-local destination (i.e. starts with a protocol and has a host)
-// having a target="_blank" added to them if one does not already exist
-//
-// Note: This requires p.RequireParseableURLs(true) and will enable it.
-func (p *Policy) AddTargetBlankToFullyQualifiedLinks(require bool) *Policy {
-
- p.addTargetBlankToFullyQualifiedLinks = require
- p.requireParseableURLs = true
-
- return p
-}
-
-// RequireParseableURLs will result in all URLs requiring that they be parseable
-// by "net/url" url.Parse()
-// This applies to:
-// - a.href
-// - area.href
-// - blockquote.cite
-// - img.src
-// - link.href
-// - script.src
-func (p *Policy) RequireParseableURLs(require bool) *Policy {
-
- p.requireParseableURLs = require
-
- return p
-}
-
-// AllowRelativeURLs enables RequireParseableURLs and then permits URLs that
-// are parseable, have no schema information and url.IsAbs() returns false
-// This permits local URLs
-func (p *Policy) AllowRelativeURLs(require bool) *Policy {
-
- p.RequireParseableURLs(true)
- p.allowRelativeURLs = require
-
- return p
-}
-
-// AllowURLSchemes will append URL schemes to the whitelist
-// Example: p.AllowURLSchemes("mailto", "http", "https")
-func (p *Policy) AllowURLSchemes(schemes ...string) *Policy {
- p.init()
-
- p.RequireParseableURLs(true)
-
- for _, scheme := range schemes {
- scheme = strings.ToLower(scheme)
-
- // Allow all URLs with matching scheme.
- p.allowURLSchemes[scheme] = nil
- }
-
- return p
-}
-
-// AllowURLSchemeWithCustomPolicy will append URL schemes with
-// a custom URL policy to the whitelist.
-// Only the URLs with matching schema and urlPolicy(url)
-// returning true will be allowed.
-func (p *Policy) AllowURLSchemeWithCustomPolicy(
- scheme string,
- urlPolicy func(url *url.URL) (allowUrl bool),
-) *Policy {
-
- p.init()
-
- p.RequireParseableURLs(true)
-
- scheme = strings.ToLower(scheme)
-
- p.allowURLSchemes[scheme] = urlPolicy
-
- return p
-}
-
-// AddSpaceWhenStrippingTag states whether to add a single space " " when
-// removing tags that are not whitelisted by the policy.
-//
-// This is useful if you expect to strip tags in dense markup and may lose the
-// value of whitespace.
-//
-// For example: "
is valid, but isn't valid as the "dir" attr
-// is mandatory
-func (p *Policy) addDefaultElementsWithoutAttrs() {
- p.init()
-
- p.setOfElementsAllowedWithoutAttrs["abbr"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["acronym"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["address"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["article"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["aside"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["audio"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["b"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["bdi"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["blockquote"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["body"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["br"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["button"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["canvas"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["caption"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["center"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["cite"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["code"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["col"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["colgroup"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["datalist"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["dd"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["del"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["details"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["dfn"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["div"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["dl"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["dt"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["em"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["fieldset"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["figcaption"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["figure"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["footer"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["h1"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["h2"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["h3"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["h4"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["h5"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["h6"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["head"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["header"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["hgroup"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["hr"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["html"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["i"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["ins"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["kbd"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["li"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["mark"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["marquee"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["nav"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["ol"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["optgroup"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["option"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["p"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["pre"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["q"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["rp"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["rt"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["ruby"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["s"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["samp"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["script"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["section"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["select"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["small"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["span"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["strike"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["strong"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["style"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["sub"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["summary"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["sup"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["svg"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["table"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["tbody"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["td"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["textarea"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["tfoot"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["th"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["thead"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["title"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["time"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["tr"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["tt"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["u"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["ul"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["var"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["video"] = struct{}{}
- p.setOfElementsAllowedWithoutAttrs["wbr"] = struct{}{}
-
-}
-
-// addDefaultSkipElementContent adds the HTML elements that we should skip
-// rendering the character content of, if the element itself is not allowed.
-// This is all character data that the end user would not normally see.
-// i.e. if we exclude a tag.
-func (p *Policy) addDefaultSkipElementContent() {
- p.init()
-
- p.setOfElementsToSkipContent["frame"] = struct{}{}
- p.setOfElementsToSkipContent["frameset"] = struct{}{}
- p.setOfElementsToSkipContent["iframe"] = struct{}{}
- p.setOfElementsToSkipContent["noembed"] = struct{}{}
- p.setOfElementsToSkipContent["noframes"] = struct{}{}
- p.setOfElementsToSkipContent["noscript"] = struct{}{}
- p.setOfElementsToSkipContent["nostyle"] = struct{}{}
- p.setOfElementsToSkipContent["object"] = struct{}{}
- p.setOfElementsToSkipContent["script"] = struct{}{}
- p.setOfElementsToSkipContent["style"] = struct{}{}
- p.setOfElementsToSkipContent["title"] = struct{}{}
-}
diff --git a/vendor/github.com/microcosm-cc/bluemonday/sanitize.go b/vendor/github.com/microcosm-cc/bluemonday/sanitize.go
deleted file mode 100644
index 65ed89b..0000000
--- a/vendor/github.com/microcosm-cc/bluemonday/sanitize.go
+++ /dev/null
@@ -1,581 +0,0 @@
-// Copyright (c) 2014, David Kitchen
abcxxxxxxdef
- // -> abcxxxdef
- // e.g: xxxabcdefxxx
- // -> defxxxabc
- // Only extract an overlap if it is as big as the edit ahead or behind it.
- pointer = 1
- for pointer < len(diffs) {
- if diffs[pointer-1].Type == DiffDelete &&
- diffs[pointer].Type == DiffInsert {
- deletion := diffs[pointer-1].Text
- insertion := diffs[pointer].Text
- overlapLength1 := dmp.DiffCommonOverlap(deletion, insertion)
- overlapLength2 := dmp.DiffCommonOverlap(insertion, deletion)
- if overlapLength1 >= overlapLength2 {
- if float64(overlapLength1) >= float64(len(deletion))/2 ||
- float64(overlapLength1) >= float64(len(insertion))/2 {
-
- // Overlap found. Insert an equality and trim the surrounding edits.
- diffs = append(
- diffs[:pointer],
- append([]Diff{Diff{DiffEqual, insertion[:overlapLength1]}}, diffs[pointer:]...)...)
-
- diffs[pointer-1].Text =
- deletion[0 : len(deletion)-overlapLength1]
- diffs[pointer+1].Text = insertion[overlapLength1:]
- pointer++
- }
- } else {
- if float64(overlapLength2) >= float64(len(deletion))/2 ||
- float64(overlapLength2) >= float64(len(insertion))/2 {
- // Reverse overlap found. Insert an equality and swap and trim the surrounding edits.
- overlap := Diff{DiffEqual, deletion[:overlapLength2]}
- diffs = append(
- diffs[:pointer],
- append([]Diff{overlap}, diffs[pointer:]...)...)
-
- diffs[pointer-1].Type = DiffInsert
- diffs[pointer-1].Text = insertion[0 : len(insertion)-overlapLength2]
- diffs[pointer+1].Type = DiffDelete
- diffs[pointer+1].Text = deletion[overlapLength2:]
- pointer++
- }
- }
- pointer++
- }
- pointer++
- }
-
- return diffs
-}
-
-// Define some regex patterns for matching boundaries.
-var (
- nonAlphaNumericRegex = regexp.MustCompile(`[^a-zA-Z0-9]`)
- whitespaceRegex = regexp.MustCompile(`\s`)
- linebreakRegex = regexp.MustCompile(`[\r\n]`)
- blanklineEndRegex = regexp.MustCompile(`\n\r?\n$`)
- blanklineStartRegex = regexp.MustCompile(`^\r?\n\r?\n`)
-)
-
-// diffCleanupSemanticScore computes a score representing whether the internal boundary falls on logical boundaries.
-// Scores range from 6 (best) to 0 (worst). Closure, but does not reference any external variables.
-func diffCleanupSemanticScore(one, two string) int {
- if len(one) == 0 || len(two) == 0 {
- // Edges are the best.
- return 6
- }
-
- // Each port of this function behaves slightly differently due to subtle differences in each language's definition of things like 'whitespace'. Since this function's purpose is largely cosmetic, the choice has been made to use each language's native features rather than force total conformity.
- rune1, _ := utf8.DecodeLastRuneInString(one)
- rune2, _ := utf8.DecodeRuneInString(two)
- char1 := string(rune1)
- char2 := string(rune2)
-
- nonAlphaNumeric1 := nonAlphaNumericRegex.MatchString(char1)
- nonAlphaNumeric2 := nonAlphaNumericRegex.MatchString(char2)
- whitespace1 := nonAlphaNumeric1 && whitespaceRegex.MatchString(char1)
- whitespace2 := nonAlphaNumeric2 && whitespaceRegex.MatchString(char2)
- lineBreak1 := whitespace1 && linebreakRegex.MatchString(char1)
- lineBreak2 := whitespace2 && linebreakRegex.MatchString(char2)
- blankLine1 := lineBreak1 && blanklineEndRegex.MatchString(one)
- blankLine2 := lineBreak2 && blanklineEndRegex.MatchString(two)
-
- if blankLine1 || blankLine2 {
- // Five points for blank lines.
- return 5
- } else if lineBreak1 || lineBreak2 {
- // Four points for line breaks.
- return 4
- } else if nonAlphaNumeric1 && !whitespace1 && whitespace2 {
- // Three points for end of sentences.
- return 3
- } else if whitespace1 || whitespace2 {
- // Two points for whitespace.
- return 2
- } else if nonAlphaNumeric1 || nonAlphaNumeric2 {
- // One point for non-alphanumeric.
- return 1
- }
- return 0
-}
-
-// DiffCleanupSemanticLossless looks for single edits surrounded on both sides by equalities which can be shifted sideways to align the edit to a word boundary.
-// E.g: The cat came. -> The cat came.
-func (dmp *DiffMatchPatch) DiffCleanupSemanticLossless(diffs []Diff) []Diff {
- pointer := 1
-
- // Intentionally ignore the first and last element (don't need checking).
- for pointer < len(diffs)-1 {
- if diffs[pointer-1].Type == DiffEqual &&
- diffs[pointer+1].Type == DiffEqual {
-
- // This is a single edit surrounded by equalities.
- equality1 := diffs[pointer-1].Text
- edit := diffs[pointer].Text
- equality2 := diffs[pointer+1].Text
-
- // First, shift the edit as far left as possible.
- commonOffset := dmp.DiffCommonSuffix(equality1, edit)
- if commonOffset > 0 {
- commonString := edit[len(edit)-commonOffset:]
- equality1 = equality1[0 : len(equality1)-commonOffset]
- edit = commonString + edit[:len(edit)-commonOffset]
- equality2 = commonString + equality2
- }
-
- // Second, step character by character right, looking for the best fit.
- bestEquality1 := equality1
- bestEdit := edit
- bestEquality2 := equality2
- bestScore := diffCleanupSemanticScore(equality1, edit) +
- diffCleanupSemanticScore(edit, equality2)
-
- for len(edit) != 0 && len(equality2) != 0 {
- _, sz := utf8.DecodeRuneInString(edit)
- if len(equality2) < sz || edit[:sz] != equality2[:sz] {
- break
- }
- equality1 += edit[:sz]
- edit = edit[sz:] + equality2[:sz]
- equality2 = equality2[sz:]
- score := diffCleanupSemanticScore(equality1, edit) +
- diffCleanupSemanticScore(edit, equality2)
- // The >= encourages trailing rather than leading whitespace on edits.
- if score >= bestScore {
- bestScore = score
- bestEquality1 = equality1
- bestEdit = edit
- bestEquality2 = equality2
- }
- }
-
- if diffs[pointer-1].Text != bestEquality1 {
- // We have an improvement, save it back to the diff.
- if len(bestEquality1) != 0 {
- diffs[pointer-1].Text = bestEquality1
- } else {
- diffs = splice(diffs, pointer-1, 1)
- pointer--
- }
-
- diffs[pointer].Text = bestEdit
- if len(bestEquality2) != 0 {
- diffs[pointer+1].Text = bestEquality2
- } else {
- diffs = append(diffs[:pointer+1], diffs[pointer+2:]...)
- pointer--
- }
- }
- }
- pointer++
- }
-
- return diffs
-}
-
-// DiffCleanupEfficiency reduces the number of edits by eliminating operationally trivial equalities.
-func (dmp *DiffMatchPatch) DiffCleanupEfficiency(diffs []Diff) []Diff {
- changes := false
- // Stack of indices where equalities are found.
- type equality struct {
- data int
- next *equality
- }
- var equalities *equality
- // Always equal to equalities[equalitiesLength-1][1]
- lastequality := ""
- pointer := 0 // Index of current position.
- // Is there an insertion operation before the last equality.
- preIns := false
- // Is there a deletion operation before the last equality.
- preDel := false
- // Is there an insertion operation after the last equality.
- postIns := false
- // Is there a deletion operation after the last equality.
- postDel := false
- for pointer < len(diffs) {
- if diffs[pointer].Type == DiffEqual { // Equality found.
- if len(diffs[pointer].Text) < dmp.DiffEditCost &&
- (postIns || postDel) {
- // Candidate found.
- equalities = &equality{
- data: pointer,
- next: equalities,
- }
- preIns = postIns
- preDel = postDel
- lastequality = diffs[pointer].Text
- } else {
- // Not a candidate, and can never become one.
- equalities = nil
- lastequality = ""
- }
- postIns = false
- postDel = false
- } else { // An insertion or deletion.
- if diffs[pointer].Type == DiffDelete {
- postDel = true
- } else {
- postIns = true
- }
-
- // Five types to be split:
- // ABXYCD
- // AXCD
- // ABXC
- // AXCD
- // ABXC
- var sumPres int
- if preIns {
- sumPres++
- }
- if preDel {
- sumPres++
- }
- if postIns {
- sumPres++
- }
- if postDel {
- sumPres++
- }
- if len(lastequality) > 0 &&
- ((preIns && preDel && postIns && postDel) ||
- ((len(lastequality) < dmp.DiffEditCost/2) && sumPres == 3)) {
-
- insPoint := equalities.data
-
- // Duplicate record.
- diffs = append(diffs[:insPoint],
- append([]Diff{Diff{DiffDelete, lastequality}}, diffs[insPoint:]...)...)
-
- // Change second copy to insert.
- diffs[insPoint+1].Type = DiffInsert
- // Throw away the equality we just deleted.
- equalities = equalities.next
- lastequality = ""
-
- if preIns && preDel {
- // No changes made which could affect previous entry, keep going.
- postIns = true
- postDel = true
- equalities = nil
- } else {
- if equalities != nil {
- equalities = equalities.next
- }
- if equalities != nil {
- pointer = equalities.data
- } else {
- pointer = -1
- }
- postIns = false
- postDel = false
- }
- changes = true
- }
- }
- pointer++
- }
-
- if changes {
- diffs = dmp.DiffCleanupMerge(diffs)
- }
-
- return diffs
-}
-
-// DiffCleanupMerge reorders and merges like edit sections. Merge equalities.
-// Any edit section can move as long as it doesn't cross an equality.
-func (dmp *DiffMatchPatch) DiffCleanupMerge(diffs []Diff) []Diff {
- // Add a dummy entry at the end.
- diffs = append(diffs, Diff{DiffEqual, ""})
- pointer := 0
- countDelete := 0
- countInsert := 0
- commonlength := 0
- textDelete := []rune(nil)
- textInsert := []rune(nil)
-
- for pointer < len(diffs) {
- switch diffs[pointer].Type {
- case DiffInsert:
- countInsert++
- textInsert = append(textInsert, []rune(diffs[pointer].Text)...)
- pointer++
- break
- case DiffDelete:
- countDelete++
- textDelete = append(textDelete, []rune(diffs[pointer].Text)...)
- pointer++
- break
- case DiffEqual:
- // Upon reaching an equality, check for prior redundancies.
- if countDelete+countInsert > 1 {
- if countDelete != 0 && countInsert != 0 {
- // Factor out any common prefixies.
- commonlength = commonPrefixLength(textInsert, textDelete)
- if commonlength != 0 {
- x := pointer - countDelete - countInsert
- if x > 0 && diffs[x-1].Type == DiffEqual {
- diffs[x-1].Text += string(textInsert[:commonlength])
- } else {
- diffs = append([]Diff{Diff{DiffEqual, string(textInsert[:commonlength])}}, diffs...)
- pointer++
- }
- textInsert = textInsert[commonlength:]
- textDelete = textDelete[commonlength:]
- }
- // Factor out any common suffixies.
- commonlength = commonSuffixLength(textInsert, textDelete)
- if commonlength != 0 {
- insertIndex := len(textInsert) - commonlength
- deleteIndex := len(textDelete) - commonlength
- diffs[pointer].Text = string(textInsert[insertIndex:]) + diffs[pointer].Text
- textInsert = textInsert[:insertIndex]
- textDelete = textDelete[:deleteIndex]
- }
- }
- // Delete the offending records and add the merged ones.
- if countDelete == 0 {
- diffs = splice(diffs, pointer-countInsert,
- countDelete+countInsert,
- Diff{DiffInsert, string(textInsert)})
- } else if countInsert == 0 {
- diffs = splice(diffs, pointer-countDelete,
- countDelete+countInsert,
- Diff{DiffDelete, string(textDelete)})
- } else {
- diffs = splice(diffs, pointer-countDelete-countInsert,
- countDelete+countInsert,
- Diff{DiffDelete, string(textDelete)},
- Diff{DiffInsert, string(textInsert)})
- }
-
- pointer = pointer - countDelete - countInsert + 1
- if countDelete != 0 {
- pointer++
- }
- if countInsert != 0 {
- pointer++
- }
- } else if pointer != 0 && diffs[pointer-1].Type == DiffEqual {
- // Merge this equality with the previous one.
- diffs[pointer-1].Text += diffs[pointer].Text
- diffs = append(diffs[:pointer], diffs[pointer+1:]...)
- } else {
- pointer++
- }
- countInsert = 0
- countDelete = 0
- textDelete = nil
- textInsert = nil
- break
- }
- }
-
- if len(diffs[len(diffs)-1].Text) == 0 {
- diffs = diffs[0 : len(diffs)-1] // Remove the dummy entry at the end.
- }
-
- // Second pass: look for single edits surrounded on both sides by equalities which can be shifted sideways to eliminate an equality. E.g: ABAC -> ABAC
- changes := false
- pointer = 1
- // Intentionally ignore the first and last element (don't need checking).
- for pointer < (len(diffs) - 1) {
- if diffs[pointer-1].Type == DiffEqual &&
- diffs[pointer+1].Type == DiffEqual {
- // This is a single edit surrounded by equalities.
- if strings.HasSuffix(diffs[pointer].Text, diffs[pointer-1].Text) {
- // Shift the edit over the previous equality.
- diffs[pointer].Text = diffs[pointer-1].Text +
- diffs[pointer].Text[:len(diffs[pointer].Text)-len(diffs[pointer-1].Text)]
- diffs[pointer+1].Text = diffs[pointer-1].Text + diffs[pointer+1].Text
- diffs = splice(diffs, pointer-1, 1)
- changes = true
- } else if strings.HasPrefix(diffs[pointer].Text, diffs[pointer+1].Text) {
- // Shift the edit over the next equality.
- diffs[pointer-1].Text += diffs[pointer+1].Text
- diffs[pointer].Text =
- diffs[pointer].Text[len(diffs[pointer+1].Text):] + diffs[pointer+1].Text
- diffs = splice(diffs, pointer+1, 1)
- changes = true
- }
- }
- pointer++
- }
-
- // If shifts were made, the diff needs reordering and another shift sweep.
- if changes {
- diffs = dmp.DiffCleanupMerge(diffs)
- }
-
- return diffs
-}
-
-// DiffXIndex returns the equivalent location in s2.
-func (dmp *DiffMatchPatch) DiffXIndex(diffs []Diff, loc int) int {
- chars1 := 0
- chars2 := 0
- lastChars1 := 0
- lastChars2 := 0
- lastDiff := Diff{}
- for i := 0; i < len(diffs); i++ {
- aDiff := diffs[i]
- if aDiff.Type != DiffInsert {
- // Equality or deletion.
- chars1 += len(aDiff.Text)
- }
- if aDiff.Type != DiffDelete {
- // Equality or insertion.
- chars2 += len(aDiff.Text)
- }
- if chars1 > loc {
- // Overshot the location.
- lastDiff = aDiff
- break
- }
- lastChars1 = chars1
- lastChars2 = chars2
- }
- if lastDiff.Type == DiffDelete {
- // The location was deleted.
- return lastChars2
- }
- // Add the remaining character length.
- return lastChars2 + (loc - lastChars1)
-}
-
-// DiffPrettyHtml converts a []Diff into a pretty HTML report.
-// It is intended as an example from which to write one's own display functions.
-func (dmp *DiffMatchPatch) DiffPrettyHtml(diffs []Diff) string {
- var buff bytes.Buffer
- for _, diff := range diffs {
- text := strings.Replace(html.EscapeString(diff.Text), "\n", "¶
", -1)
- switch diff.Type {
- case DiffInsert:
- _, _ = buff.WriteString("")
- _, _ = buff.WriteString(text)
- _, _ = buff.WriteString("")
- case DiffDelete:
- _, _ = buff.WriteString("")
- _, _ = buff.WriteString(text)
- _, _ = buff.WriteString("")
- case DiffEqual:
- _, _ = buff.WriteString("")
- _, _ = buff.WriteString(text)
- _, _ = buff.WriteString("")
- }
- }
- return buff.String()
-}
-
-// DiffPrettyText converts a []Diff into a colored text report.
-func (dmp *DiffMatchPatch) DiffPrettyText(diffs []Diff) string {
- var buff bytes.Buffer
- for _, diff := range diffs {
- text := diff.Text
-
- switch diff.Type {
- case DiffInsert:
- _, _ = buff.WriteString("\x1b[32m")
- _, _ = buff.WriteString(text)
- _, _ = buff.WriteString("\x1b[0m")
- case DiffDelete:
- _, _ = buff.WriteString("\x1b[31m")
- _, _ = buff.WriteString(text)
- _, _ = buff.WriteString("\x1b[0m")
- case DiffEqual:
- _, _ = buff.WriteString(text)
- }
- }
-
- return buff.String()
-}
-
-// DiffText1 computes and returns the source text (all equalities and deletions).
-func (dmp *DiffMatchPatch) DiffText1(diffs []Diff) string {
- //StringBuilder text = new StringBuilder()
- var text bytes.Buffer
-
- for _, aDiff := range diffs {
- if aDiff.Type != DiffInsert {
- _, _ = text.WriteString(aDiff.Text)
- }
- }
- return text.String()
-}
-
-// DiffText2 computes and returns the destination text (all equalities and insertions).
-func (dmp *DiffMatchPatch) DiffText2(diffs []Diff) string {
- var text bytes.Buffer
-
- for _, aDiff := range diffs {
- if aDiff.Type != DiffDelete {
- _, _ = text.WriteString(aDiff.Text)
- }
- }
- return text.String()
-}
-
-// DiffLevenshtein computes the Levenshtein distance that is the number of inserted, deleted or substituted characters.
-func (dmp *DiffMatchPatch) DiffLevenshtein(diffs []Diff) int {
- levenshtein := 0
- insertions := 0
- deletions := 0
-
- for _, aDiff := range diffs {
- switch aDiff.Type {
- case DiffInsert:
- insertions += len(aDiff.Text)
- case DiffDelete:
- deletions += len(aDiff.Text)
- case DiffEqual:
- // A deletion and an insertion is one substitution.
- levenshtein += max(insertions, deletions)
- insertions = 0
- deletions = 0
- }
- }
-
- levenshtein += max(insertions, deletions)
- return levenshtein
-}
-
-// DiffToDelta crushes the diff into an encoded string which describes the operations required to transform text1 into text2.
-// E.g. =3\t-2\t+ing -> Keep 3 chars, delete 2 chars, insert 'ing'. Operations are tab-separated. Inserted text is escaped using %xx notation.
-func (dmp *DiffMatchPatch) DiffToDelta(diffs []Diff) string {
- var text bytes.Buffer
- for _, aDiff := range diffs {
- switch aDiff.Type {
- case DiffInsert:
- _, _ = text.WriteString("+")
- _, _ = text.WriteString(strings.Replace(url.QueryEscape(aDiff.Text), "+", " ", -1))
- _, _ = text.WriteString("\t")
- break
- case DiffDelete:
- _, _ = text.WriteString("-")
- _, _ = text.WriteString(strconv.Itoa(utf8.RuneCountInString(aDiff.Text)))
- _, _ = text.WriteString("\t")
- break
- case DiffEqual:
- _, _ = text.WriteString("=")
- _, _ = text.WriteString(strconv.Itoa(utf8.RuneCountInString(aDiff.Text)))
- _, _ = text.WriteString("\t")
- break
- }
- }
- delta := text.String()
- if len(delta) != 0 {
- // Strip off trailing tab character.
- delta = delta[0 : utf8.RuneCountInString(delta)-1]
- delta = unescaper.Replace(delta)
- }
- return delta
-}
-
-// DiffFromDelta given the original text1, and an encoded string which describes the operations required to transform text1 into text2, comAdde the full diff.
-func (dmp *DiffMatchPatch) DiffFromDelta(text1 string, delta string) (diffs []Diff, err error) {
- i := 0
- runes := []rune(text1)
-
- for _, token := range strings.Split(delta, "\t") {
- if len(token) == 0 {
- // Blank tokens are ok (from a trailing \t).
- continue
- }
-
- // Each token begins with a one character parameter which specifies the operation of this token (delete, insert, equality).
- param := token[1:]
-
- switch op := token[0]; op {
- case '+':
- // Decode would Diff all "+" to " "
- param = strings.Replace(param, "+", "%2b", -1)
- param, err = url.QueryUnescape(param)
- if err != nil {
- return nil, err
- }
- if !utf8.ValidString(param) {
- return nil, fmt.Errorf("invalid UTF-8 token: %q", param)
- }
-
- diffs = append(diffs, Diff{DiffInsert, param})
- case '=', '-':
- n, err := strconv.ParseInt(param, 10, 0)
- if err != nil {
- return nil, err
- } else if n < 0 {
- return nil, errors.New("Negative number in DiffFromDelta: " + param)
- }
-
- i += int(n)
- // Break out if we are out of bounds, go1.6 can't handle this very well
- if i > len(runes) {
- break
- }
- // Remember that string slicing is by byte - we want by rune here.
- text := string(runes[i-int(n) : i])
-
- if op == '=' {
- diffs = append(diffs, Diff{DiffEqual, text})
- } else {
- diffs = append(diffs, Diff{DiffDelete, text})
- }
- default:
- // Anything else is an error.
- return nil, errors.New("Invalid diff operation in DiffFromDelta: " + string(token[0]))
- }
- }
-
- if i != len(runes) {
- return nil, fmt.Errorf("Delta length (%v) is different from source text length (%v)", i, len(text1))
- }
-
- return diffs, nil
-}
diff --git a/vendor/github.com/sergi/go-diff/diffmatchpatch/diffmatchpatch.go b/vendor/github.com/sergi/go-diff/diffmatchpatch/diffmatchpatch.go
deleted file mode 100644
index d3acc32..0000000
--- a/vendor/github.com/sergi/go-diff/diffmatchpatch/diffmatchpatch.go
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright (c) 2012-2016 The go-diff authors. All rights reserved.
-// https://github.com/sergi/go-diff
-// See the included LICENSE file for license details.
-//
-// go-diff is a Go implementation of Google's Diff, Match, and Patch library
-// Original library is Copyright (c) 2006 Google Inc.
-// http://code.google.com/p/google-diff-match-patch/
-
-// Package diffmatchpatch offers robust algorithms to perform the operations required for synchronizing plain text.
-package diffmatchpatch
-
-import (
- "time"
-)
-
-// DiffMatchPatch holds the configuration for diff-match-patch operations.
-type DiffMatchPatch struct {
- // Number of seconds to map a diff before giving up (0 for infinity).
- DiffTimeout time.Duration
- // Cost of an empty edit operation in terms of edit characters.
- DiffEditCost int
- // How far to search for a match (0 = exact location, 1000+ = broad match). A match this many characters away from the expected location will add 1.0 to the score (0.0 is a perfect match).
- MatchDistance int
- // When deleting a large block of text (over ~64 characters), how close do the contents have to be to match the expected contents. (0.0 = perfection, 1.0 = very loose). Note that MatchThreshold controls how closely the end points of a delete need to match.
- PatchDeleteThreshold float64
- // Chunk size for context length.
- PatchMargin int
- // The number of bits in an int.
- MatchMaxBits int
- // At what point is no match declared (0.0 = perfection, 1.0 = very loose).
- MatchThreshold float64
-}
-
-// New creates a new DiffMatchPatch object with default parameters.
-func New() *DiffMatchPatch {
- // Defaults.
- return &DiffMatchPatch{
- DiffTimeout: time.Second,
- DiffEditCost: 4,
- MatchThreshold: 0.5,
- MatchDistance: 1000,
- PatchDeleteThreshold: 0.5,
- PatchMargin: 4,
- MatchMaxBits: 32,
- }
-}
diff --git a/vendor/github.com/sergi/go-diff/diffmatchpatch/match.go b/vendor/github.com/sergi/go-diff/diffmatchpatch/match.go
deleted file mode 100644
index 17374e1..0000000
--- a/vendor/github.com/sergi/go-diff/diffmatchpatch/match.go
+++ /dev/null
@@ -1,160 +0,0 @@
-// Copyright (c) 2012-2016 The go-diff authors. All rights reserved.
-// https://github.com/sergi/go-diff
-// See the included LICENSE file for license details.
-//
-// go-diff is a Go implementation of Google's Diff, Match, and Patch library
-// Original library is Copyright (c) 2006 Google Inc.
-// http://code.google.com/p/google-diff-match-patch/
-
-package diffmatchpatch
-
-import (
- "math"
-)
-
-// MatchMain locates the best instance of 'pattern' in 'text' near 'loc'.
-// Returns -1 if no match found.
-func (dmp *DiffMatchPatch) MatchMain(text, pattern string, loc int) int {
- // Check for null inputs not needed since null can't be passed in C#.
-
- loc = int(math.Max(0, math.Min(float64(loc), float64(len(text)))))
- if text == pattern {
- // Shortcut (potentially not guaranteed by the algorithm)
- return 0
- } else if len(text) == 0 {
- // Nothing to match.
- return -1
- } else if loc+len(pattern) <= len(text) && text[loc:loc+len(pattern)] == pattern {
- // Perfect match at the perfect spot! (Includes case of null pattern)
- return loc
- }
- // Do a fuzzy compare.
- return dmp.MatchBitap(text, pattern, loc)
-}
-
-// MatchBitap locates the best instance of 'pattern' in 'text' near 'loc' using the Bitap algorithm.
-// Returns -1 if no match was found.
-func (dmp *DiffMatchPatch) MatchBitap(text, pattern string, loc int) int {
- // Initialise the alphabet.
- s := dmp.MatchAlphabet(pattern)
-
- // Highest score beyond which we give up.
- scoreThreshold := dmp.MatchThreshold
- // Is there a nearby exact match? (speedup)
- bestLoc := indexOf(text, pattern, loc)
- if bestLoc != -1 {
- scoreThreshold = math.Min(dmp.matchBitapScore(0, bestLoc, loc,
- pattern), scoreThreshold)
- // What about in the other direction? (speedup)
- bestLoc = lastIndexOf(text, pattern, loc+len(pattern))
- if bestLoc != -1 {
- scoreThreshold = math.Min(dmp.matchBitapScore(0, bestLoc, loc,
- pattern), scoreThreshold)
- }
- }
-
- // Initialise the bit arrays.
- matchmask := 1 << uint((len(pattern) - 1))
- bestLoc = -1
-
- var binMin, binMid int
- binMax := len(pattern) + len(text)
- lastRd := []int{}
- for d := 0; d < len(pattern); d++ {
- // Scan for the best match; each iteration allows for one more error. Run a binary search to determine how far from 'loc' we can stray at this error level.
- binMin = 0
- binMid = binMax
- for binMin < binMid {
- if dmp.matchBitapScore(d, loc+binMid, loc, pattern) <= scoreThreshold {
- binMin = binMid
- } else {
- binMax = binMid
- }
- binMid = (binMax-binMin)/2 + binMin
- }
- // Use the result from this iteration as the maximum for the next.
- binMax = binMid
- start := int(math.Max(1, float64(loc-binMid+1)))
- finish := int(math.Min(float64(loc+binMid), float64(len(text))) + float64(len(pattern)))
-
- rd := make([]int, finish+2)
- rd[finish+1] = (1 << uint(d)) - 1
-
- for j := finish; j >= start; j-- {
- var charMatch int
- if len(text) <= j-1 {
- // Out of range.
- charMatch = 0
- } else if _, ok := s[text[j-1]]; !ok {
- charMatch = 0
- } else {
- charMatch = s[text[j-1]]
- }
-
- if d == 0 {
- // First pass: exact match.
- rd[j] = ((rd[j+1] << 1) | 1) & charMatch
- } else {
- // Subsequent passes: fuzzy match.
- rd[j] = ((rd[j+1]<<1)|1)&charMatch | (((lastRd[j+1] | lastRd[j]) << 1) | 1) | lastRd[j+1]
- }
- if (rd[j] & matchmask) != 0 {
- score := dmp.matchBitapScore(d, j-1, loc, pattern)
- // This match will almost certainly be better than any existing match. But check anyway.
- if score <= scoreThreshold {
- // Told you so.
- scoreThreshold = score
- bestLoc = j - 1
- if bestLoc > loc {
- // When passing loc, don't exceed our current distance from loc.
- start = int(math.Max(1, float64(2*loc-bestLoc)))
- } else {
- // Already passed loc, downhill from here on in.
- break
- }
- }
- }
- }
- if dmp.matchBitapScore(d+1, loc, loc, pattern) > scoreThreshold {
- // No hope for a (better) match at greater error levels.
- break
- }
- lastRd = rd
- }
- return bestLoc
-}
-
-// matchBitapScore computes and returns the score for a match with e errors and x location.
-func (dmp *DiffMatchPatch) matchBitapScore(e, x, loc int, pattern string) float64 {
- accuracy := float64(e) / float64(len(pattern))
- proximity := math.Abs(float64(loc - x))
- if dmp.MatchDistance == 0 {
- // Dodge divide by zero error.
- if proximity == 0 {
- return accuracy
- }
-
- return 1.0
- }
- return accuracy + (proximity / float64(dmp.MatchDistance))
-}
-
-// MatchAlphabet initialises the alphabet for the Bitap algorithm.
-func (dmp *DiffMatchPatch) MatchAlphabet(pattern string) map[byte]int {
- s := map[byte]int{}
- charPattern := []byte(pattern)
- for _, c := range charPattern {
- _, ok := s[c]
- if !ok {
- s[c] = 0
- }
- }
- i := 0
-
- for _, c := range charPattern {
- value := s[c] | int(uint(1)<
[](https://travis-ci.org/sirupsen/logrus) [](https://godoc.org/github.com/sirupsen/logrus)
-
-Logrus is a structured logger for Go (golang), completely API compatible with
-the standard library logger.
-
-**Seeing weird case-sensitive problems?** It's in the past been possible to
-import Logrus as both upper- and lower-case. Due to the Go package environment,
-this caused issues in the community and we needed a standard. Some environments
-experienced problems with the upper-case variant, so the lower-case was decided.
-Everything using `logrus` will need to use the lower-case:
-`github.com/sirupsen/logrus`. Any package that isn't, should be changed.
-
-To fix Glide, see [these
-comments](https://github.com/sirupsen/logrus/issues/553#issuecomment-306591437).
-For an in-depth explanation of the casing issue, see [this
-comment](https://github.com/sirupsen/logrus/issues/570#issuecomment-313933276).
-
-**Are you interested in assisting in maintaining Logrus?** Currently I have a
-lot of obligations, and I am unable to provide Logrus with the maintainership it
-needs. If you'd like to help, please reach out to me at `simon at author's
-username dot com`.
-
-Nicely color-coded in development (when a TTY is attached, otherwise just
-plain text):
-
-
-
-With `log.SetFormatter(&log.JSONFormatter{})`, for easy parsing by logstash
-or Splunk:
-
-```json
-{"animal":"walrus","level":"info","msg":"A group of walrus emerges from the
-ocean","size":10,"time":"2014-03-10 19:57:38.562264131 -0400 EDT"}
-
-{"level":"warning","msg":"The group's number increased tremendously!",
-"number":122,"omg":true,"time":"2014-03-10 19:57:38.562471297 -0400 EDT"}
-
-{"animal":"walrus","level":"info","msg":"A giant walrus appears!",
-"size":10,"time":"2014-03-10 19:57:38.562500591 -0400 EDT"}
-
-{"animal":"walrus","level":"info","msg":"Tremendously sized cow enters the ocean.",
-"size":9,"time":"2014-03-10 19:57:38.562527896 -0400 EDT"}
-
-{"level":"fatal","msg":"The ice breaks!","number":100,"omg":true,
-"time":"2014-03-10 19:57:38.562543128 -0400 EDT"}
-```
-
-With the default `log.SetFormatter(&log.TextFormatter{})` when a TTY is not
-attached, the output is compatible with the
-[logfmt](http://godoc.org/github.com/kr/logfmt) format:
-
-```text
-time="2015-03-26T01:27:38-04:00" level=debug msg="Started observing beach" animal=walrus number=8
-time="2015-03-26T01:27:38-04:00" level=info msg="A group of walrus emerges from the ocean" animal=walrus size=10
-time="2015-03-26T01:27:38-04:00" level=warning msg="The group's number increased tremendously!" number=122 omg=true
-time="2015-03-26T01:27:38-04:00" level=debug msg="Temperature changes" temperature=-4
-time="2015-03-26T01:27:38-04:00" level=panic msg="It's over 9000!" animal=orca size=9009
-time="2015-03-26T01:27:38-04:00" level=fatal msg="The ice breaks!" err=&{0x2082280c0 map[animal:orca size:9009] 2015-03-26 01:27:38.441574009 -0400 EDT panic It's over 9000!} number=100 omg=true
-exit status 1
-```
-
-#### Case-sensitivity
-
-The organization's name was changed to lower-case--and this will not be changed
-back. If you are getting import conflicts due to case sensitivity, please use
-the lower-case import: `github.com/sirupsen/logrus`.
-
-#### Example
-
-The simplest way to use Logrus is simply the package-level exported logger:
-
-```go
-package main
-
-import (
- log "github.com/sirupsen/logrus"
-)
-
-func main() {
- log.WithFields(log.Fields{
- "animal": "walrus",
- }).Info("A walrus appears")
-}
-```
-
-Note that it's completely api-compatible with the stdlib logger, so you can
-replace your `log` imports everywhere with `log "github.com/sirupsen/logrus"`
-and you'll now have the flexibility of Logrus. You can customize it all you
-want:
-
-```go
-package main
-
-import (
- "os"
- log "github.com/sirupsen/logrus"
-)
-
-func init() {
- // Log as JSON instead of the default ASCII formatter.
- log.SetFormatter(&log.JSONFormatter{})
-
- // Output to stdout instead of the default stderr
- // Can be any io.Writer, see below for File example
- log.SetOutput(os.Stdout)
-
- // Only log the warning severity or above.
- log.SetLevel(log.WarnLevel)
-}
-
-func main() {
- log.WithFields(log.Fields{
- "animal": "walrus",
- "size": 10,
- }).Info("A group of walrus emerges from the ocean")
-
- log.WithFields(log.Fields{
- "omg": true,
- "number": 122,
- }).Warn("The group's number increased tremendously!")
-
- log.WithFields(log.Fields{
- "omg": true,
- "number": 100,
- }).Fatal("The ice breaks!")
-
- // A common pattern is to re-use fields between logging statements by re-using
- // the logrus.Entry returned from WithFields()
- contextLogger := log.WithFields(log.Fields{
- "common": "this is a common field",
- "other": "I also should be logged always",
- })
-
- contextLogger.Info("I'll be logged with common and other field")
- contextLogger.Info("Me too")
-}
-```
-
-For more advanced usage such as logging to multiple locations from the same
-application, you can also create an instance of the `logrus` Logger:
-
-```go
-package main
-
-import (
- "os"
- "github.com/sirupsen/logrus"
-)
-
-// Create a new instance of the logger. You can have any number of instances.
-var log = logrus.New()
-
-func main() {
- // The API for setting attributes is a little different than the package level
- // exported logger. See Godoc.
- log.Out = os.Stdout
-
- // You could set this to any `io.Writer` such as a file
- // file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY, 0666)
- // if err == nil {
- // log.Out = file
- // } else {
- // log.Info("Failed to log to file, using default stderr")
- // }
-
- log.WithFields(logrus.Fields{
- "animal": "walrus",
- "size": 10,
- }).Info("A group of walrus emerges from the ocean")
-}
-```
-
-#### Fields
-
-Logrus encourages careful, structured logging through logging fields instead of
-long, unparseable error messages. For example, instead of: `log.Fatalf("Failed
-to send event %s to topic %s with key %d")`, you should log the much more
-discoverable:
-
-```go
-log.WithFields(log.Fields{
- "event": event,
- "topic": topic,
- "key": key,
-}).Fatal("Failed to send event")
-```
-
-We've found this API forces you to think about logging in a way that produces
-much more useful logging messages. We've been in countless situations where just
-a single added field to a log statement that was already there would've saved us
-hours. The `WithFields` call is optional.
-
-In general, with Logrus using any of the `printf`-family functions should be
-seen as a hint you should add a field, however, you can still use the
-`printf`-family functions with Logrus.
-
-#### Default Fields
-
-Often it's helpful to have fields _always_ attached to log statements in an
-application or parts of one. For example, you may want to always log the
-`request_id` and `user_ip` in the context of a request. Instead of writing
-`log.WithFields(log.Fields{"request_id": request_id, "user_ip": user_ip})` on
-every line, you can create a `logrus.Entry` to pass around instead:
-
-```go
-requestLogger := log.WithFields(log.Fields{"request_id": request_id, "user_ip": user_ip})
-requestLogger.Info("something happened on that request") # will log request_id and user_ip
-requestLogger.Warn("something not great happened")
-```
-
-#### Hooks
-
-You can add hooks for logging levels. For example to send errors to an exception
-tracking service on `Error`, `Fatal` and `Panic`, info to StatsD or log to
-multiple places simultaneously, e.g. syslog.
-
-Logrus comes with [built-in hooks](hooks/). Add those, or your custom hook, in
-`init`:
-
-```go
-import (
- log "github.com/sirupsen/logrus"
- "gopkg.in/gemnasium/logrus-airbrake-hook.v2" // the package is named "airbrake"
- logrus_syslog "github.com/sirupsen/logrus/hooks/syslog"
- "log/syslog"
-)
-
-func init() {
-
- // Use the Airbrake hook to report errors that have Error severity or above to
- // an exception tracker. You can create custom hooks, see the Hooks section.
- log.AddHook(airbrake.NewHook(123, "xyz", "production"))
-
- hook, err := logrus_syslog.NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "")
- if err != nil {
- log.Error("Unable to connect to local syslog daemon")
- } else {
- log.AddHook(hook)
- }
-}
-```
-Note: Syslog hook also support connecting to local syslog (Ex. "/dev/log" or "/var/run/syslog" or "/var/run/log"). For the detail, please check the [syslog hook README](hooks/syslog/README.md).
-
-A list of currently known of service hook can be found in this wiki [page](https://github.com/sirupsen/logrus/wiki/Hooks)
-
-
-#### Level logging
-
-Logrus has six logging levels: Debug, Info, Warning, Error, Fatal and Panic.
-
-```go
-log.Debug("Useful debugging information.")
-log.Info("Something noteworthy happened!")
-log.Warn("You should probably take a look at this.")
-log.Error("Something failed but I'm not quitting.")
-// Calls os.Exit(1) after logging
-log.Fatal("Bye.")
-// Calls panic() after logging
-log.Panic("I'm bailing.")
-```
-
-You can set the logging level on a `Logger`, then it will only log entries with
-that severity or anything above it:
-
-```go
-// Will log anything that is info or above (warn, error, fatal, panic). Default.
-log.SetLevel(log.InfoLevel)
-```
-
-It may be useful to set `log.Level = logrus.DebugLevel` in a debug or verbose
-environment if your application has that.
-
-#### Entries
-
-Besides the fields added with `WithField` or `WithFields` some fields are
-automatically added to all logging events:
-
-1. `time`. The timestamp when the entry was created.
-2. `msg`. The logging message passed to `{Info,Warn,Error,Fatal,Panic}` after
- the `AddFields` call. E.g. `Failed to send event.`
-3. `level`. The logging level. E.g. `info`.
-
-#### Environments
-
-Logrus has no notion of environment.
-
-If you wish for hooks and formatters to only be used in specific environments,
-you should handle that yourself. For example, if your application has a global
-variable `Environment`, which is a string representation of the environment you
-could do:
-
-```go
-import (
- log "github.com/sirupsen/logrus"
-)
-
-init() {
- // do something here to set environment depending on an environment variable
- // or command-line flag
- if Environment == "production" {
- log.SetFormatter(&log.JSONFormatter{})
- } else {
- // The TextFormatter is default, you don't actually have to do this.
- log.SetFormatter(&log.TextFormatter{})
- }
-}
-```
-
-This configuration is how `logrus` was intended to be used, but JSON in
-production is mostly only useful if you do log aggregation with tools like
-Splunk or Logstash.
-
-#### Formatters
-
-The built-in logging formatters are:
-
-* `logrus.TextFormatter`. Logs the event in colors if stdout is a tty, otherwise
- without colors.
- * *Note:* to force colored output when there is no TTY, set the `ForceColors`
- field to `true`. To force no colored output even if there is a TTY set the
- `DisableColors` field to `true`. For Windows, see
- [github.com/mattn/go-colorable](https://github.com/mattn/go-colorable).
- * When colors are enabled, levels are truncated to 4 characters by default. To disable
- truncation set the `DisableLevelTruncation` field to `true`.
- * All options are listed in the [generated docs](https://godoc.org/github.com/sirupsen/logrus#TextFormatter).
-* `logrus.JSONFormatter`. Logs fields as JSON.
- * All options are listed in the [generated docs](https://godoc.org/github.com/sirupsen/logrus#JSONFormatter).
-
-Third party logging formatters:
-
-* [`FluentdFormatter`](https://github.com/joonix/log). Formats entries that can be parsed by Kubernetes and Google Container Engine.
-* [`logstash`](https://github.com/bshuster-repo/logrus-logstash-hook). Logs fields as [Logstash](http://logstash.net) Events.
-* [`prefixed`](https://github.com/x-cray/logrus-prefixed-formatter). Displays log entry source along with alternative layout.
-* [`zalgo`](https://github.com/aybabtme/logzalgo). Invoking the P͉̫o̳̼̊w̖͈̰͎e̬͔̭͂r͚̼̹̲ ̫͓͉̳͈ō̠͕͖̚f̝͍̠ ͕̲̞͖͑Z̖̫̤̫ͪa͉̬͈̗l͖͎g̳̥o̰̥̅!̣͔̲̻͊̄ ̙̘̦̹̦.
-
-You can define your formatter by implementing the `Formatter` interface,
-requiring a `Format` method. `Format` takes an `*Entry`. `entry.Data` is a
-`Fields` type (`map[string]interface{}`) with all your fields as well as the
-default ones (see Entries section above):
-
-```go
-type MyJSONFormatter struct {
-}
-
-log.SetFormatter(new(MyJSONFormatter))
-
-func (f *MyJSONFormatter) Format(entry *Entry) ([]byte, error) {
- // Note this doesn't include Time, Level and Message which are available on
- // the Entry. Consult `godoc` on information about those fields or read the
- // source of the official loggers.
- serialized, err := json.Marshal(entry.Data)
- if err != nil {
- return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
- }
- return append(serialized, '\n'), nil
-}
-```
-
-#### Logger as an `io.Writer`
-
-Logrus can be transformed into an `io.Writer`. That writer is the end of an `io.Pipe` and it is your responsibility to close it.
-
-```go
-w := logger.Writer()
-defer w.Close()
-
-srv := http.Server{
- // create a stdlib log.Logger that writes to
- // logrus.Logger.
- ErrorLog: log.New(w, "", 0),
-}
-```
-
-Each line written to that writer will be printed the usual way, using formatters
-and hooks. The level for those entries is `info`.
-
-This means that we can override the standard library logger easily:
-
-```go
-logger := logrus.New()
-logger.Formatter = &logrus.JSONFormatter{}
-
-// Use logrus for standard log output
-// Note that `log` here references stdlib's log
-// Not logrus imported under the name `log`.
-log.SetOutput(logger.Writer())
-```
-
-#### Rotation
-
-Log rotation is not provided with Logrus. Log rotation should be done by an
-external program (like `logrotate(8)`) that can compress and delete old log
-entries. It should not be a feature of the application-level logger.
-
-#### Tools
-
-| Tool | Description |
-| ---- | ----------- |
-|[Logrus Mate](https://github.com/gogap/logrus_mate)|Logrus mate is a tool for Logrus to manage loggers, you can initial logger's level, hook and formatter by config file, the logger will generated with different config at different environment.|
-|[Logrus Viper Helper](https://github.com/heirko/go-contrib/tree/master/logrusHelper)|An Helper around Logrus to wrap with spf13/Viper to load configuration with fangs! And to simplify Logrus configuration use some behavior of [Logrus Mate](https://github.com/gogap/logrus_mate). [sample](https://github.com/heirko/iris-contrib/blob/master/middleware/logrus-logger/example) |
-
-#### Testing
-
-Logrus has a built in facility for asserting the presence of log messages. This is implemented through the `test` hook and provides:
-
-* decorators for existing logger (`test.NewLocal` and `test.NewGlobal`) which basically just add the `test` hook
-* a test logger (`test.NewNullLogger`) that just records log messages (and does not output any):
-
-```go
-import(
- "github.com/sirupsen/logrus"
- "github.com/sirupsen/logrus/hooks/test"
- "github.com/stretchr/testify/assert"
- "testing"
-)
-
-func TestSomething(t*testing.T){
- logger, hook := test.NewNullLogger()
- logger.Error("Helloerror")
-
- assert.Equal(t, 1, len(hook.Entries))
- assert.Equal(t, logrus.ErrorLevel, hook.LastEntry().Level)
- assert.Equal(t, "Helloerror", hook.LastEntry().Message)
-
- hook.Reset()
- assert.Nil(t, hook.LastEntry())
-}
-```
-
-#### Fatal handlers
-
-Logrus can register one or more functions that will be called when any `fatal`
-level message is logged. The registered handlers will be executed before
-logrus performs a `os.Exit(1)`. This behavior may be helpful if callers need
-to gracefully shutdown. Unlike a `panic("Something went wrong...")` call which can be intercepted with a deferred `recover` a call to `os.Exit(1)` can not be intercepted.
-
-```
-...
-handler := func() {
- // gracefully shutdown something...
-}
-logrus.RegisterExitHandler(handler)
-...
-```
-
-#### Thread safety
-
-By default, Logger is protected by a mutex for concurrent writes. The mutex is held when calling hooks and writing logs.
-If you are sure such locking is not needed, you can call logger.SetNoLock() to disable the locking.
-
-Situation when locking is not needed includes:
-
-* You have no hooks registered, or hooks calling is already thread-safe.
-
-* Writing to logger.Out is already thread-safe, for example:
-
- 1) logger.Out is protected by locks.
-
- 2) logger.Out is a os.File handler opened with `O_APPEND` flag, and every write is smaller than 4k. (This allow multi-thread/multi-process writing)
-
- (Refer to http://www.notthewizard.com/2014/06/17/are-files-appends-really-atomic/)
diff --git a/vendor/github.com/sirupsen/logrus/alt_exit.go b/vendor/github.com/sirupsen/logrus/alt_exit.go
deleted file mode 100644
index 8af9063..0000000
--- a/vendor/github.com/sirupsen/logrus/alt_exit.go
+++ /dev/null
@@ -1,64 +0,0 @@
-package logrus
-
-// The following code was sourced and modified from the
-// https://github.com/tebeka/atexit package governed by the following license:
-//
-// Copyright (c) 2012 Miki Tebeka ...
`-wrapped list to display line numbers.
-
-```go
-package syntaxhighlight_test
-
-import (
- "fmt"
- "os"
-
- "github.com/sourcegraph/syntaxhighlight"
-)
-
-func Example() {
- src := []byte(`
-/* hello, world! */
-var a = 3;
-
-// b is a cool function
-function b() {
- return 7;
-}`)
-
- highlighted, err := syntaxhighlight.AsHTML(src)
- if err != nil {
- fmt.Println(err)
- os.Exit(1)
- }
-
- fmt.Println(string(highlighted))
-
- // Output:
- // /* hello, world! */
- // var a = 3;
- //
- // // b is a cool function
- // function b() {
- // return 7;
- // }
-}
-```
-
-## Contributors
-
-* [Quinn Slack](https://sourcegraph.com/sqs)
-
-Contributions are welcome! Submit a pull request on GitHub.
diff --git a/vendor/github.com/sourcegraph/syntaxhighlight/benchmark.txt b/vendor/github.com/sourcegraph/syntaxhighlight/benchmark.txt
deleted file mode 100644
index 2923a0f..0000000
--- a/vendor/github.com/sourcegraph/syntaxhighlight/benchmark.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-PASS
-BenchmarkAnnotate-12 20000 80528 ns/op 18192 B/op 428 allocs/op
-ok github.com/sourcegraph/syntaxhighlight 2.424s
diff --git a/vendor/github.com/sourcegraph/syntaxhighlight/highlight.go b/vendor/github.com/sourcegraph/syntaxhighlight/highlight.go
deleted file mode 100644
index 9ff794c..0000000
--- a/vendor/github.com/sourcegraph/syntaxhighlight/highlight.go
+++ /dev/null
@@ -1,295 +0,0 @@
-// Package syntaxhighlight provides syntax highlighting for code. It currently
-// uses a language-independent lexer and performs decently on JavaScript, Java,
-// Ruby, Python, Go, and C.
-package syntaxhighlight
-
-import (
- "bytes"
- "io"
- "strings"
- "text/scanner"
- "text/template"
- "unicode"
- "unicode/utf8"
-
- "github.com/sourcegraph/annotate"
-)
-
-// Kind represents a syntax highlighting kind (class) which will be assigned to tokens.
-// A syntax highlighting scheme (style) maps text style properties to each token kind.
-type Kind uint8
-
-// A set of supported highlighting kinds
-const (
- Whitespace Kind = iota
- String
- Keyword
- Comment
- Type
- Literal
- Punctuation
- Plaintext
- Tag
- HTMLTag
- HTMLAttrName
- HTMLAttrValue
- Decimal
-)
-
-//go:generate gostringer -type=Kind
-
-// Printer implements an interface to render highlighted output
-// (see HTMLPrinter for the implementation of this interface)
-type Printer interface {
- Print(w io.Writer, kind Kind, tokText string) error
-}
-
-// HTMLConfig holds the HTML class configuration to be used by annotators when
-// highlighting code.
-type HTMLConfig struct {
- String string
- Keyword string
- Comment string
- Type string
- Literal string
- Punctuation string
- Plaintext string
- Tag string
- HTMLTag string
- HTMLAttrName string
- HTMLAttrValue string
- Decimal string
- Whitespace string
-
- AsOrderedList bool
-}
-
-// HTMLPrinter implements Printer interface and is used to produce
-// HTML-based highligher
-type HTMLPrinter HTMLConfig
-
-// Class returns the set class for a given token Kind.
-func (c HTMLConfig) Class(kind Kind) string {
- switch kind {
- case String:
- return c.String
- case Keyword:
- return c.Keyword
- case Comment:
- return c.Comment
- case Type:
- return c.Type
- case Literal:
- return c.Literal
- case Punctuation:
- return c.Punctuation
- case Plaintext:
- return c.Plaintext
- case Tag:
- return c.Tag
- case HTMLTag:
- return c.HTMLTag
- case HTMLAttrName:
- return c.HTMLAttrName
- case HTMLAttrValue:
- return c.HTMLAttrValue
- case Decimal:
- return c.Decimal
- }
- return ""
-}
-
-// Print is the function that emits highlighted source code using
-// ... wrapper tags
-func (p HTMLPrinter) Print(w io.Writer, kind Kind, tokText string) error {
- if p.AsOrderedList {
- if i := strings.Index(tokText, "\n"); i > -1 {
- if err := p.Print(w, kind, tokText[:i]); err != nil {
- return err
- }
- w.Write([]byte("\n\n
"))
- }
- if err != nil {
- return nil, err
- }
- return buf.Bytes(), nil
-}
-
-// NewScanner is a helper that takes a []byte src, wraps it in a reader and creates a Scanner.
-func NewScanner(src []byte) *scanner.Scanner {
- return NewScannerReader(bytes.NewReader(src))
-}
-
-// NewScannerReader takes a reader src and creates a Scanner.
-func NewScannerReader(src io.Reader) *scanner.Scanner {
- var s scanner.Scanner
- s.Init(src)
- s.Error = func(_ *scanner.Scanner, _ string) {}
- s.Whitespace = 0
- s.Mode = s.Mode ^ scanner.SkipComments
- return &s
-}
-
-func tokenKind(tok rune, tokText string) Kind {
- switch tok {
- case scanner.Ident:
- if _, isKW := keywords[tokText]; isKW {
- return Keyword
- }
- if r, _ := utf8.DecodeRuneInString(tokText); unicode.IsUpper(r) {
- return Type
- }
- return Plaintext
- case scanner.Float, scanner.Int:
- return Decimal
- case scanner.Char, scanner.String, scanner.RawString:
- return String
- case scanner.Comment:
- return Comment
- }
- if unicode.IsSpace(tok) {
- return Whitespace
- }
- return Punctuation
-}
diff --git a/vendor/github.com/sourcegraph/syntaxhighlight/keywords.go b/vendor/github.com/sourcegraph/syntaxhighlight/keywords.go
deleted file mode 100644
index 85729d6..0000000
--- a/vendor/github.com/sourcegraph/syntaxhighlight/keywords.go
+++ /dev/null
@@ -1,177 +0,0 @@
-package syntaxhighlight
-
-var keywords = map[string]struct{}{
- "BEGIN": {},
- "END": {},
- "False": {},
- "Infinity": {},
- "NaN": {},
- "None": {},
- "True": {},
- "abstract": {},
- "alias": {},
- "align_union": {},
- "alignof": {},
- "and": {},
- "append": {},
- "as": {},
- "asm": {},
- "assert": {},
- "auto": {},
- "axiom": {},
- "begin": {},
- "bool": {},
- "boolean": {},
- "break": {},
- "byte": {},
- "caller": {},
- "case": {},
- "catch": {},
- "char": {},
- "class": {},
- "concept": {},
- "concept_map": {},
- "const": {},
- "const_cast": {},
- "constexpr": {},
- "continue": {},
- "debugger": {},
- "decltype": {},
- "def": {},
- "default": {},
- "defined": {},
- "del": {},
- "delegate": {},
- "delete": {},
- "die": {},
- "do": {},
- "double": {},
- "dump": {},
- "dynamic_cast": {},
- "elif": {},
- "else": {},
- "elsif": {},
- "end": {},
- "ensure": {},
- "enum": {},
- "eval": {},
- "except": {},
- "exec": {},
- "exit": {},
- "explicit": {},
- "export": {},
- "extends": {},
- "extern": {},
- "false": {},
- "final": {},
- "finally": {},
- "float": {},
- "float32": {},
- "float64": {},
- "for": {},
- "foreach": {},
- "friend": {},
- "from": {},
- "func": {},
- "function": {},
- "generic": {},
- "get": {},
- "global": {},
- "goto": {},
- "if": {},
- "implements": {},
- "import": {},
- "in": {},
- "inline": {},
- "instanceof": {},
- "int": {},
- "int8": {},
- "int16": {},
- "int32": {},
- "int64": {},
- "interface": {},
- "is": {},
- "lambda": {},
- "last": {},
- "late_check": {},
- "local": {},
- "long": {},
- "make": {},
- "map": {},
- "module": {},
- "mutable": {},
- "my": {},
- "namespace": {},
- "native": {},
- "new": {},
- "next": {},
- "nil": {},
- "no": {},
- "nonlocal": {},
- "not": {},
- "null": {},
- "nullptr": {},
- "operator": {},
- "or": {},
- "our": {},
- "package": {},
- "pass": {},
- "print": {},
- "private": {},
- "property": {},
- "protected": {},
- "public": {},
- "raise": {},
- "redo": {},
- "register": {},
- "reinterpret_cast": {},
- "require": {},
- "rescue": {},
- "retry": {},
- "return": {},
- "self": {},
- "set": {},
- "short": {},
- "signed": {},
- "sizeof": {},
- "static": {},
- "static_assert": {},
- "static_cast": {},
- "strictfp": {},
- "struct": {},
- "sub": {},
- "super": {},
- "switch": {},
- "synchronized": {},
- "template": {},
- "then": {},
- "this": {},
- "throw": {},
- "throws": {},
- "transient": {},
- "true": {},
- "try": {},
- "type": {},
- "typedef": {},
- "typeid": {},
- "typename": {},
- "typeof": {},
- "undef": {},
- "undefined": {},
- "union": {},
- "unless": {},
- "unsigned": {},
- "until": {},
- "use": {},
- "using": {},
- "var": {},
- "virtual": {},
- "void": {},
- "volatile": {},
- "wantarray": {},
- "when": {},
- "where": {},
- "while": {},
- "with": {},
- "yield": {},
-}
diff --git a/vendor/github.com/sourcegraph/syntaxhighlight/kind_gostring.go b/vendor/github.com/sourcegraph/syntaxhighlight/kind_gostring.go
deleted file mode 100644
index 2fc73ec..0000000
--- a/vendor/github.com/sourcegraph/syntaxhighlight/kind_gostring.go
+++ /dev/null
@@ -1,16 +0,0 @@
-// generated by gostringer -type=Kind; DO NOT EDIT
-
-package syntaxhighlight
-
-import "fmt"
-
-const _Kind_name = "WhitespaceStringKeywordCommentTypeLiteralPunctuationPlaintextTagHTMLTagHTMLAttrNameHTMLAttrValueDecimal"
-
-var _Kind_index = [...]uint8{0, 10, 16, 23, 30, 34, 41, 52, 61, 64, 71, 83, 96, 103}
-
-func (i Kind) GoString() string {
- if i+1 >= Kind(len(_Kind_index)) {
- return fmt.Sprintf("syntaxhighlight.Kind(%d)", i)
- }
- return "syntaxhighlight." + _Kind_name[_Kind_index[i]:_Kind_index[i+1]]
-}
diff --git a/vendor/github.com/spf13/cobra/.gitignore b/vendor/github.com/spf13/cobra/.gitignore
deleted file mode 100644
index 1b8c7c2..0000000
--- a/vendor/github.com/spf13/cobra/.gitignore
+++ /dev/null
@@ -1,36 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-# Vim files https://github.com/github/gitignore/blob/master/Global/Vim.gitignore
-# swap
-[._]*.s[a-w][a-z]
-[._]s[a-w][a-z]
-# session
-Session.vim
-# temporary
-.netrwhist
-*~
-# auto-generated tag files
-tags
-
-*.exe
-
-cobra.test
diff --git a/vendor/github.com/spf13/cobra/.mailmap b/vendor/github.com/spf13/cobra/.mailmap
deleted file mode 100644
index 94ec530..0000000
--- a/vendor/github.com/spf13/cobra/.mailmap
+++ /dev/null
@@ -1,3 +0,0 @@
-Steve Francia
are treated as start tags, except that
- // hasSelfClosingToken is set while they are being processed.
- hasSelfClosingToken bool
- // doc is the document root element.
- doc *Node
- // The stack of open elements (section 12.2.4.2) and active formatting
- // elements (section 12.2.4.3).
- oe, afe nodeStack
- // Element pointers (section 12.2.4.4).
- head, form *Node
- // Other parsing state flags (section 12.2.4.5).
- scripting, framesetOK bool
- // The stack of template insertion modes
- templateStack insertionModeStack
- // im is the current insertion mode.
- im insertionMode
- // originalIM is the insertion mode to go back to after completing a text
- // or inTableText insertion mode.
- originalIM insertionMode
- // fosterParenting is whether new elements should be inserted according to
- // the foster parenting rules (section 12.2.6.1).
- fosterParenting bool
- // quirks is whether the parser is operating in "quirks mode."
- quirks bool
- // fragment is whether the parser is parsing an HTML fragment.
- fragment bool
- // context is the context element when parsing an HTML fragment
- // (section 12.4).
- context *Node
-}
-
-func (p *parser) top() *Node {
- if n := p.oe.top(); n != nil {
- return n
- }
- return p.doc
-}
-
-// Stop tags for use in popUntil. These come from section 12.2.4.2.
-var (
- defaultScopeStopTags = map[string][]a.Atom{
- "": {a.Applet, a.Caption, a.Html, a.Table, a.Td, a.Th, a.Marquee, a.Object, a.Template},
- "math": {a.AnnotationXml, a.Mi, a.Mn, a.Mo, a.Ms, a.Mtext},
- "svg": {a.Desc, a.ForeignObject, a.Title},
- }
-)
-
-type scope int
-
-const (
- defaultScope scope = iota
- listItemScope
- buttonScope
- tableScope
- tableRowScope
- tableBodyScope
- selectScope
-)
-
-// popUntil pops the stack of open elements at the highest element whose tag
-// is in matchTags, provided there is no higher element in the scope's stop
-// tags (as defined in section 12.2.4.2). It returns whether or not there was
-// such an element. If there was not, popUntil leaves the stack unchanged.
-//
-// For example, the set of stop tags for table scope is: "html", "table". If
-// the stack was:
-// ["html", "body", "font", "table", "b", "i", "u"]
-// then popUntil(tableScope, "font") would return false, but
-// popUntil(tableScope, "i") would return true and the stack would become:
-// ["html", "body", "font", "table", "b"]
-//
-// If an element's tag is in both the stop tags and matchTags, then the stack
-// will be popped and the function returns true (provided, of course, there was
-// no higher element in the stack that was also in the stop tags). For example,
-// popUntil(tableScope, "table") returns true and leaves:
-// ["html", "body", "font"]
-func (p *parser) popUntil(s scope, matchTags ...a.Atom) bool {
- if i := p.indexOfElementInScope(s, matchTags...); i != -1 {
- p.oe = p.oe[:i]
- return true
- }
- return false
-}
-
-// indexOfElementInScope returns the index in p.oe of the highest element whose
-// tag is in matchTags that is in scope. If no matching element is in scope, it
-// returns -1.
-func (p *parser) indexOfElementInScope(s scope, matchTags ...a.Atom) int {
- for i := len(p.oe) - 1; i >= 0; i-- {
- tagAtom := p.oe[i].DataAtom
- if p.oe[i].Namespace == "" {
- for _, t := range matchTags {
- if t == tagAtom {
- return i
- }
- }
- switch s {
- case defaultScope:
- // No-op.
- case listItemScope:
- if tagAtom == a.Ol || tagAtom == a.Ul {
- return -1
- }
- case buttonScope:
- if tagAtom == a.Button {
- return -1
- }
- case tableScope:
- if tagAtom == a.Html || tagAtom == a.Table || tagAtom == a.Template {
- return -1
- }
- case selectScope:
- if tagAtom != a.Optgroup && tagAtom != a.Option {
- return -1
- }
- default:
- panic("unreachable")
- }
- }
- switch s {
- case defaultScope, listItemScope, buttonScope:
- for _, t := range defaultScopeStopTags[p.oe[i].Namespace] {
- if t == tagAtom {
- return -1
- }
- }
- }
- }
- return -1
-}
-
-// elementInScope is like popUntil, except that it doesn't modify the stack of
-// open elements.
-func (p *parser) elementInScope(s scope, matchTags ...a.Atom) bool {
- return p.indexOfElementInScope(s, matchTags...) != -1
-}
-
-// clearStackToContext pops elements off the stack of open elements until a
-// scope-defined element is found.
-func (p *parser) clearStackToContext(s scope) {
- for i := len(p.oe) - 1; i >= 0; i-- {
- tagAtom := p.oe[i].DataAtom
- switch s {
- case tableScope:
- if tagAtom == a.Html || tagAtom == a.Table || tagAtom == a.Template {
- p.oe = p.oe[:i+1]
- return
- }
- case tableRowScope:
- if tagAtom == a.Html || tagAtom == a.Tr || tagAtom == a.Template {
- p.oe = p.oe[:i+1]
- return
- }
- case tableBodyScope:
- if tagAtom == a.Html || tagAtom == a.Tbody || tagAtom == a.Tfoot || tagAtom == a.Thead || tagAtom == a.Template {
- p.oe = p.oe[:i+1]
- return
- }
- default:
- panic("unreachable")
- }
- }
-}
-
-// generateImpliedEndTags pops nodes off the stack of open elements as long as
-// the top node has a tag name of dd, dt, li, optgroup, option, p, rb, rp, rt or rtc.
-// If exceptions are specified, nodes with that name will not be popped off.
-func (p *parser) generateImpliedEndTags(exceptions ...string) {
- var i int
-loop:
- for i = len(p.oe) - 1; i >= 0; i-- {
- n := p.oe[i]
- if n.Type == ElementNode {
- switch n.DataAtom {
- case a.Dd, a.Dt, a.Li, a.Optgroup, a.Option, a.P, a.Rb, a.Rp, a.Rt, a.Rtc:
- for _, except := range exceptions {
- if n.Data == except {
- break loop
- }
- }
- continue
- }
- }
- break
- }
-
- p.oe = p.oe[:i+1]
-}
-
-// addChild adds a child node n to the top element, and pushes n onto the stack
-// of open elements if it is an element node.
-func (p *parser) addChild(n *Node) {
- if p.shouldFosterParent() {
- p.fosterParent(n)
- } else {
- p.top().AppendChild(n)
- }
-
- if n.Type == ElementNode {
- p.oe = append(p.oe, n)
- }
-}
-
-// shouldFosterParent returns whether the next node to be added should be
-// foster parented.
-func (p *parser) shouldFosterParent() bool {
- if p.fosterParenting {
- switch p.top().DataAtom {
- case a.Table, a.Tbody, a.Tfoot, a.Thead, a.Tr:
- return true
- }
- }
- return false
-}
-
-// fosterParent adds a child node according to the foster parenting rules.
-// Section 12.2.6.1, "foster parenting".
-func (p *parser) fosterParent(n *Node) {
- var table, parent, prev, template *Node
- var i int
- for i = len(p.oe) - 1; i >= 0; i-- {
- if p.oe[i].DataAtom == a.Table {
- table = p.oe[i]
- break
- }
- }
-
- var j int
- for j = len(p.oe) - 1; j >= 0; j-- {
- if p.oe[j].DataAtom == a.Template {
- template = p.oe[j]
- break
- }
- }
-
- if template != nil && (table == nil || j > i) {
- template.AppendChild(n)
- return
- }
-
- if table == nil {
- // The foster parent is the html element.
- parent = p.oe[0]
- } else {
- parent = table.Parent
- }
- if parent == nil {
- parent = p.oe[i-1]
- }
-
- if table != nil {
- prev = table.PrevSibling
- } else {
- prev = parent.LastChild
- }
- if prev != nil && prev.Type == TextNode && n.Type == TextNode {
- prev.Data += n.Data
- return
- }
-
- parent.InsertBefore(n, table)
-}
-
-// addText adds text to the preceding node if it is a text node, or else it
-// calls addChild with a new text node.
-func (p *parser) addText(text string) {
- if text == "" {
- return
- }
-
- if p.shouldFosterParent() {
- p.fosterParent(&Node{
- Type: TextNode,
- Data: text,
- })
- return
- }
-
- t := p.top()
- if n := t.LastChild; n != nil && n.Type == TextNode {
- n.Data += text
- return
- }
- p.addChild(&Node{
- Type: TextNode,
- Data: text,
- })
-}
-
-// addElement adds a child element based on the current token.
-func (p *parser) addElement() {
- p.addChild(&Node{
- Type: ElementNode,
- DataAtom: p.tok.DataAtom,
- Data: p.tok.Data,
- Attr: p.tok.Attr,
- })
-}
-
-// Section 12.2.4.3.
-func (p *parser) addFormattingElement() {
- tagAtom, attr := p.tok.DataAtom, p.tok.Attr
- p.addElement()
-
- // Implement the Noah's Ark clause, but with three per family instead of two.
- identicalElements := 0
-findIdenticalElements:
- for i := len(p.afe) - 1; i >= 0; i-- {
- n := p.afe[i]
- if n.Type == scopeMarkerNode {
- break
- }
- if n.Type != ElementNode {
- continue
- }
- if n.Namespace != "" {
- continue
- }
- if n.DataAtom != tagAtom {
- continue
- }
- if len(n.Attr) != len(attr) {
- continue
- }
- compareAttributes:
- for _, t0 := range n.Attr {
- for _, t1 := range attr {
- if t0.Key == t1.Key && t0.Namespace == t1.Namespace && t0.Val == t1.Val {
- // Found a match for this attribute, continue with the next attribute.
- continue compareAttributes
- }
- }
- // If we get here, there is no attribute that matches a.
- // Therefore the element is not identical to the new one.
- continue findIdenticalElements
- }
-
- identicalElements++
- if identicalElements >= 3 {
- p.afe.remove(n)
- }
- }
-
- p.afe = append(p.afe, p.top())
-}
-
-// Section 12.2.4.3.
-func (p *parser) clearActiveFormattingElements() {
- for {
- n := p.afe.pop()
- if len(p.afe) == 0 || n.Type == scopeMarkerNode {
- return
- }
- }
-}
-
-// Section 12.2.4.3.
-func (p *parser) reconstructActiveFormattingElements() {
- n := p.afe.top()
- if n == nil {
- return
- }
- if n.Type == scopeMarkerNode || p.oe.index(n) != -1 {
- return
- }
- i := len(p.afe) - 1
- for n.Type != scopeMarkerNode && p.oe.index(n) == -1 {
- if i == 0 {
- i = -1
- break
- }
- i--
- n = p.afe[i]
- }
- for {
- i++
- clone := p.afe[i].clone()
- p.addChild(clone)
- p.afe[i] = clone
- if i == len(p.afe)-1 {
- break
- }
- }
-}
-
-// Section 12.2.5.
-func (p *parser) acknowledgeSelfClosingTag() {
- p.hasSelfClosingToken = false
-}
-
-// An insertion mode (section 12.2.4.1) is the state transition function from
-// a particular state in the HTML5 parser's state machine. It updates the
-// parser's fields depending on parser.tok (where ErrorToken means EOF).
-// It returns whether the token was consumed.
-type insertionMode func(*parser) bool
-
-// setOriginalIM sets the insertion mode to return to after completing a text or
-// inTableText insertion mode.
-// Section 12.2.4.1, "using the rules for".
-func (p *parser) setOriginalIM() {
- if p.originalIM != nil {
- panic("html: bad parser state: originalIM was set twice")
- }
- p.originalIM = p.im
-}
-
-// Section 12.2.4.1, "reset the insertion mode".
-func (p *parser) resetInsertionMode() {
- for i := len(p.oe) - 1; i >= 0; i-- {
- n := p.oe[i]
- last := i == 0
- if last && p.context != nil {
- n = p.context
- }
-
- switch n.DataAtom {
- case a.Select:
- if !last {
- for ancestor, first := n, p.oe[0]; ancestor != first; {
- if ancestor == first {
- break
- }
- ancestor = p.oe[p.oe.index(ancestor)-1]
- switch ancestor.DataAtom {
- case a.Template:
- p.im = inSelectIM
- return
- case a.Table:
- p.im = inSelectInTableIM
- return
- }
- }
- }
- p.im = inSelectIM
- case a.Td, a.Th:
- // TODO: remove this divergence from the HTML5 spec.
- //
- // See https://bugs.chromium.org/p/chromium/issues/detail?id=829668
- p.im = inCellIM
- case a.Tr:
- p.im = inRowIM
- case a.Tbody, a.Thead, a.Tfoot:
- p.im = inTableBodyIM
- case a.Caption:
- p.im = inCaptionIM
- case a.Colgroup:
- p.im = inColumnGroupIM
- case a.Table:
- p.im = inTableIM
- case a.Template:
- // TODO: remove this divergence from the HTML5 spec.
- if n.Namespace != "" {
- continue
- }
- p.im = p.templateStack.top()
- case a.Head:
- // TODO: remove this divergence from the HTML5 spec.
- //
- // See https://bugs.chromium.org/p/chromium/issues/detail?id=829668
- p.im = inHeadIM
- case a.Body:
- p.im = inBodyIM
- case a.Frameset:
- p.im = inFramesetIM
- case a.Html:
- if p.head == nil {
- p.im = beforeHeadIM
- } else {
- p.im = afterHeadIM
- }
- default:
- if last {
- p.im = inBodyIM
- return
- }
- continue
- }
- return
- }
-}
-
-const whitespace = " \t\r\n\f"
-
-// Section 12.2.6.4.1.
-func initialIM(p *parser) bool {
- switch p.tok.Type {
- case TextToken:
- p.tok.Data = strings.TrimLeft(p.tok.Data, whitespace)
- if len(p.tok.Data) == 0 {
- // It was all whitespace, so ignore it.
- return true
- }
- case CommentToken:
- p.doc.AppendChild(&Node{
- Type: CommentNode,
- Data: p.tok.Data,
- })
- return true
- case DoctypeToken:
- n, quirks := parseDoctype(p.tok.Data)
- p.doc.AppendChild(n)
- p.quirks = quirks
- p.im = beforeHTMLIM
- return true
- }
- p.quirks = true
- p.im = beforeHTMLIM
- return false
-}
-
-// Section 12.2.6.4.2.
-func beforeHTMLIM(p *parser) bool {
- switch p.tok.Type {
- case DoctypeToken:
- // Ignore the token.
- return true
- case TextToken:
- p.tok.Data = strings.TrimLeft(p.tok.Data, whitespace)
- if len(p.tok.Data) == 0 {
- // It was all whitespace, so ignore it.
- return true
- }
- case StartTagToken:
- if p.tok.DataAtom == a.Html {
- p.addElement()
- p.im = beforeHeadIM
- return true
- }
- case EndTagToken:
- switch p.tok.DataAtom {
- case a.Head, a.Body, a.Html, a.Br:
- p.parseImpliedToken(StartTagToken, a.Html, a.Html.String())
- return false
- default:
- // Ignore the token.
- return true
- }
- case CommentToken:
- p.doc.AppendChild(&Node{
- Type: CommentNode,
- Data: p.tok.Data,
- })
- return true
- }
- p.parseImpliedToken(StartTagToken, a.Html, a.Html.String())
- return false
-}
-
-// Section 12.2.6.4.3.
-func beforeHeadIM(p *parser) bool {
- switch p.tok.Type {
- case TextToken:
- p.tok.Data = strings.TrimLeft(p.tok.Data, whitespace)
- if len(p.tok.Data) == 0 {
- // It was all whitespace, so ignore it.
- return true
- }
- case StartTagToken:
- switch p.tok.DataAtom {
- case a.Head:
- p.addElement()
- p.head = p.top()
- p.im = inHeadIM
- return true
- case a.Html:
- return inBodyIM(p)
- }
- case EndTagToken:
- switch p.tok.DataAtom {
- case a.Head, a.Body, a.Html, a.Br:
- p.parseImpliedToken(StartTagToken, a.Head, a.Head.String())
- return false
- default:
- // Ignore the token.
- return true
- }
- case CommentToken:
- p.addChild(&Node{
- Type: CommentNode,
- Data: p.tok.Data,
- })
- return true
- case DoctypeToken:
- // Ignore the token.
- return true
- }
-
- p.parseImpliedToken(StartTagToken, a.Head, a.Head.String())
- return false
-}
-
-// Section 12.2.6.4.4.
-func inHeadIM(p *parser) bool {
- switch p.tok.Type {
- case TextToken:
- s := strings.TrimLeft(p.tok.Data, whitespace)
- if len(s) < len(p.tok.Data) {
- // Add the initial whitespace to the current node.
- p.addText(p.tok.Data[:len(p.tok.Data)-len(s)])
- if s == "" {
- return true
- }
- p.tok.Data = s
- }
- case StartTagToken:
- switch p.tok.DataAtom {
- case a.Html:
- return inBodyIM(p)
- case a.Base, a.Basefont, a.Bgsound, a.Command, a.Link, a.Meta:
- p.addElement()
- p.oe.pop()
- p.acknowledgeSelfClosingTag()
- return true
- case a.Script, a.Title, a.Noscript, a.Noframes, a.Style:
- p.addElement()
- p.setOriginalIM()
- p.im = textIM
- return true
- case a.Head:
- // Ignore the token.
- return true
- case a.Template:
- p.addElement()
- p.afe = append(p.afe, &scopeMarker)
- p.framesetOK = false
- p.im = inTemplateIM
- p.templateStack = append(p.templateStack, inTemplateIM)
- return true
- }
- case EndTagToken:
- switch p.tok.DataAtom {
- case a.Head:
- p.oe.pop()
- p.im = afterHeadIM
- return true
- case a.Body, a.Html, a.Br:
- p.parseImpliedToken(EndTagToken, a.Head, a.Head.String())
- return false
- case a.Template:
- if !p.oe.contains(a.Template) {
- return true
- }
- // TODO: remove this divergence from the HTML5 spec.
- //
- // See https://bugs.chromium.org/p/chromium/issues/detail?id=829668
- p.generateImpliedEndTags()
- for i := len(p.oe) - 1; i >= 0; i-- {
- if n := p.oe[i]; n.Namespace == "" && n.DataAtom == a.Template {
- p.oe = p.oe[:i]
- break
- }
- }
- p.clearActiveFormattingElements()
- p.templateStack.pop()
- p.resetInsertionMode()
- return true
- default:
- // Ignore the token.
- return true
- }
- case CommentToken:
- p.addChild(&Node{
- Type: CommentNode,
- Data: p.tok.Data,
- })
- return true
- case DoctypeToken:
- // Ignore the token.
- return true
- }
-
- p.parseImpliedToken(EndTagToken, a.Head, a.Head.String())
- return false
-}
-
-// Section 12.2.6.4.6.
-func afterHeadIM(p *parser) bool {
- switch p.tok.Type {
- case TextToken:
- s := strings.TrimLeft(p.tok.Data, whitespace)
- if len(s) < len(p.tok.Data) {
- // Add the initial whitespace to the current node.
- p.addText(p.tok.Data[:len(p.tok.Data)-len(s)])
- if s == "" {
- return true
- }
- p.tok.Data = s
- }
- case StartTagToken:
- switch p.tok.DataAtom {
- case a.Html:
- return inBodyIM(p)
- case a.Body:
- p.addElement()
- p.framesetOK = false
- p.im = inBodyIM
- return true
- case a.Frameset:
- p.addElement()
- p.im = inFramesetIM
- return true
- case a.Base, a.Basefont, a.Bgsound, a.Link, a.Meta, a.Noframes, a.Script, a.Style, a.Template, a.Title:
- p.oe = append(p.oe, p.head)
- defer p.oe.remove(p.head)
- return inHeadIM(p)
- case a.Head:
- // Ignore the token.
- return true
- }
- case EndTagToken:
- switch p.tok.DataAtom {
- case a.Body, a.Html, a.Br:
- // Drop down to creating an implied tag.
- case a.Template:
- return inHeadIM(p)
- default:
- // Ignore the token.
- return true
- }
- case CommentToken:
- p.addChild(&Node{
- Type: CommentNode,
- Data: p.tok.Data,
- })
- return true
- case DoctypeToken:
- // Ignore the token.
- return true
- }
-
- p.parseImpliedToken(StartTagToken, a.Body, a.Body.String())
- p.framesetOK = true
- return false
-}
-
-// copyAttributes copies attributes of src not found on dst to dst.
-func copyAttributes(dst *Node, src Token) {
- if len(src.Attr) == 0 {
- return
- }
- attr := map[string]string{}
- for _, t := range dst.Attr {
- attr[t.Key] = t.Val
- }
- for _, t := range src.Attr {
- if _, ok := attr[t.Key]; !ok {
- dst.Attr = append(dst.Attr, t)
- attr[t.Key] = t.Val
- }
- }
-}
-
-// Section 12.2.6.4.7.
-func inBodyIM(p *parser) bool {
- switch p.tok.Type {
- case TextToken:
- d := p.tok.Data
- switch n := p.oe.top(); n.DataAtom {
- case a.Pre, a.Listing:
- if n.FirstChild == nil {
- // Ignore a newline at the start of a block.
- if d != "" && d[0] == '\r' {
- d = d[1:]
- }
- if d != "" && d[0] == '\n' {
- d = d[1:]
- }
- }
- }
- d = strings.Replace(d, "\x00", "", -1)
- if d == "" {
- return true
- }
- p.reconstructActiveFormattingElements()
- p.addText(d)
- if p.framesetOK && strings.TrimLeft(d, whitespace) != "" {
- // There were non-whitespace characters inserted.
- p.framesetOK = false
- }
- case StartTagToken:
- switch p.tok.DataAtom {
- case a.Html:
- if p.oe.contains(a.Template) {
- return true
- }
- copyAttributes(p.oe[0], p.tok)
- case a.Base, a.Basefont, a.Bgsound, a.Command, a.Link, a.Meta, a.Noframes, a.Script, a.Style, a.Template, a.Title:
- return inHeadIM(p)
- case a.Body:
- if p.oe.contains(a.Template) {
- return true
- }
- if len(p.oe) >= 2 {
- body := p.oe[1]
- if body.Type == ElementNode && body.DataAtom == a.Body {
- p.framesetOK = false
- copyAttributes(body, p.tok)
- }
- }
- case a.Frameset:
- if !p.framesetOK || len(p.oe) < 2 || p.oe[1].DataAtom != a.Body {
- // Ignore the token.
- return true
- }
- body := p.oe[1]
- if body.Parent != nil {
- body.Parent.RemoveChild(body)
- }
- p.oe = p.oe[:1]
- p.addElement()
- p.im = inFramesetIM
- return true
- case a.Address, a.Article, a.Aside, a.Blockquote, a.Center, a.Details, a.Dir, a.Div, a.Dl, a.Fieldset, a.Figcaption, a.Figure, a.Footer, a.Header, a.Hgroup, a.Menu, a.Nav, a.Ol, a.P, a.Section, a.Summary, a.Ul:
- p.popUntil(buttonScope, a.P)
- p.addElement()
- case a.H1, a.H2, a.H3, a.H4, a.H5, a.H6:
- p.popUntil(buttonScope, a.P)
- switch n := p.top(); n.DataAtom {
- case a.H1, a.H2, a.H3, a.H4, a.H5, a.H6:
- p.oe.pop()
- }
- p.addElement()
- case a.Pre, a.Listing:
- p.popUntil(buttonScope, a.P)
- p.addElement()
- // The newline, if any, will be dealt with by the TextToken case.
- p.framesetOK = false
- case a.Form:
- if p.form != nil && !p.oe.contains(a.Template) {
- // Ignore the token
- return true
- }
- p.popUntil(buttonScope, a.P)
- p.addElement()
- if !p.oe.contains(a.Template) {
- p.form = p.top()
- }
- case a.Li:
- p.framesetOK = false
- for i := len(p.oe) - 1; i >= 0; i-- {
- node := p.oe[i]
- switch node.DataAtom {
- case a.Li:
- p.oe = p.oe[:i]
- case a.Address, a.Div, a.P:
- continue
- default:
- if !isSpecialElement(node) {
- continue
- }
- }
- break
- }
- p.popUntil(buttonScope, a.P)
- p.addElement()
- case a.Dd, a.Dt:
- p.framesetOK = false
- for i := len(p.oe) - 1; i >= 0; i-- {
- node := p.oe[i]
- switch node.DataAtom {
- case a.Dd, a.Dt:
- p.oe = p.oe[:i]
- case a.Address, a.Div, a.P:
- continue
- default:
- if !isSpecialElement(node) {
- continue
- }
- }
- break
- }
- p.popUntil(buttonScope, a.P)
- p.addElement()
- case a.Plaintext:
- p.popUntil(buttonScope, a.P)
- p.addElement()
- case a.Button:
- p.popUntil(defaultScope, a.Button)
- p.reconstructActiveFormattingElements()
- p.addElement()
- p.framesetOK = false
- case a.A:
- for i := len(p.afe) - 1; i >= 0 && p.afe[i].Type != scopeMarkerNode; i-- {
- if n := p.afe[i]; n.Type == ElementNode && n.DataAtom == a.A {
- p.inBodyEndTagFormatting(a.A)
- p.oe.remove(n)
- p.afe.remove(n)
- break
- }
- }
- p.reconstructActiveFormattingElements()
- p.addFormattingElement()
- case a.B, a.Big, a.Code, a.Em, a.Font, a.I, a.S, a.Small, a.Strike, a.Strong, a.Tt, a.U:
- p.reconstructActiveFormattingElements()
- p.addFormattingElement()
- case a.Nobr:
- p.reconstructActiveFormattingElements()
- if p.elementInScope(defaultScope, a.Nobr) {
- p.inBodyEndTagFormatting(a.Nobr)
- p.reconstructActiveFormattingElements()
- }
- p.addFormattingElement()
- case a.Applet, a.Marquee, a.Object:
- p.reconstructActiveFormattingElements()
- p.addElement()
- p.afe = append(p.afe, &scopeMarker)
- p.framesetOK = false
- case a.Table:
- if !p.quirks {
- p.popUntil(buttonScope, a.P)
- }
- p.addElement()
- p.framesetOK = false
- p.im = inTableIM
- return true
- case a.Area, a.Br, a.Embed, a.Img, a.Input, a.Keygen, a.Wbr:
- p.reconstructActiveFormattingElements()
- p.addElement()
- p.oe.pop()
- p.acknowledgeSelfClosingTag()
- if p.tok.DataAtom == a.Input {
- for _, t := range p.tok.Attr {
- if t.Key == "type" {
- if strings.ToLower(t.Val) == "hidden" {
- // Skip setting framesetOK = false
- return true
- }
- }
- }
- }
- p.framesetOK = false
- case a.Param, a.Source, a.Track:
- p.addElement()
- p.oe.pop()
- p.acknowledgeSelfClosingTag()
- case a.Hr:
- p.popUntil(buttonScope, a.P)
- p.addElement()
- p.oe.pop()
- p.acknowledgeSelfClosingTag()
- p.framesetOK = false
- case a.Image:
- p.tok.DataAtom = a.Img
- p.tok.Data = a.Img.String()
- return false
- case a.Isindex:
- if p.form != nil {
- // Ignore the token.
- return true
- }
- action := ""
- prompt := "This is a searchable index. Enter search keywords: "
- attr := []Attribute{{Key: "name", Val: "isindex"}}
- for _, t := range p.tok.Attr {
- switch t.Key {
- case "action":
- action = t.Val
- case "name":
- // Ignore the attribute.
- case "prompt":
- prompt = t.Val
- default:
- attr = append(attr, t)
- }
- }
- p.acknowledgeSelfClosingTag()
- p.popUntil(buttonScope, a.P)
- p.parseImpliedToken(StartTagToken, a.Form, a.Form.String())
- if p.form == nil {
- // NOTE: The 'isindex' element has been removed,
- // and the 'template' element has not been designed to be
- // collaborative with the index element.
- //
- // Ignore the token.
- return true
- }
- if action != "" {
- p.form.Attr = []Attribute{{Key: "action", Val: action}}
- }
- p.parseImpliedToken(StartTagToken, a.Hr, a.Hr.String())
- p.parseImpliedToken(StartTagToken, a.Label, a.Label.String())
- p.addText(prompt)
- p.addChild(&Node{
- Type: ElementNode,
- DataAtom: a.Input,
- Data: a.Input.String(),
- Attr: attr,
- })
- p.oe.pop()
- p.parseImpliedToken(EndTagToken, a.Label, a.Label.String())
- p.parseImpliedToken(StartTagToken, a.Hr, a.Hr.String())
- p.parseImpliedToken(EndTagToken, a.Form, a.Form.String())
- case a.Textarea:
- p.addElement()
- p.setOriginalIM()
- p.framesetOK = false
- p.im = textIM
- case a.Xmp:
- p.popUntil(buttonScope, a.P)
- p.reconstructActiveFormattingElements()
- p.framesetOK = false
- p.addElement()
- p.setOriginalIM()
- p.im = textIM
- case a.Iframe:
- p.framesetOK = false
- p.addElement()
- p.setOriginalIM()
- p.im = textIM
- case a.Noembed, a.Noscript:
- p.addElement()
- p.setOriginalIM()
- p.im = textIM
- case a.Select:
- p.reconstructActiveFormattingElements()
- p.addElement()
- p.framesetOK = false
- p.im = inSelectIM
- return true
- case a.Optgroup, a.Option:
- if p.top().DataAtom == a.Option {
- p.oe.pop()
- }
- p.reconstructActiveFormattingElements()
- p.addElement()
- case a.Rb, a.Rtc:
- if p.elementInScope(defaultScope, a.Ruby) {
- p.generateImpliedEndTags()
- }
- p.addElement()
- case a.Rp, a.Rt:
- if p.elementInScope(defaultScope, a.Ruby) {
- p.generateImpliedEndTags("rtc")
- }
- p.addElement()
- case a.Math, a.Svg:
- p.reconstructActiveFormattingElements()
- if p.tok.DataAtom == a.Math {
- adjustAttributeNames(p.tok.Attr, mathMLAttributeAdjustments)
- } else {
- adjustAttributeNames(p.tok.Attr, svgAttributeAdjustments)
- }
- adjustForeignAttributes(p.tok.Attr)
- p.addElement()
- p.top().Namespace = p.tok.Data
- if p.hasSelfClosingToken {
- p.oe.pop()
- p.acknowledgeSelfClosingTag()
- }
- return true
- case a.Caption, a.Col, a.Colgroup, a.Frame, a.Head, a.Tbody, a.Td, a.Tfoot, a.Th, a.Thead, a.Tr:
- // Ignore the token.
- default:
- p.reconstructActiveFormattingElements()
- p.addElement()
- }
- case EndTagToken:
- switch p.tok.DataAtom {
- case a.Body:
- if p.elementInScope(defaultScope, a.Body) {
- p.im = afterBodyIM
- }
- case a.Html:
- if p.elementInScope(defaultScope, a.Body) {
- p.parseImpliedToken(EndTagToken, a.Body, a.Body.String())
- return false
- }
- return true
- case a.Address, a.Article, a.Aside, a.Blockquote, a.Button, a.Center, a.Details, a.Dir, a.Div, a.Dl, a.Fieldset, a.Figcaption, a.Figure, a.Footer, a.Header, a.Hgroup, a.Listing, a.Menu, a.Nav, a.Ol, a.Pre, a.Section, a.Summary, a.Ul:
- p.popUntil(defaultScope, p.tok.DataAtom)
- case a.Form:
- if p.oe.contains(a.Template) {
- i := p.indexOfElementInScope(defaultScope, a.Form)
- if i == -1 {
- // Ignore the token.
- return true
- }
- p.generateImpliedEndTags()
- if p.oe[i].DataAtom != a.Form {
- // Ignore the token.
- return true
- }
- p.popUntil(defaultScope, a.Form)
- } else {
- node := p.form
- p.form = nil
- i := p.indexOfElementInScope(defaultScope, a.Form)
- if node == nil || i == -1 || p.oe[i] != node {
- // Ignore the token.
- return true
- }
- p.generateImpliedEndTags()
- p.oe.remove(node)
- }
- case a.P:
- if !p.elementInScope(buttonScope, a.P) {
- p.parseImpliedToken(StartTagToken, a.P, a.P.String())
- }
- p.popUntil(buttonScope, a.P)
- case a.Li:
- p.popUntil(listItemScope, a.Li)
- case a.Dd, a.Dt:
- p.popUntil(defaultScope, p.tok.DataAtom)
- case a.H1, a.H2, a.H3, a.H4, a.H5, a.H6:
- p.popUntil(defaultScope, a.H1, a.H2, a.H3, a.H4, a.H5, a.H6)
- case a.A, a.B, a.Big, a.Code, a.Em, a.Font, a.I, a.Nobr, a.S, a.Small, a.Strike, a.Strong, a.Tt, a.U:
- p.inBodyEndTagFormatting(p.tok.DataAtom)
- case a.Applet, a.Marquee, a.Object:
- if p.popUntil(defaultScope, p.tok.DataAtom) {
- p.clearActiveFormattingElements()
- }
- case a.Br:
- p.tok.Type = StartTagToken
- return false
- case a.Template:
- return inHeadIM(p)
- default:
- p.inBodyEndTagOther(p.tok.DataAtom)
- }
- case CommentToken:
- p.addChild(&Node{
- Type: CommentNode,
- Data: p.tok.Data,
- })
- case ErrorToken:
- // TODO: remove this divergence from the HTML5 spec.
- if len(p.templateStack) > 0 {
- p.im = inTemplateIM
- return false
- } else {
- for _, e := range p.oe {
- switch e.DataAtom {
- case a.Dd, a.Dt, a.Li, a.Optgroup, a.Option, a.P, a.Rb, a.Rp, a.Rt, a.Rtc, a.Tbody, a.Td, a.Tfoot, a.Th,
- a.Thead, a.Tr, a.Body, a.Html:
- default:
- return true
- }
- }
- }
- }
-
- return true
-}
-
-func (p *parser) inBodyEndTagFormatting(tagAtom a.Atom) {
- // This is the "adoption agency" algorithm, described at
- // https://html.spec.whatwg.org/multipage/syntax.html#adoptionAgency
-
- // TODO: this is a fairly literal line-by-line translation of that algorithm.
- // Once the code successfully parses the comprehensive test suite, we should
- // refactor this code to be more idiomatic.
-
- // Steps 1-4. The outer loop.
- for i := 0; i < 8; i++ {
- // Step 5. Find the formatting element.
- var formattingElement *Node
- for j := len(p.afe) - 1; j >= 0; j-- {
- if p.afe[j].Type == scopeMarkerNode {
- break
- }
- if p.afe[j].DataAtom == tagAtom {
- formattingElement = p.afe[j]
- break
- }
- }
- if formattingElement == nil {
- p.inBodyEndTagOther(tagAtom)
- return
- }
- feIndex := p.oe.index(formattingElement)
- if feIndex == -1 {
- p.afe.remove(formattingElement)
- return
- }
- if !p.elementInScope(defaultScope, tagAtom) {
- // Ignore the tag.
- return
- }
-
- // Steps 9-10. Find the furthest block.
- var furthestBlock *Node
- for _, e := range p.oe[feIndex:] {
- if isSpecialElement(e) {
- furthestBlock = e
- break
- }
- }
- if furthestBlock == nil {
- e := p.oe.pop()
- for e != formattingElement {
- e = p.oe.pop()
- }
- p.afe.remove(e)
- return
- }
-
- // Steps 11-12. Find the common ancestor and bookmark node.
- commonAncestor := p.oe[feIndex-1]
- bookmark := p.afe.index(formattingElement)
-
- // Step 13. The inner loop. Find the lastNode to reparent.
- lastNode := furthestBlock
- node := furthestBlock
- x := p.oe.index(node)
- // Steps 13.1-13.2
- for j := 0; j < 3; j++ {
- // Step 13.3.
- x--
- node = p.oe[x]
- // Step 13.4 - 13.5.
- if p.afe.index(node) == -1 {
- p.oe.remove(node)
- continue
- }
- // Step 13.6.
- if node == formattingElement {
- break
- }
- // Step 13.7.
- clone := node.clone()
- p.afe[p.afe.index(node)] = clone
- p.oe[p.oe.index(node)] = clone
- node = clone
- // Step 13.8.
- if lastNode == furthestBlock {
- bookmark = p.afe.index(node) + 1
- }
- // Step 13.9.
- if lastNode.Parent != nil {
- lastNode.Parent.RemoveChild(lastNode)
- }
- node.AppendChild(lastNode)
- // Step 13.10.
- lastNode = node
- }
-
- // Step 14. Reparent lastNode to the common ancestor,
- // or for misnested table nodes, to the foster parent.
- if lastNode.Parent != nil {
- lastNode.Parent.RemoveChild(lastNode)
- }
- switch commonAncestor.DataAtom {
- case a.Table, a.Tbody, a.Tfoot, a.Thead, a.Tr:
- p.fosterParent(lastNode)
- case a.Template:
- // TODO: remove namespace checking
- if commonAncestor.Namespace == "html" {
- commonAncestor = commonAncestor.LastChild
- }
- fallthrough
- default:
- commonAncestor.AppendChild(lastNode)
- }
-
- // Steps 15-17. Reparent nodes from the furthest block's children
- // to a clone of the formatting element.
- clone := formattingElement.clone()
- reparentChildren(clone, furthestBlock)
- furthestBlock.AppendChild(clone)
-
- // Step 18. Fix up the list of active formatting elements.
- if oldLoc := p.afe.index(formattingElement); oldLoc != -1 && oldLoc < bookmark {
- // Move the bookmark with the rest of the list.
- bookmark--
- }
- p.afe.remove(formattingElement)
- p.afe.insert(bookmark, clone)
-
- // Step 19. Fix up the stack of open elements.
- p.oe.remove(formattingElement)
- p.oe.insert(p.oe.index(furthestBlock)+1, clone)
- }
-}
-
-// inBodyEndTagOther performs the "any other end tag" algorithm for inBodyIM.
-// "Any other end tag" handling from 12.2.6.5 The rules for parsing tokens in foreign content
-// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inforeign
-func (p *parser) inBodyEndTagOther(tagAtom a.Atom) {
- for i := len(p.oe) - 1; i >= 0; i-- {
- if p.oe[i].DataAtom == tagAtom {
- p.oe = p.oe[:i]
- break
- }
- if isSpecialElement(p.oe[i]) {
- break
- }
- }
-}
-
-// Section 12.2.6.4.8.
-func textIM(p *parser) bool {
- switch p.tok.Type {
- case ErrorToken:
- p.oe.pop()
- case TextToken:
- d := p.tok.Data
- if n := p.oe.top(); n.DataAtom == a.Textarea && n.FirstChild == nil {
- // Ignore a newline at the start of a