Linode: updated to use the Linode APIv4 (#622)

Gopkg.lock

@@ -197,6 +197,14 @@
   revision = "5cf292cae48347c2490ac1a58fe36735fb78df7e"
   version = "v1.38.2"
 
+[[projects]]
+  digest = "1:ed6fe3cdb5ccb17387b5cb11c0cbd125699f5f5d23626ccf78a7c5859183e063"
+  name = "github.com/go-resty/resty"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "97a15579492cd5f35632499f315d7a8df94160a1"
+  version = "v1.8.0"
+
 [[projects]]
   digest = "1:97df918963298c287643883209a2c3f642e6593379f97ab400c2a2e219ab647d"
   name = "github.com/golang/protobuf"
@@ -255,6 +263,14 @@
   revision = "59fac5042749a5afb9af70e813da1dd5474f0167"
   version = "1.0.1"
 
+[[projects]]
+  digest = "1:111ff5a09a32895248270bfaef9b8b6ac163a8cde9cdd603fed64b3e4b59e8ab"
+  name = "github.com/linode/linodego"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "d0d31d8ca62fa3f7e4526ca0ce95de81e4ed001e"
+  version = "v0.5.1"
+
 [[projects]]
   digest = "1:24b5f8d41224b90e3f4d22768926ed782a8ca481d945c0e064c8f165bf768280"
   name = "github.com/miekg/dns"
@@ -403,16 +419,18 @@
 
 [[projects]]
   branch = "master"
-  digest = "1:bec9fee9f0fc9b6f8cbcd4a7e2d80036829079f0aaccc28776510b18ec5f0dc5"
+  digest = "1:14308e6b384fe18ce04d886e6a6d5d3fb3f532ec599c40cf00750e3519d845f1"
   name = "golang.org/x/net"
   packages = [
     "bpf",
     "context",
     "context/ctxhttp",
+    "idna",
     "internal/iana",
     "internal/socket",
     "ipv4",
     "ipv6",
+    "publicsuffix",
   ]
   pruneopts = "NUT"
   revision = "8a410e7b638dca158bf9e766925842f6651ff828"
@@ -442,6 +460,29 @@
   pruneopts = "NUT"
   revision = "d99a578cf41bfccdeaf48b0845c823a4b8b0ad5e"
 
+[[projects]]
+  digest = "1:e7071ed636b5422cc51c0e3a6cebc229d6c9fffc528814b519a980641422d619"
+  name = "golang.org/x/text"
+  packages = [
+    "collate",
+    "collate/build",
+    "internal/colltab",
+    "internal/gen",
+    "internal/tag",
+    "internal/triegen",
+    "internal/ucd",
+    "language",
+    "secure/bidirule",
+    "transform",
+    "unicode/bidi",
+    "unicode/cldr",
+    "unicode/norm",
+    "unicode/rangetable",
+  ]
+  pruneopts = "NUT"
+  revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0"
+  version = "v0.3.0"
+
 [[projects]]
   branch = "master"
   digest = "1:90f61cd4297f7f4ce75f142744673ecdafd9023668cd24730f14033f265e394a"
@@ -542,6 +583,7 @@
     "github.com/exoscale/egoscale",
     "github.com/iij/doapi",
     "github.com/iij/doapi/protocol",
+    "github.com/linode/linodego",
     "github.com/miekg/dns",
     "github.com/namedotcom/go/namecom",
     "github.com/ovh/go-ovh/ovh",
@@ -556,6 +598,7 @@
     "github.com/urfave/cli",
     "golang.org/x/crypto/ocsp",
     "golang.org/x/net/context",
+    "golang.org/x/oauth2",
     "golang.org/x/oauth2/google",
     "google.golang.org/api/dns/v1",
     "gopkg.in/ns1/ns1-go.v2/rest",

Gopkg.toml

@@ -53,6 +53,10 @@
   branch = "master"
   name = "github.com/timewasted/linode"
 
+[[constraint]]
+  version = "0.5.1"
+  name = "github.com/linode/linodego"
+
 [[constraint]]
   branch = "master"
   name = "golang.org/x/crypto"

cli.go

@@ -221,6 +221,7 @@ Here is an example bash command using the CloudFlare DNS provider:
 	fmt.Fprintln(w, "\thostingde:\tHOSTINGDE_API_KEY, HOSTINGDE_ZONE_NAME")
 	fmt.Fprintln(w, "\tiij:\tIIJ_API_ACCESS_KEY, IIJ_API_SECRET_KEY, IIJ_DO_SERVICE_CODE")
 	fmt.Fprintln(w, "\tlinode:\tLINODE_API_KEY")
+	fmt.Fprintln(w, "\tlinodev4:\tLINODE_TOKEN")
 	fmt.Fprintln(w, "\tlightsail:\tAWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, DNS_ZONE")
 	fmt.Fprintln(w, "\tmanual:\tnone")
 	fmt.Fprintln(w, "\tnamecheap:\tNAMECHEAP_API_USER, NAMECHEAP_API_KEY")

providers/dns/dns_providers.go

@@ -29,6 +29,7 @@ import (
 	"github.com/xenolf/lego/providers/dns/iij"
 	"github.com/xenolf/lego/providers/dns/lightsail"
 	"github.com/xenolf/lego/providers/dns/linode"
+	"github.com/xenolf/lego/providers/dns/linodev4"
 	"github.com/xenolf/lego/providers/dns/namecheap"
 	"github.com/xenolf/lego/providers/dns/namedotcom"
 	"github.com/xenolf/lego/providers/dns/netcup"
@@ -96,6 +97,8 @@ func NewDNSChallengeProviderByName(name string) (acme.ChallengeProvider, error)
 		return lightsail.NewDNSProvider()
 	case "linode":
 		return linode.NewDNSProvider()
+	case "linodev4":
+		return linodev4.NewDNSProvider()
 	case "manual":
 		return acme.NewDNSProviderManual()
 	case "namecheap":

providers/dns/linode/linode.go

@@ -110,7 +110,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error {
 		return err
 	}
 
-	if _, err = d.client.CreateDomainResourceTXT(zone.domainID, acme.UnFqdn(fqdn), value, 60); err != nil {
+	if _, err = d.client.CreateDomainResourceTXT(zone.domainID, acme.UnFqdn(fqdn), value, d.config.TTL); err != nil {
 		return err
 	}
 
@@ -138,6 +138,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error {
 			if err != nil {
 				return err
 			}
+
 			if resp.ResourceID != resource.ResourceID {
 				return errors.New("error deleting resource: resource IDs do not match")
 			}

providers/dns/linodev4/linodev4.go

@@ -0,0 +1,187 @@
+// Package linodev4 implements a DNS provider for solving the DNS-01 challenge
+// using Linode DNS and Linode's APIv4
+package linodev4
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/linode/linodego"
+	"github.com/xenolf/lego/acme"
+	"github.com/xenolf/lego/platform/config/env"
+	"golang.org/x/oauth2"
+)
+
+const (
+	dnsMinTTLSecs      = 300
+	dnsUpdateFreqMins  = 15
+	dnsUpdateFudgeSecs = 120
+)
+
+// Config is used to configure the creation of the DNSProvider
+type Config struct {
+	Token           string
+	PollingInterval time.Duration
+	TTL             int
+	HTTPTimeout     time.Duration
+}
+
+// NewDefaultConfig returns a default configuration for the DNSProvider
+func NewDefaultConfig() *Config {
+	return &Config{
+		PollingInterval: env.GetOrDefaultSecond("LINODE_POLLING_INTERVAL", 15*time.Second),
+		TTL:             env.GetOrDefaultInt("LINODE_TTL", 60),
+		HTTPTimeout:     env.GetOrDefaultSecond("LINODE_HTTP_TIMEOUT", 0),
+	}
+}
+
+type hostedZoneInfo struct {
+	domainID     int
+	resourceName string
+}
+
+// DNSProvider implements the acme.ChallengeProvider interface.
+type DNSProvider struct {
+	config *Config
+	client *linodego.Client
+}
+
+// NewDNSProvider returns a DNSProvider instance configured for Linode.
+// Credentials must be passed in the environment variable: LINODE_TOKEN.
+func NewDNSProvider() (*DNSProvider, error) {
+	values, err := env.Get("LINODE_TOKEN")
+	if err != nil {
+		return nil, fmt.Errorf("linodev4: %v", err)
+	}
+
+	config := NewDefaultConfig()
+	config.Token = values["LINODE_TOKEN"]
+
+	return NewDNSProviderConfig(config)
+}
+
+// NewDNSProviderConfig return a DNSProvider instance configured for Linode.
+func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
+	if config == nil {
+		return nil, errors.New("linodev4: the configuration of the DNS provider is nil")
+	}
+
+	if len(config.Token) == 0 {
+		return nil, errors.New("linodev4: Linode Access Token missing")
+	}
+
+	tokenSource := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: config.Token})
+	oauth2Client := &http.Client{
+		Timeout: config.HTTPTimeout,
+		Transport: &oauth2.Transport{
+			Source: tokenSource,
+		},
+	}
+
+	linodeClient := linodego.NewClient(oauth2Client)
+	linodeClient.SetUserAgent(fmt.Sprintf("lego-dns linodego/%s", linodego.Version))
+
+	return &DNSProvider{
+		config: config,
+		client: &linodeClient,
+	}, nil
+}
+
+// Timeout returns the timeout and interval to use when checking for DNS
+// propagation.  Adjusting here to cope with spikes in propagation times.
+func (d *DNSProvider) Timeout() (timeout, interval time.Duration) {
+	// Since Linode only updates their zone files every X minutes, we need
+	// to figure out how many minutes we have to wait until we hit the next
+	// interval of X.  We then wait another couple of minutes, just to be
+	// safe.  Hopefully at some point during all of this, the record will
+	// have propagated throughout Linode's network.
+	minsRemaining := dnsUpdateFreqMins - (time.Now().Minute() % dnsUpdateFreqMins)
+
+	timeout = (time.Duration(minsRemaining) * time.Minute) +
+		(dnsMinTTLSecs * time.Second) +
+		(dnsUpdateFudgeSecs * time.Second)
+	interval = d.config.PollingInterval
+	return
+}
+
+// Present creates a TXT record using the specified parameters.
+func (d *DNSProvider) Present(domain, token, keyAuth string) error {
+	fqdn, value, _ := acme.DNS01Record(domain, keyAuth)
+	zone, err := d.getHostedZoneInfo(fqdn)
+	if err != nil {
+		return err
+	}
+
+	createOpts := linodego.DomainRecordCreateOptions{
+		Name:   acme.UnFqdn(fqdn),
+		Target: value,
+		TTLSec: d.config.TTL,
+		Type:   linodego.RecordTypeTXT,
+	}
+
+	_, err = d.client.CreateDomainRecord(context.Background(), zone.domainID, createOpts)
+	return err
+}
+
+// CleanUp removes the TXT record matching the specified parameters.
+func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error {
+	fqdn, value, _ := acme.DNS01Record(domain, keyAuth)
+
+	zone, err := d.getHostedZoneInfo(fqdn)
+	if err != nil {
+		return err
+	}
+
+	// Get all TXT records for the specified domain.
+	listOpts := linodego.NewListOptions(0, "{\"type\":\"TXT\"}")
+	resources, err := d.client.ListDomainRecords(context.Background(), zone.domainID, listOpts)
+	if err != nil {
+		return err
+	}
+
+	// Remove the specified resource, if it exists.
+	for _, resource := range resources {
+		if (resource.Name == strings.TrimSuffix(fqdn, ".") || resource.Name == zone.resourceName) &&
+			resource.Target == value {
+			if err := d.client.DeleteDomainRecord(context.Background(), zone.domainID, resource.ID); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (d *DNSProvider) getHostedZoneInfo(fqdn string) (*hostedZoneInfo, error) {
+	// Lookup the zone that handles the specified FQDN.
+	authZone, err := acme.FindZoneByFqdn(fqdn, acme.RecursiveNameservers)
+	if err != nil {
+		return nil, err
+	}
+
+	// Query the authority zone.
+	data, err := json.Marshal(map[string]string{"domain": acme.UnFqdn(authZone)})
+	if err != nil {
+		return nil, err
+	}
+
+	listOpts := linodego.NewListOptions(0, string(data))
+	domains, err := d.client.ListDomains(context.Background(), listOpts)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(domains) == 0 {
+		return nil, fmt.Errorf("domain not found")
+	}
+
+	return &hostedZoneInfo{
+		domainID:     domains[0].ID,
+		resourceName: strings.TrimSuffix(fqdn, "."+authZone),
+	}, nil
+}

providers/dns/linodev4/linodev4_test.go

@@ -0,0 +1,330 @@
+package linodev4
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/linode/linodego"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+type (
+	MockResponseMap map[string]interface{}
+)
+
+var (
+	apiToken   string
+	isTestLive bool
+)
+
+func init() {
+	apiToken = os.Getenv("LINODE_TOKEN")
+	isTestLive = len(apiToken) != 0
+}
+
+func restoreEnv() {
+	os.Setenv("LINODE_TOKEN", apiToken)
+}
+
+func newMockServer(t *testing.T, responses MockResponseMap) *httptest.Server {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Ensure that we support the requested action.
+		action := r.Method + ":" + r.URL.Path
+		resp, ok := responses[action]
+		if !ok {
+			require.FailNowf(t, "Unsupported mock", "action: %s", action)
+		}
+
+		rawResponse, err := json.Marshal(resp)
+		if err != nil {
+			msg := fmt.Sprintf("Failed to JSON encode response: %v", err)
+			require.FailNow(t, msg)
+		}
+
+		// Send the response.
+		w.Header().Set("Content-Type", "application/json")
+		if err, ok := resp.(linodego.APIError); ok {
+			if err.Errors[0].Reason == "Not found" {
+				w.WriteHeader(http.StatusNotFound)
+			} else {
+				w.WriteHeader(http.StatusBadRequest)
+			}
+		} else {
+			w.WriteHeader(http.StatusOK)
+		}
+		w.Write(rawResponse)
+	}))
+
+	time.Sleep(100 * time.Millisecond)
+	return srv
+}
+
+func TestNewDNSProviderWithEnv(t *testing.T) {
+	defer restoreEnv()
+	os.Setenv("LINODE_TOKEN", "testing")
+
+	_, err := NewDNSProvider()
+	assert.NoError(t, err)
+}
+
+func TestNewDNSProviderWithoutEnv(t *testing.T) {
+	defer restoreEnv()
+	os.Setenv("LINODE_TOKEN", "")
+
+	_, err := NewDNSProvider()
+	assert.EqualError(t, err, "linodev4: some credentials information are missing: LINODE_TOKEN")
+}
+
+func TestNewDNSProviderCredentialsWithKey(t *testing.T) {
+	config := NewDefaultConfig()
+	config.Token = "testing"
+
+	_, err := NewDNSProviderConfig(config)
+	assert.NoError(t, err)
+}
+
+func TestNewDNSProviderCredentialsWithoutKey(t *testing.T) {
+	config := NewDefaultConfig()
+	config.Token = ""
+
+	_, err := NewDNSProviderConfig(config)
+	assert.EqualError(t, err, "linodev4: Linode Access Token missing")
+}
+
+func TestDNSProvider_Present(t *testing.T) {
+	defer restoreEnv()
+	os.Setenv("LINODE_TOKEN", "testing")
+
+	p, err := NewDNSProvider()
+	assert.NoError(t, err)
+
+	domain := "example.com"
+	keyAuth := "dGVzdGluZw=="
+
+	mockResponses := MockResponseMap{
+		"GET:/domains": linodego.DomainsPagedResponse{
+			PageOptions: &linodego.PageOptions{
+				Pages:   1,
+				Results: 1,
+				Page:    1,
+			},
+			Data: []linodego.Domain{{
+				Domain: domain,
+				ID:     1234,
+			}},
+		},
+		"POST:/domains/1234/records": linodego.DomainRecord{
+			ID: 1234,
+		},
+	}
+
+	mockSrv := newMockServer(t, mockResponses)
+	defer mockSrv.Close()
+
+	p.client.SetBaseURL(mockSrv.URL)
+
+	err = p.Present(domain, "", keyAuth)
+	assert.NoError(t, err)
+}
+
+func TestDNSProvider_PresentNoDomain(t *testing.T) {
+	defer restoreEnv()
+	os.Setenv("LINODE_TOKEN", "testing")
+
+	p, err := NewDNSProvider()
+	assert.NoError(t, err)
+
+	domain := "example.com"
+	keyAuth := "dGVzdGluZw=="
+	mockResponses := MockResponseMap{
+		"GET:/domains": linodego.APIError{
+			Errors: []linodego.APIErrorReason{{
+				Reason: "Not found",
+			}},
+		},
+	}
+
+	mockSrv := newMockServer(t, mockResponses)
+	defer mockSrv.Close()
+
+	p.client.SetBaseURL(mockSrv.URL)
+
+	err = p.Present(domain, "", keyAuth)
+	assert.EqualError(t, err, "[404] Not found")
+}
+
+func TestDNSProvider_PresentCreateFailed(t *testing.T) {
+	defer restoreEnv()
+	os.Setenv("LINODE_TOKEN", "testing")
+
+	p, err := NewDNSProvider()
+	assert.NoError(t, err)
+
+	domain := "example.com"
+	keyAuth := "dGVzdGluZw=="
+	mockResponses := MockResponseMap{
+		"GET:/domains": &linodego.DomainsPagedResponse{
+			PageOptions: &linodego.PageOptions{
+				Pages:   1,
+				Results: 1,
+				Page:    1,
+			},
+			Data: []linodego.Domain{{
+				Domain: "foobar.com",
+				ID:     1234,
+			}},
+		},
+		"POST:/domains/1234/records": linodego.APIError{
+			Errors: []linodego.APIErrorReason{{
+				Reason: "Failed to create domain resource",
+				Field:  "somefield",
+			}},
+		},
+	}
+	mockSrv := newMockServer(t, mockResponses)
+	defer mockSrv.Close()
+
+	p.client.SetBaseURL(mockSrv.URL)
+
+	err = p.Present(domain, "", keyAuth)
+	assert.EqualError(t, err, "[400] [somefield] Failed to create domain resource")
+}
+
+func TestDNSProvider_PresentLive(t *testing.T) {
+	if !isTestLive {
+		t.Skip("Skipping live test")
+	}
+}
+
+func TestDNSProvider_CleanUp(t *testing.T) {
+	defer restoreEnv()
+	os.Setenv("LINODE_TOKEN", "testing")
+
+	p, err := NewDNSProvider()
+	assert.NoError(t, err)
+
+	domain := "example.com"
+	keyAuth := "dGVzdGluZw=="
+	mockResponses := MockResponseMap{
+		"GET:/domains": &linodego.DomainsPagedResponse{
+			PageOptions: &linodego.PageOptions{
+				Pages:   1,
+				Results: 1,
+				Page:    1,
+			},
+			Data: []linodego.Domain{{
+				Domain: "foobar.com",
+				ID:     1234,
+			}},
+		},
+		"GET:/domains/1234/records": &linodego.DomainRecordsPagedResponse{
+			PageOptions: &linodego.PageOptions{
+				Pages:   1,
+				Results: 1,
+				Page:    1,
+			},
+			Data: []linodego.DomainRecord{{
+				ID:     1234,
+				Name:   "_acme-challenge",
+				Target: "ElbOJKOkFWiZLQeoxf-wb3IpOsQCdvoM0y_wn0TEkxM",
+				Type:   "TXT",
+			}},
+		},
+		"DELETE:/domains/1234/records/1234": struct{}{},
+	}
+
+	mockSrv := newMockServer(t, mockResponses)
+	defer mockSrv.Close()
+
+	p.client.SetBaseURL(mockSrv.URL)
+
+	err = p.CleanUp(domain, "", keyAuth)
+	assert.NoError(t, err)
+}
+
+func TestDNSProvider_CleanUpNoDomain(t *testing.T) {
+	defer restoreEnv()
+	os.Setenv("LINODE_TOKEN", "testing")
+
+	p, err := NewDNSProvider()
+	assert.NoError(t, err)
+
+	domain := "example.com"
+	keyAuth := "dGVzdGluZw=="
+	mockResponses := MockResponseMap{
+		"GET:/domains": linodego.APIError{
+			Errors: []linodego.APIErrorReason{{
+				Reason: "Not found",
+			}},
+		},
+		"GET:/domains/1234/records": linodego.APIError{
+			Errors: []linodego.APIErrorReason{{
+				Reason: "Not found",
+			}},
+		},
+	}
+
+	mockSrv := newMockServer(t, mockResponses)
+	defer mockSrv.Close()
+
+	p.client.SetBaseURL(mockSrv.URL)
+
+	err = p.CleanUp(domain, "", keyAuth)
+	assert.EqualError(t, err, "[404] Not found")
+}
+
+func TestDNSProvider_CleanUpDeleteFailed(t *testing.T) {
+	defer restoreEnv()
+	os.Setenv("LINODE_TOKEN", "testing")
+
+	p, err := NewDNSProvider()
+	assert.NoError(t, err)
+
+	domain := "example.com"
+	keyAuth := "dGVzdGluZw=="
+	mockResponses := MockResponseMap{
+		"GET:/domains": linodego.DomainsPagedResponse{
+			PageOptions: &linodego.PageOptions{
+				Pages:   1,
+				Results: 1,
+				Page:    1,
+			},
+			Data: []linodego.Domain{{
+				ID:     1234,
+				Domain: "example.com",
+			}},
+		},
+		"GET:/domains/1234/records": linodego.DomainRecordsPagedResponse{
+			PageOptions: &linodego.PageOptions{
+				Pages:   1,
+				Results: 1,
+				Page:    1,
+			},
+			Data: []linodego.DomainRecord{{
+				ID:     1234,
+				Name:   "_acme-challenge",
+				Target: "ElbOJKOkFWiZLQeoxf-wb3IpOsQCdvoM0y_wn0TEkxM",
+				Type:   "TXT",
+			}},
+		},
+		"DELETE:/domains/1234/records/1234": linodego.APIError{
+			Errors: []linodego.APIErrorReason{{
+				Reason: "Failed to delete domain resource",
+			}},
+		},
+	}
+
+	mockSrv := newMockServer(t, mockResponses)
+	defer mockSrv.Close()
+
+	p.client.SetBaseURL(mockSrv.URL)
+
+	err = p.CleanUp(domain, "", keyAuth)
+	assert.EqualError(t, err, "[400] Failed to delete domain resource")
+}

vendor/github.com/go-resty/resty/LICENSE

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

vendor/github.com/go-resty/resty/client.go

@@ -0,0 +1,890 @@
+// Copyright (c) 2015-2018 Jeevanandam M (jeeva@myjeeva.com), All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"bytes"
+	"compress/gzip"
+	"crypto/tls"
+	"crypto/x509"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/url"
+	"reflect"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+)
+
+const (
+	// MethodGet HTTP method
+	MethodGet = "GET"
+
+	// MethodPost HTTP method
+	MethodPost = "POST"
+
+	// MethodPut HTTP method
+	MethodPut = "PUT"
+
+	// MethodDelete HTTP method
+	MethodDelete = "DELETE"
+
+	// MethodPatch HTTP method
+	MethodPatch = "PATCH"
+
+	// MethodHead HTTP method
+	MethodHead = "HEAD"
+
+	// MethodOptions HTTP method
+	MethodOptions = "OPTIONS"
+)
+
+var (
+	hdrUserAgentKey       = http.CanonicalHeaderKey("User-Agent")
+	hdrAcceptKey          = http.CanonicalHeaderKey("Accept")
+	hdrContentTypeKey     = http.CanonicalHeaderKey("Content-Type")
+	hdrContentLengthKey   = http.CanonicalHeaderKey("Content-Length")
+	hdrContentEncodingKey = http.CanonicalHeaderKey("Content-Encoding")
+	hdrAuthorizationKey   = http.CanonicalHeaderKey("Authorization")
+
+	plainTextType   = "text/plain; charset=utf-8"
+	jsonContentType = "application/json; charset=utf-8"
+	formContentType = "application/x-www-form-urlencoded"
+
+	jsonCheck = regexp.MustCompile(`(?i:(application|text)/(problem\+json|json))`)
+	xmlCheck  = regexp.MustCompile(`(?i:(application|text)/(problem\+xml|xml))`)
+
+	hdrUserAgentValue = "go-resty v%s - https://github.com/go-resty/resty"
+	bufPool           = &sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
+)
+
+// Client type is used for HTTP/RESTful global values
+// for all request raised from the client
+type Client struct {
+	HostURL               string
+	QueryParam            url.Values
+	FormData              url.Values
+	Header                http.Header
+	UserInfo              *User
+	Token                 string
+	Cookies               []*http.Cookie
+	Error                 reflect.Type
+	Debug                 bool
+	DisableWarn           bool
+	AllowGetMethodPayload bool
+	Log                   *log.Logger
+	RetryCount            int
+	RetryWaitTime         time.Duration
+	RetryMaxWaitTime      time.Duration
+	RetryConditions       []RetryConditionFunc
+	JSONMarshal           func(v interface{}) ([]byte, error)
+	JSONUnmarshal         func(data []byte, v interface{}) error
+
+	httpClient         *http.Client
+	setContentLength   bool
+	isHTTPMode         bool
+	outputDirectory    string
+	scheme             string
+	proxyURL           *url.URL
+	closeConnection    bool
+	notParseResponse   bool
+	debugBodySizeLimit int64
+	logPrefix          string
+	pathParams         map[string]string
+	beforeRequest      []func(*Client, *Request) error
+	udBeforeRequest    []func(*Client, *Request) error
+	preReqHook         func(*Client, *Request) error
+	afterResponse      []func(*Client, *Response) error
+}
+
+// User type is to hold an username and password information
+type User struct {
+	Username, Password string
+}
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Client methods
+//___________________________________
+
+// SetHostURL method is to set Host URL in the client instance. It will be used with request
+// raised from this client with relative URL
+//		// Setting HTTP address
+//		resty.SetHostURL("http://myjeeva.com")
+//
+//		// Setting HTTPS address
+//		resty.SetHostURL("https://myjeeva.com")
+//
+func (c *Client) SetHostURL(url string) *Client {
+	c.HostURL = strings.TrimRight(url, "/")
+	return c
+}
+
+// SetHeader method sets a single header field and its value in the client instance.
+// These headers will be applied to all requests raised from this client instance.
+// Also it can be overridden at request level header options, see `resty.R().SetHeader`
+// or `resty.R().SetHeaders`.
+//
+// Example: To set `Content-Type` and `Accept` as `application/json`
+//
+// 		resty.
+// 			SetHeader("Content-Type", "application/json").
+// 			SetHeader("Accept", "application/json")
+//
+func (c *Client) SetHeader(header, value string) *Client {
+	c.Header.Set(header, value)
+	return c
+}
+
+// SetHeaders method sets multiple headers field and its values at one go in the client instance.
+// These headers will be applied to all requests raised from this client instance. Also it can be
+// overridden at request level headers options, see `resty.R().SetHeaders` or `resty.R().SetHeader`.
+//
+// Example: To set `Content-Type` and `Accept` as `application/json`
+//
+// 		resty.SetHeaders(map[string]string{
+//				"Content-Type": "application/json",
+//				"Accept": "application/json",
+//			})
+//
+func (c *Client) SetHeaders(headers map[string]string) *Client {
+	for h, v := range headers {
+		c.Header.Set(h, v)
+	}
+
+	return c
+}
+
+// SetCookieJar method sets custom http.CookieJar in the resty client. Its way to override default.
+// Example: sometimes we don't want to save cookies in api contacting, we can remove the default
+// CookieJar in resty client.
+//
+//		resty.SetCookieJar(nil)
+//
+func (c *Client) SetCookieJar(jar http.CookieJar) *Client {
+	c.httpClient.Jar = jar
+	return c
+}
+
+// SetCookie method appends a single cookie in the client instance.
+// These cookies will be added to all the request raised from this client instance.
+// 		resty.SetCookie(&http.Cookie{
+// 					Name:"go-resty",
+//					Value:"This is cookie value",
+//					Path: "/",
+// 					Domain: "sample.com",
+// 					MaxAge: 36000,
+// 					HttpOnly: true,
+//					Secure: false,
+// 				})
+//
+func (c *Client) SetCookie(hc *http.Cookie) *Client {
+	c.Cookies = append(c.Cookies, hc)
+	return c
+}
+
+// SetCookies method sets an array of cookies in the client instance.
+// These cookies will be added to all the request raised from this client instance.
+// 		cookies := make([]*http.Cookie, 0)
+//
+//		cookies = append(cookies, &http.Cookie{
+// 					Name:"go-resty-1",
+//					Value:"This is cookie 1 value",
+//					Path: "/",
+// 					Domain: "sample.com",
+// 					MaxAge: 36000,
+// 					HttpOnly: true,
+//					Secure: false,
+// 				})
+//
+//		cookies = append(cookies, &http.Cookie{
+// 					Name:"go-resty-2",
+//					Value:"This is cookie 2 value",
+//					Path: "/",
+// 					Domain: "sample.com",
+// 					MaxAge: 36000,
+// 					HttpOnly: true,
+//					Secure: false,
+// 				})
+//
+//		// Setting a cookies into resty
+// 		resty.SetCookies(cookies)
+//
+func (c *Client) SetCookies(cs []*http.Cookie) *Client {
+	c.Cookies = append(c.Cookies, cs...)
+	return c
+}
+
+// SetQueryParam method sets single parameter and its value in the client instance.
+// It will be formed as query string for the request. For example: `search=kitchen%20papers&size=large`
+// in the URL after `?` mark. These query params will be added to all the request raised from
+// this client instance. Also it can be overridden at request level Query Param options,
+// see `resty.R().SetQueryParam` or `resty.R().SetQueryParams`.
+// 		resty.
+//			SetQueryParam("search", "kitchen papers").
+//			SetQueryParam("size", "large")
+//
+func (c *Client) SetQueryParam(param, value string) *Client {
+	c.QueryParam.Set(param, value)
+	return c
+}
+
+// SetQueryParams method sets multiple parameters and their values at one go in the client instance.
+// It will be formed as query string for the request. For example: `search=kitchen%20papers&size=large`
+// in the URL after `?` mark. These query params will be added to all the request raised from this
+// client instance. Also it can be overridden at request level Query Param options,
+// see `resty.R().SetQueryParams` or `resty.R().SetQueryParam`.
+// 		resty.SetQueryParams(map[string]string{
+//				"search": "kitchen papers",
+//				"size": "large",
+//			})
+//
+func (c *Client) SetQueryParams(params map[string]string) *Client {
+	for p, v := range params {
+		c.SetQueryParam(p, v)
+	}
+
+	return c
+}
+
+// SetFormData method sets Form parameters and their values in the client instance.
+// It's applicable only HTTP method `POST` and `PUT` and requets content type would be set as
+// `application/x-www-form-urlencoded`. These form data will be added to all the request raised from
+// this client instance. Also it can be overridden at request level form data, see `resty.R().SetFormData`.
+// 		resty.SetFormData(map[string]string{
+//				"access_token": "BC594900-518B-4F7E-AC75-BD37F019E08F",
+//				"user_id": "3455454545",
+//			})
+//
+func (c *Client) SetFormData(data map[string]string) *Client {
+	for k, v := range data {
+		c.FormData.Set(k, v)
+	}
+
+	return c
+}
+
+// SetBasicAuth method sets the basic authentication header in the HTTP request. Example:
+//		Authorization: Basic <base64-encoded-value>
+//
+// Example: To set the header for username "go-resty" and password "welcome"
+// 		resty.SetBasicAuth("go-resty", "welcome")
+//
+// This basic auth information gets added to all the request rasied from this client instance.
+// Also it can be overridden or set one at the request level is supported, see `resty.R().SetBasicAuth`.
+//
+func (c *Client) SetBasicAuth(username, password string) *Client {
+	c.UserInfo = &User{Username: username, Password: password}
+	return c
+}
+
+// SetAuthToken method sets bearer auth token header in the HTTP request. Example:
+// 		Authorization: Bearer <auth-token-value-comes-here>
+//
+// Example: To set auth token BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F
+//
+// 		resty.SetAuthToken("BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F")
+//
+// This bearer auth token gets added to all the request rasied from this client instance.
+// Also it can be overridden or set one at the request level is supported, see `resty.R().SetAuthToken`.
+//
+func (c *Client) SetAuthToken(token string) *Client {
+	c.Token = token
+	return c
+}
+
+// R method creates a request instance, its used for Get, Post, Put, Delete, Patch, Head and Options.
+func (c *Client) R() *Request {
+	r := &Request{
+		QueryParam: url.Values{},
+		FormData:   url.Values{},
+		Header:     http.Header{},
+
+		client:          c,
+		multipartFiles:  []*File{},
+		multipartFields: []*multipartField{},
+		pathParams:      map[string]string{},
+	}
+
+	return r
+}
+
+// NewRequest is an alias for R(). Creates a request instance, its used for
+// Get, Post, Put, Delete, Patch, Head and Options.
+func (c *Client) NewRequest() *Request {
+	return c.R()
+}
+
+// OnBeforeRequest method appends request middleware into the before request chain.
+// Its gets applied after default `go-resty` request middlewares and before request
+// been sent from `go-resty` to host server.
+// 		resty.OnBeforeRequest(func(c *resty.Client, r *resty.Request) error {
+//				// Now you have access to Client and Request instance
+//				// manipulate it as per your need
+//
+//				return nil 	// if its success otherwise return error
+//			})
+//
+func (c *Client) OnBeforeRequest(m func(*Client, *Request) error) *Client {
+	c.udBeforeRequest = append(c.udBeforeRequest, m)
+	return c
+}
+
+// OnAfterResponse method appends response middleware into the after response chain.
+// Once we receive response from host server, default `go-resty` response middleware
+// gets applied and then user assigened response middlewares applied.
+// 		resty.OnAfterResponse(func(c *resty.Client, r *resty.Response) error {
+//				// Now you have access to Client and Response instance
+//				// manipulate it as per your need
+//
+//				return nil 	// if its success otherwise return error
+//			})
+//
+func (c *Client) OnAfterResponse(m func(*Client, *Response) error) *Client {
+	c.afterResponse = append(c.afterResponse, m)
+	return c
+}
+
+// SetPreRequestHook method sets the given pre-request function into resty client.
+// It is called right before the request is fired.
+//
+// Note: Only one pre-request hook can be registered. Use `resty.OnBeforeRequest` for mutilple.
+func (c *Client) SetPreRequestHook(h func(*Client, *Request) error) *Client {
+	if c.preReqHook != nil {
+		c.Log.Printf("Overwriting an existing pre-request hook: %s", functionName(h))
+	}
+	c.preReqHook = h
+	return c
+}
+
+// SetDebug method enables the debug mode on `go-resty` client. Client logs details of every request and response.
+// For `Request` it logs information such as HTTP verb, Relative URL path, Host, Headers, Body if it has one.
+// For `Response` it logs information such as Status, Response Time, Headers, Body if it has one.
+//		resty.SetDebug(true)
+//
+func (c *Client) SetDebug(d bool) *Client {
+	c.Debug = d
+	return c
+}
+
+// SetDebugBodyLimit sets the maximum size for which the response body will be logged in debug mode.
+//		resty.SetDebugBodyLimit(1000000)
+//
+func (c *Client) SetDebugBodyLimit(sl int64) *Client {
+	c.debugBodySizeLimit = sl
+	return c
+}
+
+// SetDisableWarn method disables the warning message on `go-resty` client.
+// For example: go-resty warns the user when BasicAuth used on HTTP mode.
+//		resty.SetDisableWarn(true)
+//
+func (c *Client) SetDisableWarn(d bool) *Client {
+	c.DisableWarn = d
+	return c
+}
+
+// SetAllowGetMethodPayload method allows the GET method with payload on `go-resty` client.
+// For example: go-resty allows the user sends request with a payload on HTTP GET method.
+//		resty.SetAllowGetMethodPayload(true)
+//
+func (c *Client) SetAllowGetMethodPayload(a bool) *Client {
+	c.AllowGetMethodPayload = a
+	return c
+}
+
+// SetLogger method sets given writer for logging go-resty request and response details.
+// Default is os.Stderr
+// 		file, _ := os.OpenFile("/Users/jeeva/go-resty.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
+//
+//		resty.SetLogger(file)
+//
+func (c *Client) SetLogger(w io.Writer) *Client {
+	c.Log = getLogger(w)
+	return c
+}
+
+// SetContentLength method enables the HTTP header `Content-Length` value for every request.
+// By default go-resty won't set `Content-Length`.
+// 		resty.SetContentLength(true)
+//
+// Also you have an option to enable for particular request. See `resty.R().SetContentLength`
+//
+func (c *Client) SetContentLength(l bool) *Client {
+	c.setContentLength = l
+	return c
+}
+
+// SetTimeout method sets timeout for request raised from client.
+//		resty.SetTimeout(time.Duration(1 * time.Minute))
+//
+func (c *Client) SetTimeout(timeout time.Duration) *Client {
+	c.httpClient.Timeout = timeout
+	return c
+}
+
+// SetError method is to register the global or client common `Error` object into go-resty.
+// It is used for automatic unmarshalling if response status code is greater than 399 and
+// content type either JSON or XML. Can be pointer or non-pointer.
+// 		resty.SetError(&Error{})
+//		// OR
+//		resty.SetError(Error{})
+//
+func (c *Client) SetError(err interface{}) *Client {
+	c.Error = typeOf(err)
+	return c
+}
+
+// SetRedirectPolicy method sets the client redirect poilicy. go-resty provides ready to use
+// redirect policies. Wanna create one for yourself refer `redirect.go`.
+//
+//		resty.SetRedirectPolicy(FlexibleRedirectPolicy(20))
+//
+// 		// Need multiple redirect policies together
+//		resty.SetRedirectPolicy(FlexibleRedirectPolicy(20), DomainCheckRedirectPolicy("host1.com", "host2.net"))
+//
+func (c *Client) SetRedirectPolicy(policies ...interface{}) *Client {
+	for _, p := range policies {
+		if _, ok := p.(RedirectPolicy); !ok {
+			c.Log.Printf("ERORR: %v does not implement resty.RedirectPolicy (missing Apply method)",
+				functionName(p))
+		}
+	}
+
+	c.httpClient.CheckRedirect = func(req *http.Request, via []*http.Request) error {
+		for _, p := range policies {
+			if err := p.(RedirectPolicy).Apply(req, via); err != nil {
+				return err
+			}
+		}
+		return nil // looks good, go ahead
+	}
+
+	return c
+}
+
+// SetRetryCount method enables retry on `go-resty` client and allows you
+// to set no. of retry count. Resty uses a Backoff mechanism.
+func (c *Client) SetRetryCount(count int) *Client {
+	c.RetryCount = count
+	return c
+}
+
+// SetRetryWaitTime method sets default wait time to sleep before retrying
+// request.
+// Default is 100 milliseconds.
+func (c *Client) SetRetryWaitTime(waitTime time.Duration) *Client {
+	c.RetryWaitTime = waitTime
+	return c
+}
+
+// SetRetryMaxWaitTime method sets max wait time to sleep before retrying
+// request.
+// Default is 2 seconds.
+func (c *Client) SetRetryMaxWaitTime(maxWaitTime time.Duration) *Client {
+	c.RetryMaxWaitTime = maxWaitTime
+	return c
+}
+
+// AddRetryCondition method adds a retry condition function to array of functions
+// that are checked to determine if the request is retried. The request will
+// retry if any of the functions return true and error is nil.
+func (c *Client) AddRetryCondition(condition RetryConditionFunc) *Client {
+	c.RetryConditions = append(c.RetryConditions, condition)
+	return c
+}
+
+// SetHTTPMode method sets go-resty mode to 'http'
+func (c *Client) SetHTTPMode() *Client {
+	return c.SetMode("http")
+}
+
+// SetRESTMode method sets go-resty mode to 'rest'
+func (c *Client) SetRESTMode() *Client {
+	return c.SetMode("rest")
+}
+
+// SetMode method sets go-resty client mode to given value such as 'http' & 'rest'.
+//	'rest':
+//		- No Redirect
+//		- Automatic response unmarshal if it is JSON or XML
+//	'http':
+//		- Up to 10 Redirects
+//		- No automatic unmarshall. Response will be treated as `response.String()`
+//
+// If you want more redirects, use FlexibleRedirectPolicy
+//		resty.SetRedirectPolicy(FlexibleRedirectPolicy(20))
+//
+func (c *Client) SetMode(mode string) *Client {
+	// HTTP
+	if mode == "http" {
+		c.isHTTPMode = true
+		c.SetRedirectPolicy(FlexibleRedirectPolicy(10))
+		c.afterResponse = []func(*Client, *Response) error{
+			responseLogger,
+			saveResponseIntoFile,
+		}
+		return c
+	}
+
+	// RESTful
+	c.isHTTPMode = false
+	c.SetRedirectPolicy(NoRedirectPolicy())
+	c.afterResponse = []func(*Client, *Response) error{
+		responseLogger,
+		parseResponseBody,
+		saveResponseIntoFile,
+	}
+	return c
+}
+
+// Mode method returns the current client mode. Typically its a "http" or "rest".
+// Default is "rest"
+func (c *Client) Mode() string {
+	if c.isHTTPMode {
+		return "http"
+	}
+	return "rest"
+}
+
+// SetTLSClientConfig method sets TLSClientConfig for underling client Transport.
+//
+// Example:
+// 		// One can set custom root-certificate. Refer: http://golang.org/pkg/crypto/tls/#example_Dial
+//		resty.SetTLSClientConfig(&tls.Config{ RootCAs: roots })
+//
+// 		// or One can disable security check (https)
+//		resty.SetTLSClientConfig(&tls.Config{ InsecureSkipVerify: true })
+// Note: This method overwrites existing `TLSClientConfig`.
+//
+func (c *Client) SetTLSClientConfig(config *tls.Config) *Client {
+	transport, err := c.getTransport()
+	if err != nil {
+		c.Log.Printf("ERROR %v", err)
+		return c
+	}
+	transport.TLSClientConfig = config
+	return c
+}
+
+// SetProxy method sets the Proxy URL and Port for resty client.
+//		resty.SetProxy("http://proxyserver:8888")
+//
+// Alternatives: At request level proxy, see `Request.SetProxy`.  OR Without this `SetProxy` method,
+// you can also set Proxy via environment variable. By default `Go` uses setting from `HTTP_PROXY`.
+//
+func (c *Client) SetProxy(proxyURL string) *Client {
+	transport, err := c.getTransport()
+	if err != nil {
+		c.Log.Printf("ERROR %v", err)
+		return c
+	}
+
+	if pURL, err := url.Parse(proxyURL); err == nil {
+		c.proxyURL = pURL
+		transport.Proxy = http.ProxyURL(c.proxyURL)
+	} else {
+		c.Log.Printf("ERROR %v", err)
+		c.RemoveProxy()
+	}
+	return c
+}
+
+// RemoveProxy method removes the proxy configuration from resty client
+//		resty.RemoveProxy()
+//
+func (c *Client) RemoveProxy() *Client {
+	transport, err := c.getTransport()
+	if err != nil {
+		c.Log.Printf("ERROR %v", err)
+		return c
+	}
+	c.proxyURL = nil
+	transport.Proxy = nil
+	return c
+}
+
+// SetCertificates method helps to set client certificates into resty conveniently.
+//
+func (c *Client) SetCertificates(certs ...tls.Certificate) *Client {
+	config, err := c.getTLSConfig()
+	if err != nil {
+		c.Log.Printf("ERROR %v", err)
+		return c
+	}
+	config.Certificates = append(config.Certificates, certs...)
+	return c
+}
+
+// SetRootCertificate method helps to add one or more root certificates into resty client
+// 		resty.SetRootCertificate("/path/to/root/pemFile.pem")
+//
+func (c *Client) SetRootCertificate(pemFilePath string) *Client {
+	rootPemData, err := ioutil.ReadFile(pemFilePath)
+	if err != nil {
+		c.Log.Printf("ERROR %v", err)
+		return c
+	}
+
+	config, err := c.getTLSConfig()
+	if err != nil {
+		c.Log.Printf("ERROR %v", err)
+		return c
+	}
+	if config.RootCAs == nil {
+		config.RootCAs = x509.NewCertPool()
+	}
+
+	config.RootCAs.AppendCertsFromPEM(rootPemData)
+
+	return c
+}
+
+// SetOutputDirectory method sets output directory for saving HTTP response into file.
+// If the output directory not exists then resty creates one. This setting is optional one,
+// if you're planning using absoule path in `Request.SetOutput` and can used together.
+// 		resty.SetOutputDirectory("/save/http/response/here")
+//
+func (c *Client) SetOutputDirectory(dirPath string) *Client {
+	c.outputDirectory = dirPath
+	return c
+}
+
+// SetTransport method sets custom `*http.Transport` or any `http.RoundTripper`
+// compatible interface implementation in the resty client.
+//
+// NOTE:
+//
+// - If transport is not type of `*http.Transport` then you may not be able to
+// take advantage of some of the `resty` client settings.
+//
+// - It overwrites the resty client transport instance and it's configurations.
+//
+//		transport := &http.Transport{
+//			// somthing like Proxying to httptest.Server, etc...
+//			Proxy: func(req *http.Request) (*url.URL, error) {
+//				return url.Parse(server.URL)
+//			},
+//		}
+//
+//		resty.SetTransport(transport)
+//
+func (c *Client) SetTransport(transport http.RoundTripper) *Client {
+	if transport != nil {
+		c.httpClient.Transport = transport
+	}
+	return c
+}
+
+// SetScheme method sets custom scheme in the resty client. It's way to override default.
+// 		resty.SetScheme("http")
+//
+func (c *Client) SetScheme(scheme string) *Client {
+	if !IsStringEmpty(scheme) {
+		c.scheme = scheme
+	}
+
+	return c
+}
+
+// SetCloseConnection method sets variable `Close` in http request struct with the given
+// value. More info: https://golang.org/src/net/http/request.go
+func (c *Client) SetCloseConnection(close bool) *Client {
+	c.closeConnection = close
+	return c
+}
+
+// SetDoNotParseResponse method instructs `Resty` not to parse the response body automatically.
+// Resty exposes the raw response body as `io.ReadCloser`. Also do not forget to close the body,
+// otherwise you might get into connection leaks, no connection reuse.
+//
+// Please Note: Response middlewares are not applicable, if you use this option. Basically you have
+// taken over the control of response parsing from `Resty`.
+func (c *Client) SetDoNotParseResponse(parse bool) *Client {
+	c.notParseResponse = parse
+	return c
+}
+
+// SetLogPrefix method sets the Resty logger prefix value.
+func (c *Client) SetLogPrefix(prefix string) *Client {
+	c.logPrefix = prefix
+	c.Log.SetPrefix(prefix)
+	return c
+}
+
+// SetPathParams method sets multiple URL path key-value pairs at one go in the
+// resty client instance.
+// 		resty.SetPathParams(map[string]string{
+// 		   "userId": "sample@sample.com",
+// 		   "subAccountId": "100002",
+// 		})
+//
+// 		Result:
+// 		   URL - /v1/users/{userId}/{subAccountId}/details
+// 		   Composed URL - /v1/users/sample@sample.com/100002/details
+// It replace the value of the key while composing request URL. Also it can be
+// overridden at request level Path Params options, see `Request.SetPathParams`.
+func (c *Client) SetPathParams(params map[string]string) *Client {
+	for p, v := range params {
+		c.pathParams[p] = v
+	}
+	return c
+}
+
+// IsProxySet method returns the true if proxy is set on client otherwise false.
+func (c *Client) IsProxySet() bool {
+	return c.proxyURL != nil
+}
+
+// GetClient method returns the current http.Client used by the resty client.
+func (c *Client) GetClient() *http.Client {
+	return c.httpClient
+}
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Client Unexported methods
+//___________________________________
+
+// executes the given `Request` object and returns response
+func (c *Client) execute(req *Request) (*Response, error) {
+	defer releaseBuffer(req.bodyBuf)
+	// Apply Request middleware
+	var err error
+
+	// user defined on before request methods
+	// to modify the *resty.Request object
+	for _, f := range c.udBeforeRequest {
+		if err = f(c, req); err != nil {
+			return nil, err
+		}
+	}
+
+	// resty middlewares
+	for _, f := range c.beforeRequest {
+		if err = f(c, req); err != nil {
+			return nil, err
+		}
+	}
+
+	// call pre-request if defined
+	if c.preReqHook != nil {
+		if err = c.preReqHook(c, req); err != nil {
+			return nil, err
+		}
+	}
+
+	if hostHeader := req.Header.Get("Host"); hostHeader != "" {
+		req.RawRequest.Host = hostHeader
+	}
+
+	req.Time = time.Now()
+	resp, err := c.httpClient.Do(req.RawRequest)
+
+	response := &Response{
+		Request:     req,
+		RawResponse: resp,
+		receivedAt:  time.Now(),
+	}
+
+	if err != nil || req.notParseResponse || c.notParseResponse {
+		return response, err
+	}
+
+	if !req.isSaveResponse {
+		defer closeq(resp.Body)
+		body := resp.Body
+
+		// GitHub #142
+		if strings.EqualFold(resp.Header.Get(hdrContentEncodingKey), "gzip") && resp.ContentLength > 0 {
+			if _, ok := body.(*gzip.Reader); !ok {
+				body, err = gzip.NewReader(body)
+				if err != nil {
+					return response, err
+				}
+				defer closeq(body)
+			}
+		}
+
+		if response.body, err = ioutil.ReadAll(body); err != nil {
+			return response, err
+		}
+
+		response.size = int64(len(response.body))
+	}
+
+	// Apply Response middleware
+	for _, f := range c.afterResponse {
+		if err = f(c, response); err != nil {
+			break
+		}
+	}
+
+	return response, err
+}
+
+// enables a log prefix
+func (c *Client) enableLogPrefix() {
+	c.Log.SetFlags(log.LstdFlags)
+	c.Log.SetPrefix(c.logPrefix)
+}
+
+// disables a log prefix
+func (c *Client) disableLogPrefix() {
+	c.Log.SetFlags(0)
+	c.Log.SetPrefix("")
+}
+
+// getting TLS client config if not exists then create one
+func (c *Client) getTLSConfig() (*tls.Config, error) {
+	transport, err := c.getTransport()
+	if err != nil {
+		return nil, err
+	}
+	if transport.TLSClientConfig == nil {
+		transport.TLSClientConfig = &tls.Config{}
+	}
+	return transport.TLSClientConfig, nil
+}
+
+// returns `*http.Transport` currently in use or error
+// in case currently used `transport` is not an `*http.Transport`
+func (c *Client) getTransport() (*http.Transport, error) {
+	if c.httpClient.Transport == nil {
+		c.SetTransport(new(http.Transport))
+	}
+
+	if transport, ok := c.httpClient.Transport.(*http.Transport); ok {
+		return transport, nil
+	}
+	return nil, errors.New("current transport is not an *http.Transport instance")
+}
+
+//
+// File
+//
+
+// File represent file information for multipart request
+type File struct {
+	Name      string
+	ParamName string
+	io.Reader
+}
+
+// String returns string value of current file details
+func (f *File) String() string {
+	return fmt.Sprintf("ParamName: %v; FileName: %v", f.ParamName, f.Name)
+}
+
+// multipartField represent custom data part for multipart request
+type multipartField struct {
+	Param       string
+	FileName    string
+	ContentType string
+	io.Reader
+}

vendor/github.com/go-resty/resty/default.go

@@ -0,0 +1,327 @@
+// Copyright (c) 2015-2018 Jeevanandam M (jeeva@myjeeva.com), All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"crypto/tls"
+	"encoding/json"
+	"io"
+	"math"
+	"net/http"
+	"net/http/cookiejar"
+	"net/url"
+	"os"
+	"time"
+
+	"golang.org/x/net/publicsuffix"
+)
+
+// DefaultClient of resty
+var DefaultClient *Client
+
+// New method creates a new go-resty client.
+func New() *Client {
+	cookieJar, _ := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
+	return createClient(&http.Client{Jar: cookieJar})
+}
+
+// NewWithClient method create a new go-resty client with given `http.Client`.
+func NewWithClient(hc *http.Client) *Client {
+	return createClient(hc)
+}
+
+// R creates a new resty request object, it is used form a HTTP/RESTful request
+// such as GET, POST, PUT, DELETE, HEAD, PATCH and OPTIONS.
+func R() *Request {
+	return DefaultClient.R()
+}
+
+// NewRequest is an alias for R(). Creates a new resty request object, it is used form a HTTP/RESTful request
+// such as GET, POST, PUT, DELETE, HEAD, PATCH and OPTIONS.
+func NewRequest() *Request {
+	return R()
+}
+
+// SetHostURL sets Host URL. See `Client.SetHostURL for more information.
+func SetHostURL(url string) *Client {
+	return DefaultClient.SetHostURL(url)
+}
+
+// SetHeader sets single header. See `Client.SetHeader` for more information.
+func SetHeader(header, value string) *Client {
+	return DefaultClient.SetHeader(header, value)
+}
+
+// SetHeaders sets multiple headers. See `Client.SetHeaders` for more information.
+func SetHeaders(headers map[string]string) *Client {
+	return DefaultClient.SetHeaders(headers)
+}
+
+// SetCookieJar sets custom http.CookieJar. See `Client.SetCookieJar` for more information.
+func SetCookieJar(jar http.CookieJar) *Client {
+	return DefaultClient.SetCookieJar(jar)
+}
+
+// SetCookie sets single cookie object. See `Client.SetCookie` for more information.
+func SetCookie(hc *http.Cookie) *Client {
+	return DefaultClient.SetCookie(hc)
+}
+
+// SetCookies sets multiple cookie object. See `Client.SetCookies` for more information.
+func SetCookies(cs []*http.Cookie) *Client {
+	return DefaultClient.SetCookies(cs)
+}
+
+// SetQueryParam method sets single parameter and its value. See `Client.SetQueryParam` for more information.
+func SetQueryParam(param, value string) *Client {
+	return DefaultClient.SetQueryParam(param, value)
+}
+
+// SetQueryParams method sets multiple parameters and its value. See `Client.SetQueryParams` for more information.
+func SetQueryParams(params map[string]string) *Client {
+	return DefaultClient.SetQueryParams(params)
+}
+
+// SetFormData method sets Form parameters and its values. See `Client.SetFormData` for more information.
+func SetFormData(data map[string]string) *Client {
+	return DefaultClient.SetFormData(data)
+}
+
+// SetBasicAuth method sets the basic authentication header. See `Client.SetBasicAuth` for more information.
+func SetBasicAuth(username, password string) *Client {
+	return DefaultClient.SetBasicAuth(username, password)
+}
+
+// SetAuthToken method sets bearer auth token header. See `Client.SetAuthToken` for more information.
+func SetAuthToken(token string) *Client {
+	return DefaultClient.SetAuthToken(token)
+}
+
+// OnBeforeRequest method sets request middleware. See `Client.OnBeforeRequest` for more information.
+func OnBeforeRequest(m func(*Client, *Request) error) *Client {
+	return DefaultClient.OnBeforeRequest(m)
+}
+
+// OnAfterResponse method sets response middleware. See `Client.OnAfterResponse` for more information.
+func OnAfterResponse(m func(*Client, *Response) error) *Client {
+	return DefaultClient.OnAfterResponse(m)
+}
+
+// SetPreRequestHook method sets the pre-request hook. See `Client.SetPreRequestHook` for more information.
+func SetPreRequestHook(h func(*Client, *Request) error) *Client {
+	return DefaultClient.SetPreRequestHook(h)
+}
+
+// SetDebug method enables the debug mode. See `Client.SetDebug` for more information.
+func SetDebug(d bool) *Client {
+	return DefaultClient.SetDebug(d)
+}
+
+// SetDebugBodyLimit method sets the response body limit for debug mode. See `Client.SetDebugBodyLimit` for more information.
+func SetDebugBodyLimit(sl int64) *Client {
+	return DefaultClient.SetDebugBodyLimit(sl)
+}
+
+// SetAllowGetMethodPayload method allows the GET method with payload. See `Client.SetAllowGetMethodPayload` for more information.
+func SetAllowGetMethodPayload(a bool) *Client {
+	return DefaultClient.SetAllowGetMethodPayload(a)
+}
+
+// SetRetryCount method sets the retry count. See `Client.SetRetryCount` for more information.
+func SetRetryCount(count int) *Client {
+	return DefaultClient.SetRetryCount(count)
+}
+
+// SetRetryWaitTime method sets the retry wait time. See `Client.SetRetryWaitTime` for more information.
+func SetRetryWaitTime(waitTime time.Duration) *Client {
+	return DefaultClient.SetRetryWaitTime(waitTime)
+}
+
+// SetRetryMaxWaitTime method sets the retry max wait time. See `Client.SetRetryMaxWaitTime` for more information.
+func SetRetryMaxWaitTime(maxWaitTime time.Duration) *Client {
+	return DefaultClient.SetRetryMaxWaitTime(maxWaitTime)
+}
+
+// AddRetryCondition method appends check function for retry. See `Client.AddRetryCondition` for more information.
+func AddRetryCondition(condition RetryConditionFunc) *Client {
+	return DefaultClient.AddRetryCondition(condition)
+}
+
+// SetDisableWarn method disables warning comes from `go-resty` client. See `Client.SetDisableWarn` for more information.
+func SetDisableWarn(d bool) *Client {
+	return DefaultClient.SetDisableWarn(d)
+}
+
+// SetLogger method sets given writer for logging. See `Client.SetLogger` for more information.
+func SetLogger(w io.Writer) *Client {
+	return DefaultClient.SetLogger(w)
+}
+
+// SetContentLength method enables `Content-Length` value. See `Client.SetContentLength` for more information.
+func SetContentLength(l bool) *Client {
+	return DefaultClient.SetContentLength(l)
+}
+
+// SetError method is to register the global or client common `Error` object. See `Client.SetError` for more information.
+func SetError(err interface{}) *Client {
+	return DefaultClient.SetError(err)
+}
+
+// SetRedirectPolicy method sets the client redirect poilicy. See `Client.SetRedirectPolicy` for more information.
+func SetRedirectPolicy(policies ...interface{}) *Client {
+	return DefaultClient.SetRedirectPolicy(policies...)
+}
+
+// SetHTTPMode method sets go-resty mode into HTTP. See `Client.SetMode` for more information.
+func SetHTTPMode() *Client {
+	return DefaultClient.SetHTTPMode()
+}
+
+// SetRESTMode method sets go-resty mode into RESTful. See `Client.SetMode` for more information.
+func SetRESTMode() *Client {
+	return DefaultClient.SetRESTMode()
+}
+
+// Mode method returns the current client mode. See `Client.Mode` for more information.
+func Mode() string {
+	return DefaultClient.Mode()
+}
+
+// SetTLSClientConfig method sets TLSClientConfig for underling client Transport. See `Client.SetTLSClientConfig` for more information.
+func SetTLSClientConfig(config *tls.Config) *Client {
+	return DefaultClient.SetTLSClientConfig(config)
+}
+
+// SetTimeout method sets timeout for request. See `Client.SetTimeout` for more information.
+func SetTimeout(timeout time.Duration) *Client {
+	return DefaultClient.SetTimeout(timeout)
+}
+
+// SetProxy method sets Proxy for request. See `Client.SetProxy` for more information.
+func SetProxy(proxyURL string) *Client {
+	return DefaultClient.SetProxy(proxyURL)
+}
+
+// RemoveProxy method removes the proxy configuration. See `Client.RemoveProxy` for more information.
+func RemoveProxy() *Client {
+	return DefaultClient.RemoveProxy()
+}
+
+// SetCertificates method helps to set client certificates into resty conveniently.
+// See `Client.SetCertificates` for more information and example.
+func SetCertificates(certs ...tls.Certificate) *Client {
+	return DefaultClient.SetCertificates(certs...)
+}
+
+// SetRootCertificate method helps to add one or more root certificates into resty client.
+// See `Client.SetRootCertificate` for more information.
+func SetRootCertificate(pemFilePath string) *Client {
+	return DefaultClient.SetRootCertificate(pemFilePath)
+}
+
+// SetOutputDirectory method sets output directory. See `Client.SetOutputDirectory` for more information.
+func SetOutputDirectory(dirPath string) *Client {
+	return DefaultClient.SetOutputDirectory(dirPath)
+}
+
+// SetTransport method sets custom `*http.Transport` or any `http.RoundTripper`
+// compatible interface implementation in the resty client.
+// See `Client.SetTransport` for more information.
+func SetTransport(transport http.RoundTripper) *Client {
+	return DefaultClient.SetTransport(transport)
+}
+
+// SetScheme method sets custom scheme in the resty client.
+// See `Client.SetScheme` for more information.
+func SetScheme(scheme string) *Client {
+	return DefaultClient.SetScheme(scheme)
+}
+
+// SetCloseConnection method sets close connection value in the resty client.
+// See `Client.SetCloseConnection` for more information.
+func SetCloseConnection(close bool) *Client {
+	return DefaultClient.SetCloseConnection(close)
+}
+
+// SetDoNotParseResponse method instructs `Resty` not to parse the response body automatically.
+// See `Client.SetDoNotParseResponse` for more information.
+func SetDoNotParseResponse(parse bool) *Client {
+	return DefaultClient.SetDoNotParseResponse(parse)
+}
+
+// SetPathParams method sets the Request path parameter key-value pairs. See
+// `Client.SetPathParams` for more information.
+func SetPathParams(params map[string]string) *Client {
+	return DefaultClient.SetPathParams(params)
+}
+
+// IsProxySet method returns the true if proxy is set on client otherwise false.
+// See `Client.IsProxySet` for more information.
+func IsProxySet() bool {
+	return DefaultClient.IsProxySet()
+}
+
+// GetClient method returns the current `http.Client` used by the default resty client.
+func GetClient() *http.Client {
+	return DefaultClient.httpClient
+}
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Unexported methods
+//___________________________________
+
+func createClient(hc *http.Client) *Client {
+	c := &Client{
+		HostURL:            "",
+		QueryParam:         url.Values{},
+		FormData:           url.Values{},
+		Header:             http.Header{},
+		UserInfo:           nil,
+		Token:              "",
+		Cookies:            make([]*http.Cookie, 0),
+		Debug:              false,
+		Log:                getLogger(os.Stderr),
+		RetryCount:         0,
+		RetryWaitTime:      defaultWaitTime,
+		RetryMaxWaitTime:   defaultMaxWaitTime,
+		JSONMarshal:        json.Marshal,
+		JSONUnmarshal:      json.Unmarshal,
+		httpClient:         hc,
+		debugBodySizeLimit: math.MaxInt32,
+		pathParams:         make(map[string]string),
+	}
+
+	// Log Prefix
+	c.SetLogPrefix("RESTY ")
+
+	// Default redirect policy
+	c.SetRedirectPolicy(NoRedirectPolicy())
+
+	// default before request middlewares
+	c.beforeRequest = []func(*Client, *Request) error{
+		parseRequestURL,
+		parseRequestHeader,
+		parseRequestBody,
+		createHTTPRequest,
+		addCredentials,
+		requestLogger,
+	}
+
+	// user defined request middlewares
+	c.udBeforeRequest = []func(*Client, *Request) error{}
+
+	// default after response middlewares
+	c.afterResponse = []func(*Client, *Response) error{
+		responseLogger,
+		parseResponseBody,
+		saveResponseIntoFile,
+	}
+
+	return c
+}
+
+func init() {
+	DefaultClient = New()
+}

vendor/github.com/go-resty/resty/middleware.go

@@ -0,0 +1,453 @@
+// Copyright (c) 2015-2018 Jeevanandam M (jeeva@myjeeva.com), All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"bytes"
+	"encoding/xml"
+	"errors"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"time"
+)
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Request Middleware(s)
+//___________________________________
+
+func parseRequestURL(c *Client, r *Request) error {
+	// GitHub #103 Path Params
+	if len(r.pathParams) > 0 {
+		for p, v := range r.pathParams {
+			r.URL = strings.Replace(r.URL, "{"+p+"}", v, -1)
+		}
+	}
+	if len(c.pathParams) > 0 {
+		for p, v := range c.pathParams {
+			r.URL = strings.Replace(r.URL, "{"+p+"}", v, -1)
+		}
+	}
+
+	// Parsing request URL
+	reqURL, err := url.Parse(r.URL)
+	if err != nil {
+		return err
+	}
+
+	// If Request.URL is relative path then added c.HostURL into
+	// the request URL otherwise Request.URL will be used as-is
+	if !reqURL.IsAbs() {
+		r.URL = reqURL.String()
+		if len(r.URL) > 0 && r.URL[0] != '/' {
+			r.URL = "/" + r.URL
+		}
+
+		reqURL, err = url.Parse(c.HostURL + r.URL)
+		if err != nil {
+			return err
+		}
+	}
+
+	// Adding Query Param
+	query := make(url.Values)
+	for k, v := range c.QueryParam {
+		for _, iv := range v {
+			query.Add(k, iv)
+		}
+	}
+
+	for k, v := range r.QueryParam {
+		// remove query param from client level by key
+		// since overrides happens for that key in the request
+		query.Del(k)
+
+		for _, iv := range v {
+			query.Add(k, iv)
+		}
+	}
+
+	// GitHub #123 Preserve query string order partially.
+	// Since not feasible in `SetQuery*` resty methods, because
+	// standard package `url.Encode(...)` sorts the query params
+	// alphabetically
+	if len(query) > 0 {
+		if IsStringEmpty(reqURL.RawQuery) {
+			reqURL.RawQuery = query.Encode()
+		} else {
+			reqURL.RawQuery = reqURL.RawQuery + "&" + query.Encode()
+		}
+	}
+
+	r.URL = reqURL.String()
+
+	return nil
+}
+
+func parseRequestHeader(c *Client, r *Request) error {
+	hdr := make(http.Header)
+	for k := range c.Header {
+		hdr[k] = append(hdr[k], c.Header[k]...)
+	}
+
+	for k := range r.Header {
+		hdr.Del(k)
+		hdr[k] = append(hdr[k], r.Header[k]...)
+	}
+
+	if IsStringEmpty(hdr.Get(hdrUserAgentKey)) {
+		hdr.Set(hdrUserAgentKey, fmt.Sprintf(hdrUserAgentValue, Version))
+	}
+
+	ct := hdr.Get(hdrContentTypeKey)
+	if IsStringEmpty(hdr.Get(hdrAcceptKey)) && !IsStringEmpty(ct) &&
+		(IsJSONType(ct) || IsXMLType(ct)) {
+		hdr.Set(hdrAcceptKey, hdr.Get(hdrContentTypeKey))
+	}
+
+	r.Header = hdr
+
+	return nil
+}
+
+func parseRequestBody(c *Client, r *Request) (err error) {
+	if isPayloadSupported(r.Method, c.AllowGetMethodPayload) {
+		// Handling Multipart
+		if r.isMultiPart && !(r.Method == MethodPatch) {
+			if err = handleMultipart(c, r); err != nil {
+				return
+			}
+
+			goto CL
+		}
+
+		// Handling Form Data
+		if len(c.FormData) > 0 || len(r.FormData) > 0 {
+			handleFormData(c, r)
+
+			goto CL
+		}
+
+		// Handling Request body
+		if r.Body != nil {
+			handleContentType(c, r)
+
+			if err = handleRequestBody(c, r); err != nil {
+				return
+			}
+		}
+	}
+
+CL:
+	// by default resty won't set content length, you can if you want to :)
+	if (c.setContentLength || r.setContentLength) && r.bodyBuf != nil {
+		r.Header.Set(hdrContentLengthKey, fmt.Sprintf("%d", r.bodyBuf.Len()))
+	}
+
+	return
+}
+
+func createHTTPRequest(c *Client, r *Request) (err error) {
+	if r.bodyBuf == nil {
+		if reader, ok := r.Body.(io.Reader); ok {
+			r.RawRequest, err = http.NewRequest(r.Method, r.URL, reader)
+		} else {
+			r.RawRequest, err = http.NewRequest(r.Method, r.URL, nil)
+		}
+	} else {
+		r.RawRequest, err = http.NewRequest(r.Method, r.URL, r.bodyBuf)
+	}
+
+	if err != nil {
+		return
+	}
+
+	// Assign close connection option
+	r.RawRequest.Close = c.closeConnection
+
+	// Add headers into http request
+	r.RawRequest.Header = r.Header
+
+	// Add cookies into http request
+	for _, cookie := range c.Cookies {
+		r.RawRequest.AddCookie(cookie)
+	}
+
+	// it's for non-http scheme option
+	if r.RawRequest.URL != nil && r.RawRequest.URL.Scheme == "" {
+		r.RawRequest.URL.Scheme = c.scheme
+		r.RawRequest.URL.Host = r.URL
+	}
+
+	// Use context if it was specified
+	r.addContextIfAvailable()
+
+	return
+}
+
+func addCredentials(c *Client, r *Request) error {
+	var isBasicAuth bool
+	// Basic Auth
+	if r.UserInfo != nil { // takes precedence
+		r.RawRequest.SetBasicAuth(r.UserInfo.Username, r.UserInfo.Password)
+		isBasicAuth = true
+	} else if c.UserInfo != nil {
+		r.RawRequest.SetBasicAuth(c.UserInfo.Username, c.UserInfo.Password)
+		isBasicAuth = true
+	}
+
+	if !c.DisableWarn {
+		if isBasicAuth && !strings.HasPrefix(r.URL, "https") {
+			c.Log.Println("WARNING - Using Basic Auth in HTTP mode is not secure.")
+		}
+	}
+
+	// Token Auth
+	if !IsStringEmpty(r.Token) { // takes precedence
+		r.RawRequest.Header.Set(hdrAuthorizationKey, "Bearer "+r.Token)
+	} else if !IsStringEmpty(c.Token) {
+		r.RawRequest.Header.Set(hdrAuthorizationKey, "Bearer "+c.Token)
+	}
+
+	return nil
+}
+
+func requestLogger(c *Client, r *Request) error {
+	if c.Debug {
+		rr := r.RawRequest
+		reqLog := "\n---------------------- REQUEST LOG -----------------------\n" +
+			fmt.Sprintf("%s  %s  %s\n", r.Method, rr.URL.RequestURI(), rr.Proto) +
+			fmt.Sprintf("HOST   : %s\n", rr.URL.Host) +
+			fmt.Sprintf("HEADERS:\n") +
+			composeHeaders(rr.Header) + "\n" +
+			fmt.Sprintf("BODY   :\n%v\n", r.fmtBodyString()) +
+			"----------------------------------------------------------\n"
+
+		c.Log.Print(reqLog)
+	}
+
+	return nil
+}
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Response Middleware(s)
+//___________________________________
+
+func responseLogger(c *Client, res *Response) error {
+	if c.Debug {
+		resLog := "\n---------------------- RESPONSE LOG -----------------------\n" +
+			fmt.Sprintf("STATUS 		: %s\n", res.Status()) +
+			fmt.Sprintf("RECEIVED AT	: %v\n", res.ReceivedAt().Format(time.RFC3339Nano)) +
+			fmt.Sprintf("RESPONSE TIME	: %v\n", res.Time()) +
+			"HEADERS:\n" +
+			composeHeaders(res.Header()) + "\n"
+
+		if res.Request.isSaveResponse {
+			resLog += fmt.Sprintf("BODY   :\n***** RESPONSE WRITTEN INTO FILE *****\n")
+		} else {
+			resLog += fmt.Sprintf("BODY   :\n%v\n", res.fmtBodyString(c.debugBodySizeLimit))
+		}
+		resLog += "----------------------------------------------------------\n"
+
+		c.Log.Print(resLog)
+	}
+
+	return nil
+}
+
+func parseResponseBody(c *Client, res *Response) (err error) {
+	// Handles only JSON or XML content type
+	ct := firstNonEmpty(res.Header().Get(hdrContentTypeKey), res.Request.fallbackContentType)
+	if IsJSONType(ct) || IsXMLType(ct) {
+		// HTTP status code > 199 and < 300, considered as Result
+		if res.IsSuccess() {
+			if res.Request.Result != nil {
+				err = Unmarshalc(c, ct, res.body, res.Request.Result)
+				return
+			}
+		}
+
+		// HTTP status code > 399, considered as Error
+		if res.IsError() {
+			// global error interface
+			if res.Request.Error == nil && c.Error != nil {
+				res.Request.Error = reflect.New(c.Error).Interface()
+			}
+
+			if res.Request.Error != nil {
+				err = Unmarshalc(c, ct, res.body, res.Request.Error)
+			}
+		}
+	}
+
+	return
+}
+
+func handleMultipart(c *Client, r *Request) (err error) {
+	r.bodyBuf = acquireBuffer()
+	w := multipart.NewWriter(r.bodyBuf)
+
+	for k, v := range c.FormData {
+		for _, iv := range v {
+			if err = w.WriteField(k, iv); err != nil {
+				return err
+			}
+		}
+	}
+
+	for k, v := range r.FormData {
+		for _, iv := range v {
+			if strings.HasPrefix(k, "@") { // file
+				err = addFile(w, k[1:], iv)
+				if err != nil {
+					return
+				}
+			} else { // form value
+				if err = w.WriteField(k, iv); err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	// #21 - adding io.Reader support
+	if len(r.multipartFiles) > 0 {
+		for _, f := range r.multipartFiles {
+			err = addFileReader(w, f)
+			if err != nil {
+				return
+			}
+		}
+	}
+
+	// GitHub #130 adding multipart field support with content type
+	if len(r.multipartFields) > 0 {
+		for _, mf := range r.multipartFields {
+			if err = addMultipartFormField(w, mf); err != nil {
+				return
+			}
+		}
+	}
+
+	r.Header.Set(hdrContentTypeKey, w.FormDataContentType())
+	err = w.Close()
+
+	return
+}
+
+func handleFormData(c *Client, r *Request) {
+	formData := url.Values{}
+
+	for k, v := range c.FormData {
+		for _, iv := range v {
+			formData.Add(k, iv)
+		}
+	}
+
+	for k, v := range r.FormData {
+		// remove form data field from client level by key
+		// since overrides happens for that key in the request
+		formData.Del(k)
+
+		for _, iv := range v {
+			formData.Add(k, iv)
+		}
+	}
+
+	r.bodyBuf = bytes.NewBuffer([]byte(formData.Encode()))
+	r.Header.Set(hdrContentTypeKey, formContentType)
+	r.isFormData = true
+}
+
+func handleContentType(c *Client, r *Request) {
+	contentType := r.Header.Get(hdrContentTypeKey)
+	if IsStringEmpty(contentType) {
+		contentType = DetectContentType(r.Body)
+		r.Header.Set(hdrContentTypeKey, contentType)
+	}
+}
+
+func handleRequestBody(c *Client, r *Request) (err error) {
+	var bodyBytes []byte
+	contentType := r.Header.Get(hdrContentTypeKey)
+	kind := kindOf(r.Body)
+	r.bodyBuf = nil
+
+	if reader, ok := r.Body.(io.Reader); ok {
+		if c.setContentLength || r.setContentLength { // keep backward compability
+			r.bodyBuf = acquireBuffer()
+			_, err = r.bodyBuf.ReadFrom(reader)
+			r.Body = nil
+		} else {
+			// Otherwise buffer less processing for `io.Reader`, sounds good.
+			return
+		}
+	} else if b, ok := r.Body.([]byte); ok {
+		bodyBytes = b
+	} else if s, ok := r.Body.(string); ok {
+		bodyBytes = []byte(s)
+	} else if IsJSONType(contentType) &&
+		(kind == reflect.Struct || kind == reflect.Map || kind == reflect.Slice) {
+		bodyBytes, err = c.JSONMarshal(r.Body)
+	} else if IsXMLType(contentType) && (kind == reflect.Struct) {
+		bodyBytes, err = xml.Marshal(r.Body)
+	}
+
+	if bodyBytes == nil && r.bodyBuf == nil {
+		err = errors.New("unsupported 'Body' type/value")
+	}
+
+	// if any errors during body bytes handling, return it
+	if err != nil {
+		return
+	}
+
+	// []byte into Buffer
+	if bodyBytes != nil && r.bodyBuf == nil {
+		r.bodyBuf = acquireBuffer()
+		_, _ = r.bodyBuf.Write(bodyBytes)
+	}
+
+	return
+}
+
+func saveResponseIntoFile(c *Client, res *Response) error {
+	if res.Request.isSaveResponse {
+		file := ""
+
+		if len(c.outputDirectory) > 0 && !filepath.IsAbs(res.Request.outputFile) {
+			file += c.outputDirectory + string(filepath.Separator)
+		}
+
+		file = filepath.Clean(file + res.Request.outputFile)
+		if err := createDirectory(filepath.Dir(file)); err != nil {
+			return err
+		}
+
+		outFile, err := os.Create(file)
+		if err != nil {
+			return err
+		}
+		defer closeq(outFile)
+
+		// io.Copy reads maximum 32kb size, it is perfect for large file download too
+		defer closeq(res.RawResponse.Body)
+
+		written, err := io.Copy(outFile, res.RawResponse.Body)
+		if err != nil {
+			return err
+		}
+
+		res.size = written
+	}
+
+	return nil
+}

vendor/github.com/go-resty/resty/redirect.go

@@ -0,0 +1,99 @@
+// Copyright (c) 2015-2018 Jeevanandam M (jeeva@myjeeva.com), All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"strings"
+)
+
+type (
+	// RedirectPolicy to regulate the redirects in the resty client.
+	// Objects implementing the RedirectPolicy interface can be registered as
+	//
+	// Apply function should return nil to continue the redirect jounery, otherwise
+	// return error to stop the redirect.
+	RedirectPolicy interface {
+		Apply(req *http.Request, via []*http.Request) error
+	}
+
+	// The RedirectPolicyFunc type is an adapter to allow the use of ordinary functions as RedirectPolicy.
+	// If f is a function with the appropriate signature, RedirectPolicyFunc(f) is a RedirectPolicy object that calls f.
+	RedirectPolicyFunc func(*http.Request, []*http.Request) error
+)
+
+// Apply calls f(req, via).
+func (f RedirectPolicyFunc) Apply(req *http.Request, via []*http.Request) error {
+	return f(req, via)
+}
+
+// NoRedirectPolicy is used to disable redirects in the HTTP client
+// 		resty.SetRedirectPolicy(NoRedirectPolicy())
+func NoRedirectPolicy() RedirectPolicy {
+	return RedirectPolicyFunc(func(req *http.Request, via []*http.Request) error {
+		return errors.New("auto redirect is disabled")
+	})
+}
+
+// FlexibleRedirectPolicy is convenient method to create No of redirect policy for HTTP client.
+// 		resty.SetRedirectPolicy(FlexibleRedirectPolicy(20))
+func FlexibleRedirectPolicy(noOfRedirect int) RedirectPolicy {
+	return RedirectPolicyFunc(func(req *http.Request, via []*http.Request) error {
+		if len(via) >= noOfRedirect {
+			return fmt.Errorf("stopped after %d redirects", noOfRedirect)
+		}
+
+		checkHostAndAddHeaders(req, via[0])
+
+		return nil
+	})
+}
+
+// DomainCheckRedirectPolicy is convenient method to define domain name redirect rule in resty client.
+// Redirect is allowed for only mentioned host in the policy.
+// 		resty.SetRedirectPolicy(DomainCheckRedirectPolicy("host1.com", "host2.org", "host3.net"))
+func DomainCheckRedirectPolicy(hostnames ...string) RedirectPolicy {
+	hosts := make(map[string]bool)
+	for _, h := range hostnames {
+		hosts[strings.ToLower(h)] = true
+	}
+
+	fn := RedirectPolicyFunc(func(req *http.Request, via []*http.Request) error {
+		if ok := hosts[getHostname(req.URL.Host)]; !ok {
+			return errors.New("redirect is not allowed as per DomainCheckRedirectPolicy")
+		}
+
+		return nil
+	})
+
+	return fn
+}
+
+func getHostname(host string) (hostname string) {
+	if strings.Index(host, ":") > 0 {
+		host, _, _ = net.SplitHostPort(host)
+	}
+	hostname = strings.ToLower(host)
+	return
+}
+
+// By default Golang will not redirect request headers
+// after go throughing various discussion comments from thread
+// https://github.com/golang/go/issues/4800
+// go-resty will add all the headers during a redirect for the same host
+func checkHostAndAddHeaders(cur *http.Request, pre *http.Request) {
+	curHostname := getHostname(cur.URL.Host)
+	preHostname := getHostname(pre.URL.Host)
+	if strings.EqualFold(curHostname, preHostname) {
+		for key, val := range pre.Header {
+			cur.Header[key] = val
+		}
+	} else { // only library User-Agent header is added
+		cur.Header.Set(hdrUserAgentKey, fmt.Sprintf(hdrUserAgentValue, Version))
+	}
+}

vendor/github.com/go-resty/resty/request.go

@@ -0,0 +1,558 @@
+// Copyright (c) 2015-2018 Jeevanandam M (jeeva@myjeeva.com), All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"encoding/xml"
+	"fmt"
+	"io"
+	"net"
+	"net/url"
+	"reflect"
+	"strings"
+)
+
+// SRVRecord holds the data to query the SRV record for the following service
+type SRVRecord struct {
+	Service string
+	Domain  string
+}
+
+// SetHeader method is to set a single header field and its value in the current request.
+// Example: To set `Content-Type` and `Accept` as `application/json`.
+// 		resty.R().
+//			SetHeader("Content-Type", "application/json").
+//			SetHeader("Accept", "application/json")
+//
+// Also you can override header value, which was set at client instance level.
+//
+func (r *Request) SetHeader(header, value string) *Request {
+	r.Header.Set(header, value)
+	return r
+}
+
+// SetHeaders method sets multiple headers field and its values at one go in the current request.
+// Example: To set `Content-Type` and `Accept` as `application/json`
+//
+// 		resty.R().
+//			SetHeaders(map[string]string{
+//				"Content-Type": "application/json",
+//				"Accept": "application/json",
+//			})
+// Also you can override header value, which was set at client instance level.
+//
+func (r *Request) SetHeaders(headers map[string]string) *Request {
+	for h, v := range headers {
+		r.SetHeader(h, v)
+	}
+
+	return r
+}
+
+// SetQueryParam method sets single parameter and its value in the current request.
+// It will be formed as query string for the request.
+// Example: `search=kitchen%20papers&size=large` in the URL after `?` mark.
+// 		resty.R().
+//			SetQueryParam("search", "kitchen papers").
+//			SetQueryParam("size", "large")
+// Also you can override query params value, which was set at client instance level
+//
+func (r *Request) SetQueryParam(param, value string) *Request {
+	r.QueryParam.Set(param, value)
+	return r
+}
+
+// SetQueryParams method sets multiple parameters and its values at one go in the current request.
+// It will be formed as query string for the request.
+// Example: `search=kitchen%20papers&size=large` in the URL after `?` mark.
+// 		resty.R().
+//			SetQueryParams(map[string]string{
+//				"search": "kitchen papers",
+//				"size": "large",
+//			})
+// Also you can override query params value, which was set at client instance level
+//
+func (r *Request) SetQueryParams(params map[string]string) *Request {
+	for p, v := range params {
+		r.SetQueryParam(p, v)
+	}
+
+	return r
+}
+
+// SetMultiValueQueryParams method appends multiple parameters with multi-value
+// at one go in the current request. It will be formed as query string for the request.
+// Example: `status=pending&status=approved&status=open` in the URL after `?` mark.
+// 		resty.R().
+//			SetMultiValueQueryParams(url.Values{
+//				"status": []string{"pending", "approved", "open"},
+//			})
+// Also you can override query params value, which was set at client instance level
+//
+func (r *Request) SetMultiValueQueryParams(params url.Values) *Request {
+	for p, v := range params {
+		for _, pv := range v {
+			r.QueryParam.Add(p, pv)
+		}
+	}
+
+	return r
+}
+
+// SetQueryString method provides ability to use string as an input to set URL query string for the request.
+//
+// Using String as an input
+// 		resty.R().
+//			SetQueryString("productId=232&template=fresh-sample&cat=resty&source=google&kw=buy a lot more")
+//
+func (r *Request) SetQueryString(query string) *Request {
+	params, err := url.ParseQuery(strings.TrimSpace(query))
+	if err == nil {
+		for p, v := range params {
+			for _, pv := range v {
+				r.QueryParam.Add(p, pv)
+			}
+		}
+	} else {
+		r.client.Log.Printf("ERROR %v", err)
+	}
+	return r
+}
+
+// SetFormData method sets Form parameters and their values in the current request.
+// It's applicable only HTTP method `POST` and `PUT` and requests content type would be set as
+// `application/x-www-form-urlencoded`.
+// 		resty.R().
+// 			SetFormData(map[string]string{
+//				"access_token": "BC594900-518B-4F7E-AC75-BD37F019E08F",
+//				"user_id": "3455454545",
+//			})
+// Also you can override form data value, which was set at client instance level
+//
+func (r *Request) SetFormData(data map[string]string) *Request {
+	for k, v := range data {
+		r.FormData.Set(k, v)
+	}
+
+	return r
+}
+
+// SetMultiValueFormData method appends multiple form parameters with multi-value
+// at one go in the current request.
+// 		resty.R().
+//			SetMultiValueFormData(url.Values{
+//				"search_criteria": []string{"book", "glass", "pencil"},
+//			})
+// Also you can override form data value, which was set at client instance level
+//
+func (r *Request) SetMultiValueFormData(params url.Values) *Request {
+	for k, v := range params {
+		for _, kv := range v {
+			r.FormData.Add(k, kv)
+		}
+	}
+
+	return r
+}
+
+// SetBody method sets the request body for the request. It supports various realtime need easy.
+// We can say its quite handy or powerful. Supported request body data types is `string`, `[]byte`,
+// `struct` and `map`. Body value can be pointer or non-pointer. Automatic marshalling
+// for JSON and XML content type, if it is `struct` or `map`.
+//
+// Example:
+//
+// Struct as a body input, based on content type, it will be marshalled.
+//		resty.R().
+//			SetBody(User{
+//				Username: "jeeva@myjeeva.com",
+//				Password: "welcome2resty",
+//			})
+//
+// Map as a body input, based on content type, it will be marshalled.
+//		resty.R().
+//			SetBody(map[string]interface{}{
+//				"username": "jeeva@myjeeva.com",
+//				"password": "welcome2resty",
+//				"address": &Address{
+//					Address1: "1111 This is my street",
+//					Address2: "Apt 201",
+//					City: "My City",
+//					State: "My State",
+//					ZipCode: 00000,
+//				},
+//			})
+//
+// String as a body input. Suitable for any need as a string input.
+//		resty.R().
+//			SetBody(`{
+//				"username": "jeeva@getrightcare.com",
+//				"password": "admin"
+//			}`)
+//
+// []byte as a body input. Suitable for raw request such as file upload, serialize & deserialize, etc.
+// 		resty.R().
+//			SetBody([]byte("This is my raw request, sent as-is"))
+//
+func (r *Request) SetBody(body interface{}) *Request {
+	r.Body = body
+	return r
+}
+
+// SetResult method is to register the response `Result` object for automatic unmarshalling in the RESTful mode
+// if response status code is between 200 and 299 and content type either JSON or XML.
+//
+// Note: Result object can be pointer or non-pointer.
+//		resty.R().SetResult(&AuthToken{})
+//		// OR
+//		resty.R().SetResult(AuthToken{})
+//
+// Accessing a result value
+//		response.Result().(*AuthToken)
+//
+func (r *Request) SetResult(res interface{}) *Request {
+	r.Result = getPointer(res)
+	return r
+}
+
+// SetError method is to register the request `Error` object for automatic unmarshalling in the RESTful mode
+// if response status code is greater than 399 and content type either JSON or XML.
+//
+// Note: Error object can be pointer or non-pointer.
+// 		resty.R().SetError(&AuthError{})
+//		// OR
+//		resty.R().SetError(AuthError{})
+//
+// Accessing a error value
+//		response.Error().(*AuthError)
+//
+func (r *Request) SetError(err interface{}) *Request {
+	r.Error = getPointer(err)
+	return r
+}
+
+// SetFile method is to set single file field name and its path for multipart upload.
+//	resty.R().
+//		SetFile("my_file", "/Users/jeeva/Gas Bill - Sep.pdf")
+//
+func (r *Request) SetFile(param, filePath string) *Request {
+	r.isMultiPart = true
+	r.FormData.Set("@"+param, filePath)
+
+	return r
+}
+
+// SetFiles method is to set multiple file field name and its path for multipart upload.
+//	resty.R().
+//		SetFiles(map[string]string{
+//				"my_file1": "/Users/jeeva/Gas Bill - Sep.pdf",
+//				"my_file2": "/Users/jeeva/Electricity Bill - Sep.pdf",
+//				"my_file3": "/Users/jeeva/Water Bill - Sep.pdf",
+//			})
+//
+func (r *Request) SetFiles(files map[string]string) *Request {
+	r.isMultiPart = true
+
+	for f, fp := range files {
+		r.FormData.Set("@"+f, fp)
+	}
+
+	return r
+}
+
+// SetFileReader method is to set single file using io.Reader for multipart upload.
+//	resty.R().
+//		SetFileReader("profile_img", "my-profile-img.png", bytes.NewReader(profileImgBytes)).
+//		SetFileReader("notes", "user-notes.txt", bytes.NewReader(notesBytes))
+//
+func (r *Request) SetFileReader(param, fileName string, reader io.Reader) *Request {
+	r.isMultiPart = true
+
+	r.multipartFiles = append(r.multipartFiles, &File{
+		Name:      fileName,
+		ParamName: param,
+		Reader:    reader,
+	})
+
+	return r
+}
+
+// SetMultipartField method is to set custom data using io.Reader for multipart upload.
+func (r *Request) SetMultipartField(param, fileName, contentType string, reader io.Reader) *Request {
+	r.isMultiPart = true
+
+	r.multipartFields = append(r.multipartFields, &multipartField{
+		Param:       param,
+		FileName:    fileName,
+		ContentType: contentType,
+		Reader:      reader,
+	})
+
+	return r
+}
+
+// SetContentLength method sets the HTTP header `Content-Length` value for current request.
+// By default go-resty won't set `Content-Length`. Also you have an option to enable for every
+// request. See `resty.SetContentLength`
+// 		resty.R().SetContentLength(true)
+//
+func (r *Request) SetContentLength(l bool) *Request {
+	r.setContentLength = true
+
+	return r
+}
+
+// SetBasicAuth method sets the basic authentication header in the current HTTP request.
+// For Header example:
+//		Authorization: Basic <base64-encoded-value>
+//
+// To set the header for username "go-resty" and password "welcome"
+// 		resty.R().SetBasicAuth("go-resty", "welcome")
+//
+// This method overrides the credentials set by method `resty.SetBasicAuth`.
+//
+func (r *Request) SetBasicAuth(username, password string) *Request {
+	r.UserInfo = &User{Username: username, Password: password}
+	return r
+}
+
+// SetAuthToken method sets bearer auth token header in the current HTTP request. Header example:
+// 		Authorization: Bearer <auth-token-value-comes-here>
+//
+// Example: To set auth token BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F
+//
+// 		resty.R().SetAuthToken("BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F")
+//
+// This method overrides the Auth token set by method `resty.SetAuthToken`.
+//
+func (r *Request) SetAuthToken(token string) *Request {
+	r.Token = token
+	return r
+}
+
+// SetOutput method sets the output file for current HTTP request. Current HTTP response will be
+// saved into given file. It is similar to `curl -o` flag. Absolute path or relative path can be used.
+// If is it relative path then output file goes under the output directory, as mentioned
+// in the `Client.SetOutputDirectory`.
+// 		resty.R().
+// 			SetOutput("/Users/jeeva/Downloads/ReplyWithHeader-v5.1-beta.zip").
+// 			Get("http://bit.ly/1LouEKr")
+//
+// Note: In this scenario `Response.Body` might be nil.
+func (r *Request) SetOutput(file string) *Request {
+	r.outputFile = file
+	r.isSaveResponse = true
+	return r
+}
+
+// SetSRV method sets the details to query the service SRV record and execute the
+// request.
+// 		resty.R().
+//			SetSRV(SRVRecord{"web", "testservice.com"}).
+//			Get("/get")
+func (r *Request) SetSRV(srv *SRVRecord) *Request {
+	r.SRV = srv
+	return r
+}
+
+// SetDoNotParseResponse method instructs `Resty` not to parse the response body automatically.
+// Resty exposes the raw response body as `io.ReadCloser`. Also do not forget to close the body,
+// otherwise you might get into connection leaks, no connection reuse.
+//
+// Please Note: Response middlewares are not applicable, if you use this option. Basically you have
+// taken over the control of response parsing from `Resty`.
+func (r *Request) SetDoNotParseResponse(parse bool) *Request {
+	r.notParseResponse = parse
+	return r
+}
+
+// SetPathParams method sets multiple URL path key-value pairs at one go in the
+// resty current request instance.
+// 		resty.R().SetPathParams(map[string]string{
+// 		   "userId": "sample@sample.com",
+// 		   "subAccountId": "100002",
+// 		})
+//
+// 		Result:
+// 		   URL - /v1/users/{userId}/{subAccountId}/details
+// 		   Composed URL - /v1/users/sample@sample.com/100002/details
+// It replace the value of the key while composing request URL. Also you can
+// override Path Params value, which was set at client instance level.
+func (r *Request) SetPathParams(params map[string]string) *Request {
+	for p, v := range params {
+		r.pathParams[p] = v
+	}
+	return r
+}
+
+// ExpectContentType method allows to provide fallback `Content-Type` for automatic unmarshalling
+// when `Content-Type` response header is unavailable.
+func (r *Request) ExpectContentType(contentType string) *Request {
+	r.fallbackContentType = contentType
+	return r
+}
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// HTTP verb method starts here
+//___________________________________
+
+// Get method does GET HTTP request. It's defined in section 4.3.1 of RFC7231.
+func (r *Request) Get(url string) (*Response, error) {
+	return r.Execute(MethodGet, url)
+}
+
+// Head method does HEAD HTTP request. It's defined in section 4.3.2 of RFC7231.
+func (r *Request) Head(url string) (*Response, error) {
+	return r.Execute(MethodHead, url)
+}
+
+// Post method does POST HTTP request. It's defined in section 4.3.3 of RFC7231.
+func (r *Request) Post(url string) (*Response, error) {
+	return r.Execute(MethodPost, url)
+}
+
+// Put method does PUT HTTP request. It's defined in section 4.3.4 of RFC7231.
+func (r *Request) Put(url string) (*Response, error) {
+	return r.Execute(MethodPut, url)
+}
+
+// Delete method does DELETE HTTP request. It's defined in section 4.3.5 of RFC7231.
+func (r *Request) Delete(url string) (*Response, error) {
+	return r.Execute(MethodDelete, url)
+}
+
+// Options method does OPTIONS HTTP request. It's defined in section 4.3.7 of RFC7231.
+func (r *Request) Options(url string) (*Response, error) {
+	return r.Execute(MethodOptions, url)
+}
+
+// Patch method does PATCH HTTP request. It's defined in section 2 of RFC5789.
+func (r *Request) Patch(url string) (*Response, error) {
+	return r.Execute(MethodPatch, url)
+}
+
+// Execute method performs the HTTP request with given HTTP method and URL
+// for current `Request`.
+// 		resp, err := resty.R().Execute(resty.GET, "http://httpbin.org/get")
+//
+func (r *Request) Execute(method, url string) (*Response, error) {
+	var addrs []*net.SRV
+	var err error
+
+	if r.isMultiPart && !(method == MethodPost || method == MethodPut) {
+		return nil, fmt.Errorf("multipart content is not allowed in HTTP verb [%v]", method)
+	}
+
+	if r.SRV != nil {
+		_, addrs, err = net.LookupSRV(r.SRV.Service, "tcp", r.SRV.Domain)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	r.Method = method
+	r.URL = r.selectAddr(addrs, url, 0)
+
+	if r.client.RetryCount == 0 {
+		return r.client.execute(r)
+	}
+
+	var resp *Response
+	attempt := 0
+	_ = Backoff(
+		func() (*Response, error) {
+			attempt++
+
+			r.URL = r.selectAddr(addrs, url, attempt)
+
+			resp, err = r.client.execute(r)
+			if err != nil {
+				r.client.Log.Printf("ERROR %v, Attempt %v", err, attempt)
+				if r.isContextCancelledIfAvailable() {
+					// stop Backoff from retrying request if request has been
+					// canceled by context
+					return resp, nil
+				}
+			}
+
+			return resp, err
+		},
+		Retries(r.client.RetryCount),
+		WaitTime(r.client.RetryWaitTime),
+		MaxWaitTime(r.client.RetryMaxWaitTime),
+		RetryConditions(r.client.RetryConditions),
+	)
+
+	return resp, err
+}
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Request Unexported methods
+//___________________________________
+
+func (r *Request) fmtBodyString() (body string) {
+	body = "***** NO CONTENT *****"
+	if isPayloadSupported(r.Method, r.client.AllowGetMethodPayload) {
+		if _, ok := r.Body.(io.Reader); ok {
+			body = "***** BODY IS io.Reader *****"
+			return
+		}
+
+		// multipart or form-data
+		if r.isMultiPart || r.isFormData {
+			body = r.bodyBuf.String()
+			return
+		}
+
+		// request body data
+		if r.Body == nil {
+			return
+		}
+		var prtBodyBytes []byte
+		var err error
+
+		contentType := r.Header.Get(hdrContentTypeKey)
+		kind := kindOf(r.Body)
+		if canJSONMarshal(contentType, kind) {
+			prtBodyBytes, err = json.MarshalIndent(&r.Body, "", "   ")
+		} else if IsXMLType(contentType) && (kind == reflect.Struct) {
+			prtBodyBytes, err = xml.MarshalIndent(&r.Body, "", "   ")
+		} else if b, ok := r.Body.(string); ok {
+			if IsJSONType(contentType) {
+				bodyBytes := []byte(b)
+				out := acquireBuffer()
+				defer releaseBuffer(out)
+				if err = json.Indent(out, bodyBytes, "", "   "); err == nil {
+					prtBodyBytes = out.Bytes()
+				}
+			} else {
+				body = b
+				return
+			}
+		} else if b, ok := r.Body.([]byte); ok {
+			body = base64.StdEncoding.EncodeToString(b)
+		}
+
+		if prtBodyBytes != nil && err == nil {
+			body = string(prtBodyBytes)
+		}
+	}
+
+	return
+}
+
+func (r *Request) selectAddr(addrs []*net.SRV, path string, attempt int) string {
+	if addrs == nil {
+		return path
+	}
+
+	idx := attempt % len(addrs)
+	domain := strings.TrimRight(addrs[idx].Target, ".")
+	path = strings.TrimLeft(path, "/")
+
+	return fmt.Sprintf("%s://%s:%d/%s", r.client.scheme, domain, addrs[idx].Port, path)
+}

vendor/github.com/go-resty/resty/request16.go

@@ -0,0 +1,58 @@
+// +build !go1.7
+
+// Copyright (c) 2015-2018 Jeevanandam M (jeeva@myjeeva.com)
+// 2016 Andrew Grigorev (https://github.com/ei-grad)
+// All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"bytes"
+	"net/http"
+	"net/url"
+	"time"
+)
+
+// Request type is used to compose and send individual request from client
+// go-resty is provide option override client level settings such as
+// Auth Token, Basic Auth credentials, Header, Query Param, Form Data, Error object
+// and also you can add more options for that particular request
+type Request struct {
+	URL        string
+	Method     string
+	Token      string
+	QueryParam url.Values
+	FormData   url.Values
+	Header     http.Header
+	Time       time.Time
+	Body       interface{}
+	Result     interface{}
+	Error      interface{}
+	RawRequest *http.Request
+	SRV        *SRVRecord
+	UserInfo   *User
+
+	isMultiPart         bool
+	isFormData          bool
+	setContentLength    bool
+	isSaveResponse      bool
+	notParseResponse    bool
+	outputFile          string
+	fallbackContentType string
+	pathParams          map[string]string
+	client              *Client
+	bodyBuf             *bytes.Buffer
+	multipartFiles      []*File
+	multipartFields     []*multipartField
+}
+
+func (r *Request) addContextIfAvailable() {
+	// nothing to do for golang<1.7
+}
+
+func (r *Request) isContextCancelledIfAvailable() bool {
+	// just always return false golang<1.7
+	return false
+}

vendor/github.com/go-resty/resty/request17.go

@@ -0,0 +1,75 @@
+// +build go1.7 go1.8
+
+// Copyright (c) 2015-2018 Jeevanandam M (jeeva@myjeeva.com)
+// 2016 Andrew Grigorev (https://github.com/ei-grad)
+// All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"bytes"
+	"context"
+	"net/http"
+	"net/url"
+	"time"
+)
+
+// Request type is used to compose and send individual request from client
+// go-resty is provide option override client level settings such as
+// Auth Token, Basic Auth credentials, Header, Query Param, Form Data, Error object
+// and also you can add more options for that particular request
+type Request struct {
+	URL        string
+	Method     string
+	Token      string
+	QueryParam url.Values
+	FormData   url.Values
+	Header     http.Header
+	Time       time.Time
+	Body       interface{}
+	Result     interface{}
+	Error      interface{}
+	RawRequest *http.Request
+	SRV        *SRVRecord
+	UserInfo   *User
+
+	isMultiPart         bool
+	isFormData          bool
+	setContentLength    bool
+	isSaveResponse      bool
+	notParseResponse    bool
+	outputFile          string
+	fallbackContentType string
+	ctx                 context.Context
+	pathParams          map[string]string
+	client              *Client
+	bodyBuf             *bytes.Buffer
+	multipartFiles      []*File
+	multipartFields     []*multipartField
+}
+
+// SetContext method sets the context.Context for current Request. It allows
+// to interrupt the request execution if ctx.Done() channel is closed.
+// See https://blog.golang.org/context article and the "context" package
+// documentation.
+func (r *Request) SetContext(ctx context.Context) *Request {
+	r.ctx = ctx
+	return r
+}
+
+func (r *Request) addContextIfAvailable() {
+	if r.ctx != nil {
+		r.RawRequest = r.RawRequest.WithContext(r.ctx)
+	}
+}
+
+func (r *Request) isContextCancelledIfAvailable() bool {
+	if r.ctx != nil {
+		if r.ctx.Err() != nil {
+			return true
+		}
+	}
+	return false
+}

vendor/github.com/go-resty/resty/response.go

@@ -0,0 +1,150 @@
+// Copyright (c) 2015-2018 Jeevanandam M (jeeva@myjeeva.com), All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// Response is an object represents executed request and its values.
+type Response struct {
+	Request     *Request
+	RawResponse *http.Response
+
+	body       []byte
+	size       int64
+	receivedAt time.Time
+}
+
+// Body method returns HTTP response as []byte array for the executed request.
+// Note: `Response.Body` might be nil, if `Request.SetOutput` is used.
+func (r *Response) Body() []byte {
+	if r.RawResponse == nil {
+		return []byte{}
+	}
+	return r.body
+}
+
+// Status method returns the HTTP status string for the executed request.
+//	Example: 200 OK
+func (r *Response) Status() string {
+	if r.RawResponse == nil {
+		return ""
+	}
+
+	return r.RawResponse.Status
+}
+
+// StatusCode method returns the HTTP status code for the executed request.
+//	Example: 200
+func (r *Response) StatusCode() int {
+	if r.RawResponse == nil {
+		return 0
+	}
+
+	return r.RawResponse.StatusCode
+}
+
+// Result method returns the response value as an object if it has one
+func (r *Response) Result() interface{} {
+	return r.Request.Result
+}
+
+// Error method returns the error object if it has one
+func (r *Response) Error() interface{} {
+	return r.Request.Error
+}
+
+// Header method returns the response headers
+func (r *Response) Header() http.Header {
+	if r.RawResponse == nil {
+		return http.Header{}
+	}
+
+	return r.RawResponse.Header
+}
+
+// Cookies method to access all the response cookies
+func (r *Response) Cookies() []*http.Cookie {
+	if r.RawResponse == nil {
+		return make([]*http.Cookie, 0)
+	}
+
+	return r.RawResponse.Cookies()
+}
+
+// String method returns the body of the server response as String.
+func (r *Response) String() string {
+	if r.body == nil {
+		return ""
+	}
+
+	return strings.TrimSpace(string(r.body))
+}
+
+// Time method returns the time of HTTP response time that from request we sent and received a request.
+// See `response.ReceivedAt` to know when client recevied response and see `response.Request.Time` to know
+// when client sent a request.
+func (r *Response) Time() time.Duration {
+	return r.receivedAt.Sub(r.Request.Time)
+}
+
+// ReceivedAt method returns when response got recevied from server for the request.
+func (r *Response) ReceivedAt() time.Time {
+	return r.receivedAt
+}
+
+// Size method returns the HTTP response size in bytes. Ya, you can relay on HTTP `Content-Length` header,
+// however it won't be good for chucked transfer/compressed response. Since Resty calculates response size
+// at the client end. You will get actual size of the http response.
+func (r *Response) Size() int64 {
+	return r.size
+}
+
+// RawBody method exposes the HTTP raw response body. Use this method in-conjunction with `SetDoNotParseResponse`
+// option otherwise you get an error as `read err: http: read on closed response body`.
+//
+// Do not forget to close the body, otherwise you might get into connection leaks, no connection reuse.
+// Basically you have taken over the control of response parsing from `Resty`.
+func (r *Response) RawBody() io.ReadCloser {
+	if r.RawResponse == nil {
+		return nil
+	}
+	return r.RawResponse.Body
+}
+
+// IsSuccess method returns true if HTTP status code >= 200 and <= 299 otherwise false.
+func (r *Response) IsSuccess() bool {
+	return r.StatusCode() > 199 && r.StatusCode() < 300
+}
+
+// IsError method returns true if HTTP status code >= 400 otherwise false.
+func (r *Response) IsError() bool {
+	return r.StatusCode() > 399
+}
+
+func (r *Response) fmtBodyString(sl int64) string {
+	if r.body != nil {
+		if int64(len(r.body)) > sl {
+			return fmt.Sprintf("***** RESPONSE TOO LARGE (size - %d) *****", len(r.body))
+		}
+		ct := r.Header().Get(hdrContentTypeKey)
+		if IsJSONType(ct) {
+			out := acquireBuffer()
+			defer releaseBuffer(out)
+			if err := json.Indent(out, r.body, "", "   "); err == nil {
+				return out.String()
+			}
+		}
+		return r.String()
+	}
+
+	return "***** NO CONTENT *****"
+}

vendor/github.com/go-resty/resty/resty.go

@@ -0,0 +1,9 @@
+// Copyright (c) 2015-2018 Jeevanandam M (jeeva@myjeeva.com), All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+// Package resty provides simple HTTP and REST client for Go inspired by Ruby rest-client.
+package resty
+
+// Version # of resty
+const Version = "1.8.0"

vendor/github.com/go-resty/resty/retry.go

@@ -0,0 +1,114 @@
+// Copyright (c) 2015-2018 Jeevanandam M (jeeva@myjeeva.com), All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"math"
+	"math/rand"
+	"time"
+)
+
+const (
+	defaultMaxRetries  = 3
+	defaultWaitTime    = time.Duration(100) * time.Millisecond
+	defaultMaxWaitTime = time.Duration(2000) * time.Millisecond
+)
+
+type (
+	// Option is to create convenient retry options like wait time, max retries, etc.
+	Option func(*Options)
+
+	// RetryConditionFunc type is for retry condition function
+	RetryConditionFunc func(*Response) (bool, error)
+
+	// Options to hold go-resty retry values
+	Options struct {
+		maxRetries      int
+		waitTime        time.Duration
+		maxWaitTime     time.Duration
+		retryConditions []RetryConditionFunc
+	}
+)
+
+// Retries sets the max number of retries
+func Retries(value int) Option {
+	return func(o *Options) {
+		o.maxRetries = value
+	}
+}
+
+// WaitTime sets the default wait time to sleep between requests
+func WaitTime(value time.Duration) Option {
+	return func(o *Options) {
+		o.waitTime = value
+	}
+}
+
+// MaxWaitTime sets the max wait time to sleep between requests
+func MaxWaitTime(value time.Duration) Option {
+	return func(o *Options) {
+		o.maxWaitTime = value
+	}
+}
+
+// RetryConditions sets the conditions that will be checked for retry.
+func RetryConditions(conditions []RetryConditionFunc) Option {
+	return func(o *Options) {
+		o.retryConditions = conditions
+	}
+}
+
+// Backoff retries with increasing timeout duration up until X amount of retries
+// (Default is 3 attempts, Override with option Retries(n))
+func Backoff(operation func() (*Response, error), options ...Option) error {
+	// Defaults
+	opts := Options{
+		maxRetries:      defaultMaxRetries,
+		waitTime:        defaultWaitTime,
+		maxWaitTime:     defaultMaxWaitTime,
+		retryConditions: []RetryConditionFunc{},
+	}
+
+	for _, o := range options {
+		o(&opts)
+	}
+
+	var (
+		resp *Response
+		err  error
+	)
+	base := float64(opts.waitTime)        // Time to wait between each attempt
+	capLevel := float64(opts.maxWaitTime) // Maximum amount of wait time for the retry
+	for attempt := 0; attempt < opts.maxRetries; attempt++ {
+		resp, err = operation()
+
+		var needsRetry bool
+		var conditionErr error
+		for _, condition := range opts.retryConditions {
+			needsRetry, conditionErr = condition(resp)
+			if needsRetry || conditionErr != nil {
+				break
+			}
+		}
+
+		// If the operation returned no error, there was no condition satisfied and
+		// there was no error caused by the conditional functions.
+		if err == nil && !needsRetry && conditionErr == nil {
+			return nil
+		}
+		// Adding capped exponential backup with jitter
+		// See the following article...
+		// http://www.awsarchitectureblog.com/2015/03/backoff.html
+		temp := math.Min(capLevel, base*math.Exp2(float64(attempt)))
+		sleepDuration := time.Duration(int(temp/2) + rand.Intn(int(temp/2)))
+
+		if sleepDuration < opts.waitTime {
+			sleepDuration = opts.waitTime
+		}
+		time.Sleep(sleepDuration)
+	}
+
+	return err
+}

vendor/github.com/go-resty/resty/util.go

@@ -0,0 +1,243 @@
+// Copyright (c) 2015-2018 Jeevanandam M (jeeva@myjeeva.com), All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"bytes"
+	"encoding/json"
+	"encoding/xml"
+	"fmt"
+	"io"
+	"log"
+	"mime/multipart"
+	"net/http"
+	"net/textproto"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"sort"
+	"strings"
+)
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Package Helper methods
+//___________________________________
+
+// IsStringEmpty method tells whether given string is empty or not
+func IsStringEmpty(str string) bool {
+	return len(strings.TrimSpace(str)) == 0
+}
+
+// DetectContentType method is used to figure out `Request.Body` content type for request header
+func DetectContentType(body interface{}) string {
+	contentType := plainTextType
+	kind := kindOf(body)
+	switch kind {
+	case reflect.Struct, reflect.Map:
+		contentType = jsonContentType
+	case reflect.String:
+		contentType = plainTextType
+	default:
+		if b, ok := body.([]byte); ok {
+			contentType = http.DetectContentType(b)
+		} else if kind == reflect.Slice {
+			contentType = jsonContentType
+		}
+	}
+
+	return contentType
+}
+
+// IsJSONType method is to check JSON content type or not
+func IsJSONType(ct string) bool {
+	return jsonCheck.MatchString(ct)
+}
+
+// IsXMLType method is to check XML content type or not
+func IsXMLType(ct string) bool {
+	return xmlCheck.MatchString(ct)
+}
+
+// Unmarshal content into object from JSON or XML
+// Deprecated: kept for backward compatibility
+func Unmarshal(ct string, b []byte, d interface{}) (err error) {
+	if IsJSONType(ct) {
+		err = json.Unmarshal(b, d)
+	} else if IsXMLType(ct) {
+		err = xml.Unmarshal(b, d)
+	}
+
+	return
+}
+
+// Unmarshalc content into object from JSON or XML
+func Unmarshalc(c *Client, ct string, b []byte, d interface{}) (err error) {
+	if IsJSONType(ct) {
+		err = c.JSONUnmarshal(b, d)
+	} else if IsXMLType(ct) {
+		err = xml.Unmarshal(b, d)
+	}
+
+	return
+}
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Package Unexported methods
+//___________________________________
+
+func firstNonEmpty(v ...string) string {
+	for _, s := range v {
+		if !IsStringEmpty(s) {
+			return s
+		}
+	}
+	return ""
+}
+
+func getLogger(w io.Writer) *log.Logger {
+	return log.New(w, "RESTY ", log.LstdFlags)
+}
+
+var quoteEscaper = strings.NewReplacer("\\", "\\\\", `"`, "\\\"")
+
+func escapeQuotes(s string) string {
+	return quoteEscaper.Replace(s)
+}
+
+func createMultipartHeader(param, fileName, contentType string) textproto.MIMEHeader {
+	hdr := make(textproto.MIMEHeader)
+	hdr.Set("Content-Disposition", fmt.Sprintf(`form-data; name="%s"; filename="%s"`,
+		escapeQuotes(param), escapeQuotes(fileName)))
+	hdr.Set("Content-Type", contentType)
+	return hdr
+}
+
+func addMultipartFormField(w *multipart.Writer, mf *multipartField) error {
+	partWriter, err := w.CreatePart(createMultipartHeader(mf.Param, mf.FileName, mf.ContentType))
+	if err != nil {
+		return err
+	}
+
+	_, err = io.Copy(partWriter, mf.Reader)
+	return err
+}
+
+func writeMultipartFormFile(w *multipart.Writer, fieldName, fileName string, r io.Reader) error {
+	// Auto detect actual multipart content type
+	cbuf := make([]byte, 512)
+	size, err := r.Read(cbuf)
+	if err != nil {
+		return err
+	}
+
+	partWriter, err := w.CreatePart(createMultipartHeader(fieldName, fileName, http.DetectContentType(cbuf)))
+	if err != nil {
+		return err
+	}
+
+	if _, err = partWriter.Write(cbuf[:size]); err != nil {
+		return err
+	}
+
+	_, err = io.Copy(partWriter, r)
+	return err
+}
+
+func addFile(w *multipart.Writer, fieldName, path string) error {
+	file, err := os.Open(path)
+	if err != nil {
+		return err
+	}
+	defer closeq(file)
+	return writeMultipartFormFile(w, fieldName, filepath.Base(path), file)
+}
+
+func addFileReader(w *multipart.Writer, f *File) error {
+	return writeMultipartFormFile(w, f.ParamName, f.Name, f.Reader)
+}
+
+func getPointer(v interface{}) interface{} {
+	vv := valueOf(v)
+	if vv.Kind() == reflect.Ptr {
+		return v
+	}
+	return reflect.New(vv.Type()).Interface()
+}
+
+func isPayloadSupported(m string, allowMethodGet bool) bool {
+	return !(m == MethodHead || m == MethodOptions || (m == MethodGet && !allowMethodGet))
+}
+
+func typeOf(i interface{}) reflect.Type {
+	return indirect(valueOf(i)).Type()
+}
+
+func valueOf(i interface{}) reflect.Value {
+	return reflect.ValueOf(i)
+}
+
+func indirect(v reflect.Value) reflect.Value {
+	return reflect.Indirect(v)
+}
+
+func kindOf(v interface{}) reflect.Kind {
+	return typeOf(v).Kind()
+}
+
+func createDirectory(dir string) (err error) {
+	if _, err = os.Stat(dir); err != nil {
+		if os.IsNotExist(err) {
+			if err = os.MkdirAll(dir, 0755); err != nil {
+				return
+			}
+		}
+	}
+	return
+}
+
+func canJSONMarshal(contentType string, kind reflect.Kind) bool {
+	return IsJSONType(contentType) && (kind == reflect.Struct || kind == reflect.Map)
+}
+
+func functionName(i interface{}) string {
+	return runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name()
+}
+
+func acquireBuffer() *bytes.Buffer {
+	return bufPool.Get().(*bytes.Buffer)
+}
+
+func releaseBuffer(buf *bytes.Buffer) {
+	if buf != nil {
+		buf.Reset()
+		bufPool.Put(buf)
+	}
+}
+
+func closeq(v interface{}) {
+	if c, ok := v.(io.Closer); ok {
+		sliently(c.Close())
+	}
+}
+
+func sliently(_ ...interface{}) {}
+
+func composeHeaders(hdrs http.Header) string {
+	var str []string
+	for _, k := range sortHeaderKeys(hdrs) {
+		str = append(str, fmt.Sprintf("%25s: %s", k, strings.Join(hdrs[k], ", ")))
+	}
+	return strings.Join(str, "\n")
+}
+
+func sortHeaderKeys(hdrs http.Header) []string {
+	var keys []string
+	for key := range hdrs {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	return keys
+}

vendor/github.com/linode/linodego/LICENSE

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

vendor/github.com/linode/linodego/account.go

@@ -0,0 +1,44 @@
+package linodego
+
+import "context"
+
+// Account associated with the token in use
+type Account struct {
+	FirstName  string      `json:"first_name"`
+	LastName   string      `json:"last_name"`
+	Email      string      `json:"email"`
+	Company    string      `json:"company"`
+	Address1   string      `json:"address1"`
+	Address2   string      `json:"address2"`
+	Balance    float32     `json:"balance"`
+	City       string      `json:"city"`
+	State      string      `json:"state"`
+	Zip        string      `json:"zip"`
+	Country    string      `json:"country"`
+	TaxID      string      `json:"tax_id"`
+	CreditCard *CreditCard `json:"credit_card"`
+}
+
+// CreditCard information associated with the Account.
+type CreditCard struct {
+	LastFour string `json:"last_four"`
+	Expiry   string `json:"expiry"`
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (v *Account) fixDates() *Account {
+	return v
+}
+
+// GetAccount gets the contact and billing information related to the Account
+func (c *Client) GetAccount(ctx context.Context) (*Account, error) {
+	e, err := c.Account.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&Account{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Account).fixDates(), nil
+}

vendor/github.com/linode/linodego/account_events.go

@@ -0,0 +1,277 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// Event represents an action taken on the Account.
+type Event struct {
+	CreatedStr string `json:"created"`
+
+	// The unique ID of this Event.
+	ID int `json:"id"`
+
+	// Current status of the Event, Enum: "failed" "finished" "notification" "scheduled" "started"
+	Status EventStatus `json:"status"`
+
+	// The action that caused this Event. New actions may be added in the future.
+	Action EventAction `json:"action"`
+
+	// A percentage estimating the amount of time remaining for an Event. Returns null for notification events.
+	PercentComplete int `json:"percent_complete"`
+
+	// The rate of completion of the Event. Only some Events will return rate; for example, migration and resize Events.
+	Rate *string `json:"rate"`
+
+	// If this Event has been read.
+	Read bool `json:"read"`
+
+	// If this Event has been seen.
+	Seen bool `json:"seen"`
+
+	// The estimated time remaining until the completion of this Event. This value is only returned for in-progress events.
+	TimeRemainingMsg json.RawMessage `json:"time_remaining"`
+	TimeRemaining    *int            `json:"-"`
+
+	// The username of the User who caused the Event.
+	Username string `json:"username"`
+
+	// Detailed information about the Event's entity, including ID, type, label, and URL used to access it.
+	Entity *EventEntity `json:"entity"`
+
+	// When this Event was created.
+	Created *time.Time `json:"-"`
+}
+
+// EventAction constants start with Action and include all known Linode API Event Actions.
+type EventAction string
+
+// EventAction constants represent the actions that cause an Event. New actions may be added in the future.
+const (
+	ActionBackupsEnable            EventAction = "backups_enable"
+	ActionBackupsCancel            EventAction = "backups_cancel"
+	ActionBackupsRestore           EventAction = "backups_restore"
+	ActionCommunityQuestionReply   EventAction = "community_question_reply"
+	ActionCreateCardUpdated        EventAction = "credit_card_updated"
+	ActionDiskCreate               EventAction = "disk_create"
+	ActionDiskDelete               EventAction = "disk_delete"
+	ActionDiskDuplicate            EventAction = "disk_duplicate"
+	ActionDiskImagize              EventAction = "disk_imagize"
+	ActionDiskResize               EventAction = "disk_resize"
+	ActionDNSRecordCreate          EventAction = "dns_record_create"
+	ActionDNSRecordDelete          EventAction = "dns_record_delete"
+	ActionDNSZoneCreate            EventAction = "dns_zone_create"
+	ActionDNSZoneDelete            EventAction = "dns_zone_delete"
+	ActionImageDelete              EventAction = "image_delete"
+	ActionLinodeAddIP              EventAction = "linode_addip"
+	ActionLinodeBoot               EventAction = "linode_boot"
+	ActionLinodeClone              EventAction = "linode_clone"
+	ActionLinodeCreate             EventAction = "linode_create"
+	ActionLinodeDelete             EventAction = "linode_delete"
+	ActionLinodeDeleteIP           EventAction = "linode_deleteip"
+	ActionLinodeMigrate            EventAction = "linode_migrate"
+	ActionLinodeMutate             EventAction = "linode_mutate"
+	ActionLinodeReboot             EventAction = "linode_reboot"
+	ActionLinodeRebuild            EventAction = "linode_rebuild"
+	ActionLinodeResize             EventAction = "linode_resize"
+	ActionLinodeShutdown           EventAction = "linode_shutdown"
+	ActionLinodeSnapshot           EventAction = "linode_snapshot"
+	ActionLongviewClientCreate     EventAction = "longviewclient_create"
+	ActionLongviewClientDelete     EventAction = "longviewclient_delete"
+	ActionManagedDisabled          EventAction = "managed_disabled"
+	ActionManagedEnabled           EventAction = "managed_enabled"
+	ActionManagedServiceCreate     EventAction = "managed_service_create"
+	ActionManagedServiceDelete     EventAction = "managed_service_delete"
+	ActionNodebalancerCreate       EventAction = "nodebalancer_create"
+	ActionNodebalancerDelete       EventAction = "nodebalancer_delete"
+	ActionNodebalancerConfigCreate EventAction = "nodebalancer_config_create"
+	ActionNodebalancerConfigDelete EventAction = "nodebalancer_config_delete"
+	ActionPasswordReset            EventAction = "password_reset"
+	ActionPaymentSubmitted         EventAction = "payment_submitted"
+	ActionStackScriptCreate        EventAction = "stackscript_create"
+	ActionStackScriptDelete        EventAction = "stackscript_delete"
+	ActionStackScriptPublicize     EventAction = "stackscript_publicize"
+	ActionStackScriptRevise        EventAction = "stackscript_revise"
+	ActionTFADisabled              EventAction = "tfa_disabled"
+	ActionTFAEnabled               EventAction = "tfa_enabled"
+	ActionTicketAttachmentUpload   EventAction = "ticket_attachment_upload"
+	ActionTicketCreate             EventAction = "ticket_create"
+	ActionTicketReply              EventAction = "ticket_reply"
+	ActionVolumeAttach             EventAction = "volume_attach"
+	ActionVolumeClone              EventAction = "volume_clone"
+	ActionVolumeCreate             EventAction = "volume_create"
+	ActionVolumeDelte              EventAction = "volume_delete"
+	ActionVolumeDetach             EventAction = "volume_detach"
+	ActionVolumeResize             EventAction = "volume_resize"
+)
+
+// EntityType constants start with Entity and include Linode API Event Entity Types
+type EntityType string
+
+// EntityType contants are the entities an Event can be related to
+const (
+	EntityLinode EntityType = "linode"
+	EntityDisk   EntityType = "disk"
+)
+
+// EventStatus constants start with Event and include Linode API Event Status values
+type EventStatus string
+
+// EventStatus constants reflect the current status of an Event
+const (
+	EventFailed       EventStatus = "failed"
+	EventFinished     EventStatus = "finished"
+	EventNotification EventStatus = "notification"
+	EventScheduled    EventStatus = "scheduled"
+	EventStarted      EventStatus = "started"
+)
+
+// EventEntity provides detailed information about the Event's
+// associated entity, including ID, Type, Label, and a URL that
+// can be used to access it.
+type EventEntity struct {
+	// ID may be a string or int, it depends on the EntityType
+	ID    interface{} `json:"id"`
+	Label string      `json:"label"`
+	Type  EntityType  `json:"type"`
+	URL   string      `json:"url"`
+}
+
+// EventsPagedResponse represents a paginated Events API response
+type EventsPagedResponse struct {
+	*PageOptions
+	Data []Event `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Event
+func (EventsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Events.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// endpointWithID gets the endpoint URL for a specific Event
+func (e Event) endpointWithID(c *Client) string {
+	endpoint, err := c.Events.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	endpoint = fmt.Sprintf("%s/%d", endpoint, e.ID)
+	return endpoint
+}
+
+// appendData appends Events when processing paginated Event responses
+func (resp *EventsPagedResponse) appendData(r *EventsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListEvents gets a collection of Event objects representing actions taken
+// on the Account. The Events returned depend on the token grants and the grants
+// of the associated user.
+func (c *Client) ListEvents(ctx context.Context, opts *ListOptions) ([]Event, error) {
+	response := EventsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// GetEvent gets the Event with the Event ID
+func (c *Client) GetEvent(ctx context.Context, id int) (*Event, error) {
+	e, err := c.Events.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := c.R(ctx).SetResult(&Event{}).Get(e)
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Event).fixDates(), nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (e *Event) fixDates() *Event {
+	e.Created, _ = parseDates(e.CreatedStr)
+	e.TimeRemaining = unmarshalTimeRemaining(e.TimeRemainingMsg)
+	return e
+}
+
+// MarkEventRead marks a single Event as read.
+func (c *Client) MarkEventRead(ctx context.Context, event *Event) error {
+	e := event.endpointWithID(c)
+	e = fmt.Sprintf("%s/read", e)
+
+	_, err := coupleAPIErrors(c.R(ctx).Post(e))
+
+	return err
+}
+
+// MarkEventsSeen marks all Events up to and including this Event by ID as seen.
+func (c *Client) MarkEventsSeen(ctx context.Context, event *Event) error {
+	e := event.endpointWithID(c)
+	e = fmt.Sprintf("%s/seen", e)
+
+	_, err := coupleAPIErrors(c.R(ctx).Post(e))
+
+	return err
+}
+
+func unmarshalTimeRemaining(m json.RawMessage) *int {
+	jsonBytes, err := m.MarshalJSON()
+	if err != nil {
+		panic(jsonBytes)
+	}
+
+	if len(jsonBytes) == 4 && string(jsonBytes) == "null" {
+		return nil
+	}
+
+	var timeStr string
+	if err := json.Unmarshal(jsonBytes, &timeStr); err == nil && len(timeStr) > 0 {
+		if dur, err := durationToSeconds(timeStr); err != nil {
+			panic(err)
+		} else {
+			return &dur
+		}
+	} else {
+		var intPtr int
+		if err := json.Unmarshal(jsonBytes, &intPtr); err == nil {
+			return &intPtr
+		}
+	}
+
+	log.Println("[WARN] Unexpected unmarshalTimeRemaining value: ", jsonBytes)
+	return nil
+}
+
+// durationToSeconds takes a hh:mm:ss string and returns the number of seconds
+func durationToSeconds(s string) (int, error) {
+	multipliers := [3]int{60 * 60, 60, 1}
+	segs := strings.Split(s, ":")
+	if len(segs) > len(multipliers) {
+		return 0, fmt.Errorf("too many ':' separators in time duration: %s", s)
+	}
+	var d int
+	l := len(segs)
+	for i := 0; i < l; i++ {
+		m, err := strconv.Atoi(segs[i])
+		if err != nil {
+			return 0, err
+		}
+		d += m * multipliers[i+len(multipliers)-l]
+	}
+	return d, nil
+}

vendor/github.com/linode/linodego/account_invoices.go

@@ -0,0 +1,125 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+// Invoice structs reflect an invoice for billable activity on the account.
+type Invoice struct {
+	DateStr string `json:"date"`
+
+	ID    int        `json:"id"`
+	Label string     `json:"label"`
+	Total float32    `json:"total"`
+	Date  *time.Time `json:"-"`
+}
+
+// InvoiceItem structs reflect an single billable activity associate with an Invoice
+type InvoiceItem struct {
+	FromStr string `json:"from"`
+	ToStr   string `json:"to"`
+
+	Label     string     `json:"label"`
+	Type      string     `json:"type"`
+	UnitPrice int        `json:"unitprice"`
+	Quantity  int        `json:"quantity"`
+	Amount    float32    `json:"amount"`
+	From      *time.Time `json:"-"`
+	To        *time.Time `json:"-"`
+}
+
+// InvoicesPagedResponse represents a paginated Invoice API response
+type InvoicesPagedResponse struct {
+	*PageOptions
+	Data []Invoice `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Invoice
+func (InvoicesPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Invoices.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends Invoices when processing paginated Invoice responses
+func (resp *InvoicesPagedResponse) appendData(r *InvoicesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListInvoices gets a paginated list of Invoices against the Account
+func (c *Client) ListInvoices(ctx context.Context, opts *ListOptions) ([]Invoice, error) {
+	response := InvoicesPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (v *Invoice) fixDates() *Invoice {
+	v.Date, _ = parseDates(v.DateStr)
+	return v
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (v *InvoiceItem) fixDates() *InvoiceItem {
+	v.From, _ = parseDates(v.FromStr)
+	v.To, _ = parseDates(v.ToStr)
+	return v
+}
+
+// GetInvoice gets the a single Invoice matching the provided ID
+func (c *Client) GetInvoice(ctx context.Context, id int) (*Invoice, error) {
+	e, err := c.Invoices.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&Invoice{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Invoice).fixDates(), nil
+}
+
+// InvoiceItemsPagedResponse represents a paginated Invoice Item API response
+type InvoiceItemsPagedResponse struct {
+	*PageOptions
+	Data []InvoiceItem `json:"data"`
+}
+
+// endpointWithID gets the endpoint URL for InvoiceItems associated with a specific Invoice
+func (InvoiceItemsPagedResponse) endpointWithID(c *Client, id int) string {
+	endpoint, err := c.InvoiceItems.endpointWithID(id)
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends InvoiceItems when processing paginated Invoice Item responses
+func (resp *InvoiceItemsPagedResponse) appendData(r *InvoiceItemsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListInvoiceItems gets the invoice items associated with a specific Invoice
+func (c *Client) ListInvoiceItems(ctx context.Context, id int, opts *ListOptions) ([]InvoiceItem, error) {
+	response := InvoiceItemsPagedResponse{}
+	err := c.listHelperWithID(ctx, &response, id, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}

vendor/github.com/linode/linodego/account_notifications.go

@@ -0,0 +1,73 @@
+package linodego
+
+import (
+	"context"
+	"time"
+)
+
+// Notification represents a notification on an Account
+type Notification struct {
+	UntilStr string `json:"until"`
+	WhenStr  string `json:"when"`
+
+	Label    string              `json:"label"`
+	Message  string              `json:"message"`
+	Type     string              `json:"type"`
+	Severity string              `json:"severity"`
+	Entity   *NotificationEntity `json:"entity"`
+	Until    *time.Time          `json:"-"`
+	When     *time.Time          `json:"-"`
+}
+
+// NotificationEntity adds detailed information about the Notification.
+// This could refer to the ticket that triggered the notification, for example.
+type NotificationEntity struct {
+	ID    int    `json:"id"`
+	Label string `json:"label"`
+	Type  string `json:"type"`
+	URL   string `json:"url"`
+}
+
+// NotificationsPagedResponse represents a paginated Notifications API response
+type NotificationsPagedResponse struct {
+	*PageOptions
+	Data []Notification `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Notification
+func (NotificationsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Notifications.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends Notifications when processing paginated Notification responses
+func (resp *NotificationsPagedResponse) appendData(r *NotificationsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListNotifications gets a collection of Notification objects representing important,
+// often time-sensitive items related to the Account. An account cannot interact directly with
+// Notifications, and a Notification will disappear when the circumstances causing it
+// have been resolved. For example, if the account has an important Ticket open, a response
+// to the Ticket will dismiss the Notification.
+func (c *Client) ListNotifications(ctx context.Context, opts *ListOptions) ([]Notification, error) {
+	response := NotificationsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (v *Notification) fixDates() *Notification {
+	v.Until, _ = parseDates(v.UntilStr)
+	v.When, _ = parseDates(v.WhenStr)
+	return v
+}

vendor/github.com/linode/linodego/client.go

@@ -0,0 +1,201 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"strconv"
+
+	"github.com/go-resty/resty"
+)
+
+const (
+	// APIHost Linode API hostname
+	APIHost = "api.linode.com"
+	// APIVersion Linode API version
+	APIVersion = "v4"
+	// APIProto connect to API with http(s)
+	APIProto = "https"
+	// Version of linodego
+	Version = "0.5.1"
+	// APIEnvVar environment var to check for API token
+	APIEnvVar = "LINODE_TOKEN"
+	// APISecondsPerPoll how frequently to poll for new Events
+	APISecondsPerPoll = 10
+)
+
+// DefaultUserAgent is the default User-Agent sent in HTTP request headers
+const DefaultUserAgent = "linodego " + Version + " https://github.com/linode/linodego"
+
+var envDebug = false
+
+// Client is a wrapper around the Resty client
+type Client struct {
+	resty     *resty.Client
+	userAgent string
+	resources map[string]*Resource
+	debug     bool
+
+	Images                *Resource
+	InstanceDisks         *Resource
+	InstanceConfigs       *Resource
+	InstanceSnapshots     *Resource
+	InstanceIPs           *Resource
+	InstanceVolumes       *Resource
+	Instances             *Resource
+	IPAddresses           *Resource
+	IPv6Pools             *Resource
+	IPv6Ranges            *Resource
+	Regions               *Resource
+	StackScripts          *Resource
+	Volumes               *Resource
+	Kernels               *Resource
+	Types                 *Resource
+	Domains               *Resource
+	DomainRecords         *Resource
+	Longview              *Resource
+	LongviewClients       *Resource
+	LongviewSubscriptions *Resource
+	NodeBalancers         *Resource
+	NodeBalancerConfigs   *Resource
+	NodeBalancerNodes     *Resource
+	SSHKeys               *Resource
+	Tickets               *Resource
+	Account               *Resource
+	Invoices              *Resource
+	InvoiceItems          *Resource
+	Events                *Resource
+	Notifications         *Resource
+	Profile               *Resource
+	Managed               *Resource
+}
+
+func init() {
+	// Wether or not we will enable Resty debugging output
+	if apiDebug, ok := os.LookupEnv("LINODE_DEBUG"); ok {
+		if parsed, err := strconv.ParseBool(apiDebug); err == nil {
+			envDebug = parsed
+			log.Println("[INFO] LINODE_DEBUG being set to", envDebug)
+		} else {
+			log.Println("[WARN] LINODE_DEBUG should be an integer, 0 or 1")
+		}
+	}
+
+}
+
+// SetUserAgent sets a custom user-agent for HTTP requests
+func (c *Client) SetUserAgent(ua string) *Client {
+	c.userAgent = ua
+	c.resty.SetHeader("User-Agent", c.userAgent)
+
+	return c
+}
+
+// R wraps resty's R method
+func (c *Client) R(ctx context.Context) *resty.Request {
+	return c.resty.R().
+		ExpectContentType("application/json").
+		SetHeader("Content-Type", "application/json").
+		SetContext(ctx).
+		SetError(APIError{})
+}
+
+// SetDebug sets the debug on resty's client
+func (c *Client) SetDebug(debug bool) *Client {
+	c.debug = debug
+	c.resty.SetDebug(debug)
+	return c
+}
+
+// SetBaseURL sets the base URL of the Linode v4 API (https://api.linode.com/v4)
+func (c *Client) SetBaseURL(url string) *Client {
+	c.resty.SetHostURL(url)
+	return c
+}
+
+// Resource looks up a resource by name
+func (c Client) Resource(resourceName string) *Resource {
+	selectedResource, ok := c.resources[resourceName]
+	if !ok {
+		log.Fatalf("Could not find resource named '%s', exiting.", resourceName)
+	}
+	return selectedResource
+}
+
+// NewClient factory to create new Client struct
+func NewClient(hc *http.Client) (client Client) {
+	restyClient := resty.NewWithClient(hc)
+	client.resty = restyClient
+	client.SetUserAgent(DefaultUserAgent)
+	client.SetBaseURL(fmt.Sprintf("%s://%s/%s", APIProto, APIHost, APIVersion))
+
+	resources := map[string]*Resource{
+		stackscriptsName:          NewResource(&client, stackscriptsName, stackscriptsEndpoint, false, Stackscript{}, StackscriptsPagedResponse{}),
+		imagesName:                NewResource(&client, imagesName, imagesEndpoint, false, Image{}, ImagesPagedResponse{}),
+		instancesName:             NewResource(&client, instancesName, instancesEndpoint, false, Instance{}, InstancesPagedResponse{}),
+		instanceDisksName:         NewResource(&client, instanceDisksName, instanceDisksEndpoint, true, InstanceDisk{}, InstanceDisksPagedResponse{}),
+		instanceConfigsName:       NewResource(&client, instanceConfigsName, instanceConfigsEndpoint, true, InstanceConfig{}, InstanceConfigsPagedResponse{}),
+		instanceSnapshotsName:     NewResource(&client, instanceSnapshotsName, instanceSnapshotsEndpoint, true, InstanceSnapshot{}, nil),
+		instanceIPsName:           NewResource(&client, instanceIPsName, instanceIPsEndpoint, true, InstanceIP{}, nil),                           // really?
+		instanceVolumesName:       NewResource(&client, instanceVolumesName, instanceVolumesEndpoint, true, nil, InstanceVolumesPagedResponse{}), // really?
+		ipaddressesName:           NewResource(&client, ipaddressesName, ipaddressesEndpoint, false, nil, IPAddressesPagedResponse{}),            // really?
+		ipv6poolsName:             NewResource(&client, ipv6poolsName, ipv6poolsEndpoint, false, nil, IPv6PoolsPagedResponse{}),                  // really?
+		ipv6rangesName:            NewResource(&client, ipv6rangesName, ipv6rangesEndpoint, false, IPv6Range{}, IPv6RangesPagedResponse{}),
+		regionsName:               NewResource(&client, regionsName, regionsEndpoint, false, Region{}, RegionsPagedResponse{}),
+		volumesName:               NewResource(&client, volumesName, volumesEndpoint, false, Volume{}, VolumesPagedResponse{}),
+		kernelsName:               NewResource(&client, kernelsName, kernelsEndpoint, false, LinodeKernel{}, LinodeKernelsPagedResponse{}),
+		typesName:                 NewResource(&client, typesName, typesEndpoint, false, LinodeType{}, LinodeTypesPagedResponse{}),
+		domainsName:               NewResource(&client, domainsName, domainsEndpoint, false, Domain{}, DomainsPagedResponse{}),
+		domainRecordsName:         NewResource(&client, domainRecordsName, domainRecordsEndpoint, true, DomainRecord{}, DomainRecordsPagedResponse{}),
+		longviewName:              NewResource(&client, longviewName, longviewEndpoint, false, nil, nil), // really?
+		longviewclientsName:       NewResource(&client, longviewclientsName, longviewclientsEndpoint, false, LongviewClient{}, LongviewClientsPagedResponse{}),
+		longviewsubscriptionsName: NewResource(&client, longviewsubscriptionsName, longviewsubscriptionsEndpoint, false, LongviewSubscription{}, LongviewSubscriptionsPagedResponse{}),
+		nodebalancersName:         NewResource(&client, nodebalancersName, nodebalancersEndpoint, false, NodeBalancer{}, NodeBalancerConfigsPagedResponse{}),
+		nodebalancerconfigsName:   NewResource(&client, nodebalancerconfigsName, nodebalancerconfigsEndpoint, true, NodeBalancerConfig{}, NodeBalancerConfigsPagedResponse{}),
+		nodebalancernodesName:     NewResource(&client, nodebalancernodesName, nodebalancernodesEndpoint, true, NodeBalancerNode{}, NodeBalancerNodesPagedResponse{}),
+		sshkeysName:               NewResource(&client, sshkeysName, sshkeysEndpoint, false, SSHKey{}, SSHKeysPagedResponse{}),
+		ticketsName:               NewResource(&client, ticketsName, ticketsEndpoint, false, Ticket{}, TicketsPagedResponse{}),
+		accountName:               NewResource(&client, accountName, accountEndpoint, false, Account{}, nil), // really?
+		eventsName:                NewResource(&client, eventsName, eventsEndpoint, false, Event{}, EventsPagedResponse{}),
+		invoicesName:              NewResource(&client, invoicesName, invoicesEndpoint, false, Invoice{}, InvoicesPagedResponse{}),
+		invoiceItemsName:          NewResource(&client, invoiceItemsName, invoiceItemsEndpoint, true, InvoiceItem{}, InvoiceItemsPagedResponse{}),
+		profileName:               NewResource(&client, profileName, profileEndpoint, false, nil, nil), // really?
+		managedName:               NewResource(&client, managedName, managedEndpoint, false, nil, nil), // really?
+	}
+
+	client.resources = resources
+
+	client.SetDebug(envDebug)
+	client.Images = resources[imagesName]
+	client.StackScripts = resources[stackscriptsName]
+	client.Instances = resources[instancesName]
+	client.Regions = resources[regionsName]
+	client.InstanceDisks = resources[instanceDisksName]
+	client.InstanceConfigs = resources[instanceConfigsName]
+	client.InstanceSnapshots = resources[instanceSnapshotsName]
+	client.InstanceIPs = resources[instanceIPsName]
+	client.InstanceVolumes = resources[instanceVolumesName]
+	client.IPAddresses = resources[ipaddressesName]
+	client.IPv6Pools = resources[ipv6poolsName]
+	client.IPv6Ranges = resources[ipv6rangesName]
+	client.Volumes = resources[volumesName]
+	client.Kernels = resources[kernelsName]
+	client.Types = resources[typesName]
+	client.Domains = resources[domainsName]
+	client.DomainRecords = resources[domainRecordsName]
+	client.Longview = resources[longviewName]
+	client.LongviewSubscriptions = resources[longviewsubscriptionsName]
+	client.NodeBalancers = resources[nodebalancersName]
+	client.NodeBalancerConfigs = resources[nodebalancerconfigsName]
+	client.NodeBalancerNodes = resources[nodebalancernodesName]
+	client.SSHKeys = resources[sshkeysName]
+	client.Tickets = resources[ticketsName]
+	client.Account = resources[accountName]
+	client.Events = resources[eventsName]
+	client.Invoices = resources[invoicesName]
+	client.Profile = resources[profileName]
+	client.Managed = resources[managedName]
+	return
+}

vendor/github.com/linode/linodego/domain_records.go

@@ -0,0 +1,211 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// DomainRecord represents a DomainRecord object
+type DomainRecord struct {
+	ID       int              `json:"id"`
+	Type     DomainRecordType `json:"type"`
+	Name     string           `json:"name"`
+	Target   string           `json:"target"`
+	Priority int              `json:"priority"`
+	Weight   int              `json:"weight"`
+	Port     int              `json:"port"`
+	Service  *string          `json:"service"`
+	Protocol *string          `json:"protocol"`
+	TTLSec   int              `json:"ttl_sec"`
+	Tag      *string          `json:"tag"`
+}
+
+// DomainRecordCreateOptions fields are those accepted by CreateDomainRecord
+type DomainRecordCreateOptions struct {
+	Type     DomainRecordType `json:"type"`
+	Name     string           `json:"name"`
+	Target   string           `json:"target"`
+	Priority *int             `json:"priority,omitempty"`
+	Weight   *int             `json:"weight,omitempty"`
+	Port     *int             `json:"port,omitempty"`
+	Service  *string          `json:"service,omitempty"`
+	Protocol *string          `json:"protocol,omitempty"`
+	TTLSec   int              `json:"ttl_sec,omitempty"` // 0 is not accepted by Linode, so can be omitted
+	Tag      *string          `json:"tag,omitempty"`
+}
+
+// DomainRecordUpdateOptions fields are those accepted by UpdateDomainRecord
+type DomainRecordUpdateOptions struct {
+	Type     DomainRecordType `json:"type,omitempty"`
+	Name     string           `json:"name,omitempty"`
+	Target   string           `json:"target,omitempty"`
+	Priority *int             `json:"priority,omitempty"` // 0 is valid, so omit only nil values
+	Weight   *int             `json:"weight,omitempty"`   // 0 is valid, so omit only nil values
+	Port     *int             `json:"port,omitempty"`     // 0 is valid to spec, so omit only nil values
+	Service  *string          `json:"service,omitempty"`
+	Protocol *string          `json:"protocol,omitempty"`
+	TTLSec   int              `json:"ttl_sec,omitempty"` // 0 is not accepted by Linode, so can be omitted
+	Tag      *string          `json:"tag,omitempty"`
+}
+
+// DomainRecordType constants start with RecordType and include Linode API Domain Record Types
+type DomainRecordType string
+
+// DomainRecordType contants are the DNS record types a DomainRecord can assign
+const (
+	RecordTypeA     DomainRecordType = "A"
+	RecordTypeAAAA  DomainRecordType = "AAAA"
+	RecordTypeNS    DomainRecordType = "NS"
+	RecordTypeMX    DomainRecordType = "MX"
+	RecordTypeCNAME DomainRecordType = "CNAME"
+	RecordTypeTXT   DomainRecordType = "TXT"
+	RecordTypeSRV   DomainRecordType = "SRV"
+	RecordTypePTR   DomainRecordType = "PTR"
+	RecordTypeCAA   DomainRecordType = "CAA"
+)
+
+// GetUpdateOptions converts a DomainRecord to DomainRecordUpdateOptions for use in UpdateDomainRecord
+func (d DomainRecord) GetUpdateOptions() (du DomainRecordUpdateOptions) {
+	du.Type = d.Type
+	du.Name = d.Name
+	du.Target = d.Target
+	du.Priority = copyInt(&d.Priority)
+	du.Weight = copyInt(&d.Weight)
+	du.Port = copyInt(&d.Port)
+	du.Service = copyString(d.Service)
+	du.Protocol = copyString(d.Protocol)
+	du.TTLSec = d.TTLSec
+	du.Tag = copyString(d.Tag)
+	return
+}
+
+func copyInt(iPtr *int) *int {
+	if iPtr == nil {
+		return nil
+	}
+	var t = *iPtr
+	return &t
+}
+
+func copyString(sPtr *string) *string {
+	if sPtr == nil {
+		return nil
+	}
+	var t = *sPtr
+	return &t
+}
+
+// DomainRecordsPagedResponse represents a paginated DomainRecord API response
+type DomainRecordsPagedResponse struct {
+	*PageOptions
+	Data []DomainRecord `json:"data"`
+}
+
+// endpoint gets the endpoint URL for InstanceConfig
+func (DomainRecordsPagedResponse) endpointWithID(c *Client, id int) string {
+	endpoint, err := c.DomainRecords.endpointWithID(id)
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends DomainRecords when processing paginated DomainRecord responses
+func (resp *DomainRecordsPagedResponse) appendData(r *DomainRecordsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListDomainRecords lists DomainRecords
+func (c *Client) ListDomainRecords(ctx context.Context, domainID int, opts *ListOptions) ([]DomainRecord, error) {
+	response := DomainRecordsPagedResponse{}
+	err := c.listHelperWithID(ctx, &response, domainID, opts)
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (d *DomainRecord) fixDates() *DomainRecord {
+	return d
+}
+
+// GetDomainRecord gets the domainrecord with the provided ID
+func (c *Client) GetDomainRecord(ctx context.Context, domainID int, id int) (*DomainRecord, error) {
+	e, err := c.DomainRecords.endpointWithID(domainID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&DomainRecord{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*DomainRecord), nil
+}
+
+// CreateDomainRecord creates a DomainRecord
+func (c *Client) CreateDomainRecord(ctx context.Context, domainID int, domainrecord DomainRecordCreateOptions) (*DomainRecord, error) {
+	var body string
+	e, err := c.DomainRecords.endpointWithID(domainID)
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&DomainRecord{})
+
+	bodyData, err := json.Marshal(domainrecord)
+	if err != nil {
+		return nil, NewError(err)
+	}
+	body = string(bodyData)
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*DomainRecord).fixDates(), nil
+}
+
+// UpdateDomainRecord updates the DomainRecord with the specified id
+func (c *Client) UpdateDomainRecord(ctx context.Context, domainID int, id int, domainrecord DomainRecordUpdateOptions) (*DomainRecord, error) {
+	var body string
+	e, err := c.DomainRecords.endpointWithID(domainID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	req := c.R(ctx).SetResult(&DomainRecord{})
+
+	if bodyData, err := json.Marshal(domainrecord); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*DomainRecord).fixDates(), nil
+}
+
+// DeleteDomainRecord deletes the DomainRecord with the specified id
+func (c *Client) DeleteDomainRecord(ctx context.Context, domainID int, id int) error {
+	e, err := c.DomainRecords.endpointWithID(domainID)
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}

vendor/github.com/linode/linodego/domains.go

@@ -0,0 +1,285 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// Domain represents a Domain object
+type Domain struct {
+	//	This Domain's unique ID
+	ID int `json:"id"`
+
+	// The domain this Domain represents. These must be unique in our system; you cannot have two Domains representing the same domain.
+	Domain string `json:"domain"`
+
+	// If this Domain represents the authoritative source of information for the domain it describes, or if it is a read-only copy of a master (also called a slave).
+	Type DomainType `json:"type"` // Enum:"master" "slave"
+
+	// Deprecated: The group this Domain belongs to. This is for display purposes only.
+	Group string `json:"group"`
+
+	// Used to control whether this Domain is currently being rendered.
+	Status DomainStatus `json:"status"` // Enum:"disabled" "active" "edit_mode" "has_errors"
+
+	// A description for this Domain. This is for display purposes only.
+	Description string `json:"description"`
+
+	// Start of Authority email address. This is required for master Domains.
+	SOAEmail string `json:"soa_email"`
+
+	// The interval, in seconds, at which a failed refresh should be retried.
+	// Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	RetrySec int `json:"retry_sec"`
+
+	// The IP addresses representing the master DNS for this Domain.
+	MasterIPs []string `json:"master_ips"`
+
+	// The list of IPs that may perform a zone transfer for this Domain. This is potentially dangerous, and should be set to an empty list unless you intend to use it.
+	AXfrIPs []string `json:"axfr_ips"`
+
+	// The amount of time in seconds that may pass before this Domain is no longer authoritative. Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	ExpireSec int `json:"expire_sec"`
+
+	// The amount of time in seconds before this Domain should be refreshed. Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	RefreshSec int `json:"refresh_sec"`
+
+	// "Time to Live" - the amount of time in seconds that this Domain's records may be cached by resolvers or other domain servers. Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	TTLSec int `json:"ttl_sec"`
+}
+
+// DomainCreateOptions fields are those accepted by CreateDomain
+type DomainCreateOptions struct {
+	// The domain this Domain represents. These must be unique in our system; you cannot have two Domains representing the same domain.
+	Domain string `json:"domain"`
+
+	// If this Domain represents the authoritative source of information for the domain it describes, or if it is a read-only copy of a master (also called a slave).
+	// Enum:"master" "slave"
+	Type DomainType `json:"type"`
+
+	// Deprecated: The group this Domain belongs to. This is for display purposes only.
+	Group string `json:"group,omitempty"`
+
+	// Used to control whether this Domain is currently being rendered.
+	// Enum:"disabled" "active" "edit_mode" "has_errors"
+	Status DomainStatus `json:"status,omitempty"`
+
+	// A description for this Domain. This is for display purposes only.
+	Description string `json:"description,omitempty"`
+
+	// Start of Authority email address. This is required for master Domains.
+	SOAEmail string `json:"soa_email,omitempty"`
+
+	// The interval, in seconds, at which a failed refresh should be retried.
+	// Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	RetrySec int `json:"retry_sec,omitempty"`
+
+	// The IP addresses representing the master DNS for this Domain.
+	MasterIPs []string `json:"master_ips,omitempty"`
+
+	// The list of IPs that may perform a zone transfer for this Domain. This is potentially dangerous, and should be set to an empty list unless you intend to use it.
+	AXfrIPs []string `json:"axfr_ips,omitempty"`
+
+	// The amount of time in seconds that may pass before this Domain is no longer authoritative. Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	ExpireSec int `json:"expire_sec,omitempty"`
+
+	// The amount of time in seconds before this Domain should be refreshed. Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	RefreshSec int `json:"refresh_sec,omitempty"`
+
+	// "Time to Live" - the amount of time in seconds that this Domain's records may be cached by resolvers or other domain servers. Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	TTLSec int `json:"ttl_sec,omitempty"`
+}
+
+// DomainUpdateOptions converts a Domain to DomainUpdateOptions for use in UpdateDomain
+type DomainUpdateOptions struct {
+	// The domain this Domain represents. These must be unique in our system; you cannot have two Domains representing the same domain.
+	Domain string `json:"domain,omitempty"`
+
+	// If this Domain represents the authoritative source of information for the domain it describes, or if it is a read-only copy of a master (also called a slave).
+	// Enum:"master" "slave"
+	Type DomainType `json:"type,omitempty"`
+
+	// Deprecated: The group this Domain belongs to. This is for display purposes only.
+	Group string `json:"group,omitempty"`
+
+	// Used to control whether this Domain is currently being rendered.
+	// Enum:"disabled" "active" "edit_mode" "has_errors"
+	Status DomainStatus `json:"status,omitempty"`
+
+	// A description for this Domain. This is for display purposes only.
+	Description string `json:"description,omitempty"`
+
+	// Start of Authority email address. This is required for master Domains.
+	SOAEmail string `json:"soa_email,omitempty"`
+
+	// The interval, in seconds, at which a failed refresh should be retried.
+	// Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	RetrySec int `json:"retry_sec,omitempty"`
+
+	// The IP addresses representing the master DNS for this Domain.
+	MasterIPs []string `json:"master_ips,omitempty"`
+
+	// The list of IPs that may perform a zone transfer for this Domain. This is potentially dangerous, and should be set to an empty list unless you intend to use it.
+	AXfrIPs []string `json:"axfr_ips,omitempty"`
+
+	// The amount of time in seconds that may pass before this Domain is no longer authoritative. Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	ExpireSec int `json:"expire_sec,omitempty"`
+
+	// The amount of time in seconds before this Domain should be refreshed. Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	RefreshSec int `json:"refresh_sec,omitempty"`
+
+	// "Time to Live" - the amount of time in seconds that this Domain's records may be cached by resolvers or other domain servers. Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	TTLSec int `json:"ttl_sec,omitempty"`
+}
+
+// DomainType constants start with DomainType and include Linode API Domain Type values
+type DomainType string
+
+// DomainType constants reflect the DNS zone type of a Domain
+const (
+	DomainTypeMaster DomainType = "master"
+	DomainTypeSlave  DomainType = "slave"
+)
+
+// DomainStatus constants start with DomainStatus and include Linode API Domain Status values
+type DomainStatus string
+
+// DomainStatus constants reflect the current status of a Domain
+const (
+	DomainStatusDisabled  DomainStatus = "disabled"
+	DomainStatusActive    DomainStatus = "active"
+	DomainStatusEditMode  DomainStatus = "edit_mode"
+	DomainStatusHasErrors DomainStatus = "has_errors"
+)
+
+// GetUpdateOptions converts a Domain to DomainUpdateOptions for use in UpdateDomain
+func (d Domain) GetUpdateOptions() (du DomainUpdateOptions) {
+	du.Domain = d.Domain
+	du.Type = d.Type
+	du.Group = d.Group
+	du.Status = d.Status
+	du.Description = d.Description
+	du.SOAEmail = d.SOAEmail
+	du.RetrySec = d.RetrySec
+	du.MasterIPs = d.MasterIPs
+	du.AXfrIPs = d.AXfrIPs
+	du.ExpireSec = d.ExpireSec
+	du.RefreshSec = d.RefreshSec
+	du.TTLSec = d.TTLSec
+	return
+}
+
+// DomainsPagedResponse represents a paginated Domain API response
+type DomainsPagedResponse struct {
+	*PageOptions
+	Data []Domain `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Domain
+func (DomainsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Domains.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends Domains when processing paginated Domain responses
+func (resp *DomainsPagedResponse) appendData(r *DomainsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListDomains lists Domains
+func (c *Client) ListDomains(ctx context.Context, opts *ListOptions) ([]Domain, error) {
+	response := DomainsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (d *Domain) fixDates() *Domain {
+	return d
+}
+
+// GetDomain gets the domain with the provided ID
+func (c *Client) GetDomain(ctx context.Context, id int) (*Domain, error) {
+	e, err := c.Domains.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&Domain{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Domain).fixDates(), nil
+}
+
+// CreateDomain creates a Domain
+func (c *Client) CreateDomain(ctx context.Context, domain DomainCreateOptions) (*Domain, error) {
+	var body string
+	e, err := c.Domains.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&Domain{})
+
+	bodyData, err := json.Marshal(domain)
+	if err != nil {
+		return nil, NewError(err)
+	}
+	body = string(bodyData)
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Domain).fixDates(), nil
+}
+
+// UpdateDomain updates the Domain with the specified id
+func (c *Client) UpdateDomain(ctx context.Context, id int, domain DomainUpdateOptions) (*Domain, error) {
+	var body string
+	e, err := c.Domains.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	req := c.R(ctx).SetResult(&Domain{})
+
+	if bodyData, err := json.Marshal(domain); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Domain).fixDates(), nil
+}
+
+// DeleteDomain deletes the Domain with the specified id
+func (c *Client) DeleteDomain(ctx context.Context, id int) error {
+	e, err := c.Domains.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}

vendor/github.com/linode/linodego/errors.go

@@ -0,0 +1,109 @@
+package linodego
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"strings"
+
+	"github.com/go-resty/resty"
+)
+
+const (
+	// ErrorFromString is the Code identifying Errors created by string types
+	ErrorFromString = 1
+	// ErrorFromError is the Code identifying Errors created by error types
+	ErrorFromError = 2
+	// ErrorFromStringer is the Code identifying Errors created by fmt.Stringer types
+	ErrorFromStringer = 3
+)
+
+// Error wraps the LinodeGo error with the relevant http.Response
+type Error struct {
+	Response *http.Response
+	Code     int
+	Message  string
+}
+
+// APIErrorReason is an individual invalid request message returned by the Linode API
+type APIErrorReason struct {
+	Reason string `json:"reason"`
+	Field  string `json:"field"`
+}
+
+func (r APIErrorReason) Error() string {
+	if len(r.Field) == 0 {
+		return r.Reason
+	}
+	return fmt.Sprintf("[%s] %s", r.Field, r.Reason)
+}
+
+// APIError is the error-set returned by the Linode API when presented with an invalid request
+type APIError struct {
+	Errors []APIErrorReason `json:"errors"`
+}
+
+func coupleAPIErrors(r *resty.Response, err error) (*resty.Response, error) {
+	if err != nil {
+		return nil, NewError(err)
+	}
+
+	if r.Error() != nil {
+		apiError, ok := r.Error().(*APIError)
+		if !ok || (ok && len(apiError.Errors) == 0) {
+			return r, nil
+		}
+		return nil, NewError(r)
+	}
+
+	return r, nil
+}
+
+func (e APIError) Error() string {
+	var x []string
+	for _, msg := range e.Errors {
+		x = append(x, msg.Error())
+	}
+	return strings.Join(x, "; ")
+}
+
+func (g Error) Error() string {
+	return fmt.Sprintf("[%03d] %s", g.Code, g.Message)
+}
+
+// NewError creates a linodego.Error with a Code identifying the source err type,
+// - ErrorFromString   (1) from a string
+// - ErrorFromError    (2) for an error
+// - ErrorFromStringer (3) for a Stringer
+// - HTTP Status Codes (100-600) for a resty.Response object
+func NewError(err interface{}) *Error {
+	if err == nil {
+		return nil
+	}
+
+	switch e := err.(type) {
+	case *Error:
+		return e
+	case *resty.Response:
+		apiError, ok := e.Error().(*APIError)
+
+		if !ok {
+			log.Fatalln("Unexpected Resty Error Response")
+		}
+
+		return &Error{
+			Code:     e.RawResponse.StatusCode,
+			Message:  apiError.Error(),
+			Response: e.RawResponse,
+		}
+	case error:
+		return &Error{Code: ErrorFromError, Message: e.Error()}
+	case string:
+		return &Error{Code: ErrorFromString, Message: e}
+	case fmt.Stringer:
+		return &Error{Code: ErrorFromStringer, Message: e.String()}
+	default:
+		log.Fatalln("Unsupported type to linodego.NewError")
+		panic(err)
+	}
+}

vendor/github.com/linode/linodego/images.go

@@ -0,0 +1,163 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// Image represents a deployable Image object for use with Linode Instances
+type Image struct {
+	CreatedStr  string `json:"created"`
+	UpdatedStr  string `json:"updated"`
+	ID          string `json:"id"`
+	CreatedBy   string `json:"created_by"`
+	Label       string `json:"label"`
+	Description string `json:"description"`
+	Type        string `json:"type"`
+	Vendor      string `json:"vendor"`
+	Size        int    `json:"size"`
+	IsPublic    bool   `json:"is_public"`
+	Deprecated  bool   `json:"deprecated"`
+
+	Created *time.Time `json:"-"`
+	Updated *time.Time `json:"-"`
+}
+
+// ImageCreateOptions fields are those accepted by CreateImage
+type ImageCreateOptions struct {
+	DiskID      int    `json:"disk_id"`
+	Label       string `json:"label"`
+	Description string `json:"description,omitempty"`
+}
+
+// ImageUpdateOptions fields are those accepted by UpdateImage
+type ImageUpdateOptions struct {
+	Label       string  `json:"label,omitempty"`
+	Description *string `json:"description,omitempty"`
+}
+
+func (i *Image) fixDates() *Image {
+	i.Created, _ = parseDates(i.CreatedStr)
+	i.Updated, _ = parseDates(i.UpdatedStr)
+	return i
+}
+
+// GetUpdateOptions converts an Image to ImageUpdateOptions for use in UpdateImage
+func (i Image) GetUpdateOptions() (iu ImageUpdateOptions) {
+	iu.Label = i.Label
+	iu.Description = copyString(&i.Description)
+	return
+}
+
+// ImagesPagedResponse represents a linode API response for listing of images
+type ImagesPagedResponse struct {
+	*PageOptions
+	Data []Image `json:"data"`
+}
+
+func (ImagesPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Images.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+func (resp *ImagesPagedResponse) appendData(r *ImagesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListImages lists Images
+func (c *Client) ListImages(ctx context.Context, opts *ListOptions) ([]Image, error) {
+	response := ImagesPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+
+}
+
+// GetImage gets the Image with the provided ID
+func (c *Client) GetImage(ctx context.Context, id string) (*Image, error) {
+	e, err := c.Images.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+	r, err := coupleAPIErrors(c.Images.R(ctx).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Image), nil
+}
+
+// CreateImage creates a Image
+func (c *Client) CreateImage(ctx context.Context, createOpts ImageCreateOptions) (*Image, error) {
+	var body string
+	e, err := c.Images.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&Image{})
+
+	if bodyData, err := json.Marshal(createOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Image).fixDates(), nil
+}
+
+// UpdateImage updates the Image with the specified id
+func (c *Client) UpdateImage(ctx context.Context, id string, updateOpts ImageUpdateOptions) (*Image, error) {
+	var body string
+	e, err := c.Images.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+
+	req := c.R(ctx).SetResult(&Image{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Image).fixDates(), nil
+}
+
+// DeleteImage deletes the Image with the specified id
+func (c *Client) DeleteImage(ctx context.Context, id string) error {
+	e, err := c.Images.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}

vendor/github.com/linode/linodego/instance_configs.go

@@ -0,0 +1,246 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// InstanceConfig represents all of the settings that control the boot and run configuration of a Linode Instance
+type InstanceConfig struct {
+	CreatedStr string `json:"created"`
+	UpdatedStr string `json:"updated"`
+
+	ID          int                      `json:"id"`
+	Label       string                   `json:"label"`
+	Comments    string                   `json:"comments"`
+	Devices     *InstanceConfigDeviceMap `json:"devices"`
+	Helpers     *InstanceConfigHelpers   `json:"helpers"`
+	MemoryLimit int                      `json:"memory_limit"`
+	Kernel      string                   `json:"kernel"`
+	InitRD      *int                     `json:"init_rd"`
+	RootDevice  string                   `json:"root_device"`
+	RunLevel    string                   `json:"run_level"`
+	VirtMode    string                   `json:"virt_mode"`
+	Created     *time.Time               `json:"-"`
+	Updated     *time.Time               `json:"-"`
+}
+
+// InstanceConfigDevice contains either the DiskID or VolumeID assigned to a Config Device
+type InstanceConfigDevice struct {
+	DiskID   int `json:"disk_id,omitempty"`
+	VolumeID int `json:"volume_id,omitempty"`
+}
+
+// InstanceConfigDeviceMap contains SDA-SDH InstanceConfigDevice settings
+type InstanceConfigDeviceMap struct {
+	SDA *InstanceConfigDevice `json:"sda,omitempty"`
+	SDB *InstanceConfigDevice `json:"sdb,omitempty"`
+	SDC *InstanceConfigDevice `json:"sdc,omitempty"`
+	SDD *InstanceConfigDevice `json:"sdd,omitempty"`
+	SDE *InstanceConfigDevice `json:"sde,omitempty"`
+	SDF *InstanceConfigDevice `json:"sdf,omitempty"`
+	SDG *InstanceConfigDevice `json:"sdg,omitempty"`
+	SDH *InstanceConfigDevice `json:"sdh,omitempty"`
+}
+
+// InstanceConfigHelpers are Instance Config options that control Linux distribution specific tweaks
+type InstanceConfigHelpers struct {
+	UpdateDBDisabled  bool `json:"updatedb_disabled"`
+	Distro            bool `json:"distro"`
+	ModulesDep        bool `json:"modules_dep"`
+	Network           bool `json:"network"`
+	DevTmpFsAutomount bool `json:"devtmpfs_automount"`
+}
+
+// InstanceConfigsPagedResponse represents a paginated InstanceConfig API response
+type InstanceConfigsPagedResponse struct {
+	*PageOptions
+	Data []InstanceConfig `json:"data"`
+}
+
+// InstanceConfigCreateOptions are InstanceConfig settings that can be used at creation
+type InstanceConfigCreateOptions struct {
+	Label       string                  `json:"label,omitempty"`
+	Comments    string                  `json:"comments,omitempty"`
+	Devices     InstanceConfigDeviceMap `json:"devices"`
+	Helpers     *InstanceConfigHelpers  `json:"helpers,omitempty"`
+	MemoryLimit int                     `json:"memory_limit,omitempty"`
+	Kernel      string                  `json:"kernel,omitempty"`
+	InitRD      int                     `json:"init_rd,omitempty"`
+	RootDevice  *string                 `json:"root_device,omitempty"`
+	RunLevel    string                  `json:"run_level,omitempty"`
+	VirtMode    string                  `json:"virt_mode,omitempty"`
+}
+
+// InstanceConfigUpdateOptions are InstanceConfig settings that can be used in updates
+type InstanceConfigUpdateOptions struct {
+	Label    string                   `json:"label,omitempty"`
+	Comments string                   `json:"comments"`
+	Devices  *InstanceConfigDeviceMap `json:"devices,omitempty"`
+	Helpers  *InstanceConfigHelpers   `json:"helpers,omitempty"`
+	// MemoryLimit 0 means unlimitted, this is not omitted
+	MemoryLimit int    `json:"memory_limit"`
+	Kernel      string `json:"kernel,omitempty"`
+	// InitRD is nullable, permit the sending of null
+	InitRD     *int   `json:"init_rd"`
+	RootDevice string `json:"root_device,omitempty"`
+	RunLevel   string `json:"run_level,omitempty"`
+	VirtMode   string `json:"virt_mode,omitempty"`
+}
+
+// GetCreateOptions converts a InstanceConfig to InstanceConfigCreateOptions for use in CreateInstanceConfig
+func (i InstanceConfig) GetCreateOptions() InstanceConfigCreateOptions {
+	initrd := 0
+	if i.InitRD != nil {
+		initrd = *i.InitRD
+	}
+	return InstanceConfigCreateOptions{
+		Label:       i.Label,
+		Comments:    i.Comments,
+		Devices:     *i.Devices,
+		Helpers:     i.Helpers,
+		MemoryLimit: i.MemoryLimit,
+		Kernel:      i.Kernel,
+		InitRD:      initrd,
+		RootDevice:  copyString(&i.RootDevice),
+		RunLevel:    i.RunLevel,
+		VirtMode:    i.VirtMode,
+	}
+}
+
+// GetUpdateOptions converts a InstanceConfig to InstanceConfigUpdateOptions for use in UpdateInstanceConfig
+func (i InstanceConfig) GetUpdateOptions() InstanceConfigUpdateOptions {
+	return InstanceConfigUpdateOptions{
+		Label:       i.Label,
+		Comments:    i.Comments,
+		Devices:     i.Devices,
+		Helpers:     i.Helpers,
+		MemoryLimit: i.MemoryLimit,
+		Kernel:      i.Kernel,
+		InitRD:      copyInt(i.InitRD),
+		RootDevice:  i.RootDevice,
+		RunLevel:    i.RunLevel,
+		VirtMode:    i.VirtMode,
+	}
+}
+
+// endpointWithID gets the endpoint URL for InstanceConfigs of a given Instance
+func (InstanceConfigsPagedResponse) endpointWithID(c *Client, id int) string {
+	endpoint, err := c.InstanceConfigs.endpointWithID(id)
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends InstanceConfigs when processing paginated InstanceConfig responses
+func (resp *InstanceConfigsPagedResponse) appendData(r *InstanceConfigsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListInstanceConfigs lists InstanceConfigs
+func (c *Client) ListInstanceConfigs(ctx context.Context, linodeID int, opts *ListOptions) ([]InstanceConfig, error) {
+	response := InstanceConfigsPagedResponse{}
+	err := c.listHelperWithID(ctx, &response, linodeID, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (i *InstanceConfig) fixDates() *InstanceConfig {
+	i.Created, _ = parseDates(i.CreatedStr)
+	i.Updated, _ = parseDates(i.UpdatedStr)
+	return i
+}
+
+// GetInstanceConfig gets the template with the provided ID
+func (c *Client) GetInstanceConfig(ctx context.Context, linodeID int, configID int) (*InstanceConfig, error) {
+	e, err := c.InstanceConfigs.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, configID)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&InstanceConfig{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*InstanceConfig).fixDates(), nil
+}
+
+// CreateInstanceConfig creates a new InstanceConfig for the given Instance
+func (c *Client) CreateInstanceConfig(ctx context.Context, linodeID int, createOpts InstanceConfigCreateOptions) (*InstanceConfig, error) {
+	var body string
+	e, err := c.InstanceConfigs.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&InstanceConfig{})
+
+	if bodyData, err := json.Marshal(createOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, err
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Result().(*InstanceConfig).fixDates(), nil
+}
+
+// UpdateInstanceConfig update an InstanceConfig for the given Instance
+func (c *Client) UpdateInstanceConfig(ctx context.Context, linodeID int, configID int, updateOpts InstanceConfigUpdateOptions) (*InstanceConfig, error) {
+	var body string
+	e, err := c.InstanceConfigs.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, configID)
+	req := c.R(ctx).SetResult(&InstanceConfig{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, err
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Result().(*InstanceConfig).fixDates(), nil
+}
+
+// RenameInstanceConfig renames an InstanceConfig
+func (c *Client) RenameInstanceConfig(ctx context.Context, linodeID int, configID int, label string) (*InstanceConfig, error) {
+	return c.UpdateInstanceConfig(ctx, linodeID, configID, InstanceConfigUpdateOptions{Label: label})
+}
+
+// DeleteInstanceConfig deletes a Linode InstanceConfig
+func (c *Client) DeleteInstanceConfig(ctx context.Context, linodeID int, configID int) error {
+	e, err := c.InstanceConfigs.endpointWithID(linodeID)
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, configID)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}

vendor/github.com/linode/linodego/instance_disks.go

@@ -0,0 +1,217 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// InstanceDisk represents an Instance Disk object
+type InstanceDisk struct {
+	CreatedStr string `json:"created"`
+	UpdatedStr string `json:"updated"`
+
+	ID         int            `json:"id"`
+	Label      string         `json:"label"`
+	Status     string         `json:"status"`
+	Size       int            `json:"size"`
+	Filesystem DiskFilesystem `json:"filesystem"`
+	Created    time.Time      `json:"-"`
+	Updated    time.Time      `json:"-"`
+}
+
+// DiskFilesystem constants start with Filesystem and include Linode API Filesystems
+type DiskFilesystem string
+
+// DiskFilesystem constants represent the filesystems types an Instance Disk may use
+const (
+	FilesystemRaw    DiskFilesystem = "raw"
+	FilesystemSwap   DiskFilesystem = "swap"
+	FilesystemExt3   DiskFilesystem = "ext3"
+	FilesystemExt4   DiskFilesystem = "ext4"
+	FilesystemInitrd DiskFilesystem = "initrd"
+)
+
+// InstanceDisksPagedResponse represents a paginated InstanceDisk API response
+type InstanceDisksPagedResponse struct {
+	*PageOptions
+	Data []InstanceDisk `json:"data"`
+}
+
+// InstanceDiskCreateOptions are InstanceDisk settings that can be used at creation
+type InstanceDiskCreateOptions struct {
+	Label string `json:"label"`
+	Size  int    `json:"size"`
+
+	// Image is optional, but requires RootPass if provided
+	Image    string `json:"image,omitempty"`
+	RootPass string `json:"root_pass,omitempty"`
+
+	Filesystem      string            `json:"filesystem,omitempty"`
+	AuthorizedKeys  []string          `json:"authorized_keys,omitempty"`
+	AuthorizedUsers []string          `json:"authorized_users,omitempty"`
+	ReadOnly        bool              `json:"read_only,omitempty"`
+	StackscriptID   int               `json:"stackscript_id,omitempty"`
+	StackscriptData map[string]string `json:"stackscript_data,omitempty"`
+}
+
+// InstanceDiskUpdateOptions are InstanceDisk settings that can be used in updates
+type InstanceDiskUpdateOptions struct {
+	Label    string `json:"label"`
+	ReadOnly bool   `json:"read_only"`
+}
+
+// endpointWithID gets the endpoint URL for InstanceDisks of a given Instance
+func (InstanceDisksPagedResponse) endpointWithID(c *Client, id int) string {
+	endpoint, err := c.InstanceDisks.endpointWithID(id)
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends InstanceDisks when processing paginated InstanceDisk responses
+func (resp *InstanceDisksPagedResponse) appendData(r *InstanceDisksPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListInstanceDisks lists InstanceDisks
+func (c *Client) ListInstanceDisks(ctx context.Context, linodeID int, opts *ListOptions) ([]InstanceDisk, error) {
+	response := InstanceDisksPagedResponse{}
+	err := c.listHelperWithID(ctx, &response, linodeID, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (v *InstanceDisk) fixDates() *InstanceDisk {
+	if created, err := parseDates(v.CreatedStr); err == nil {
+		v.Created = *created
+	}
+	if updated, err := parseDates(v.UpdatedStr); err == nil {
+		v.Updated = *updated
+	}
+	return v
+}
+
+// GetInstanceDisk gets the template with the provided ID
+func (c *Client) GetInstanceDisk(ctx context.Context, linodeID int, configID int) (*InstanceDisk, error) {
+	e, err := c.InstanceDisks.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, configID)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&InstanceDisk{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*InstanceDisk).fixDates(), nil
+}
+
+// CreateInstanceDisk creates a new InstanceDisk for the given Instance
+func (c *Client) CreateInstanceDisk(ctx context.Context, linodeID int, createOpts InstanceDiskCreateOptions) (*InstanceDisk, error) {
+	var body string
+	e, err := c.InstanceDisks.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&InstanceDisk{})
+
+	if bodyData, err := json.Marshal(createOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Result().(*InstanceDisk).fixDates(), nil
+}
+
+// UpdateInstanceDisk creates a new InstanceDisk for the given Instance
+func (c *Client) UpdateInstanceDisk(ctx context.Context, linodeID int, diskID int, updateOpts InstanceDiskUpdateOptions) (*InstanceDisk, error) {
+	var body string
+	e, err := c.InstanceDisks.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, diskID)
+
+	req := c.R(ctx).SetResult(&InstanceDisk{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Result().(*InstanceDisk).fixDates(), nil
+}
+
+// RenameInstanceDisk renames an InstanceDisk
+func (c *Client) RenameInstanceDisk(ctx context.Context, linodeID int, diskID int, label string) (*InstanceDisk, error) {
+	return c.UpdateInstanceDisk(ctx, linodeID, diskID, InstanceDiskUpdateOptions{Label: label})
+}
+
+// ResizeInstanceDisk resizes the size of the Instance disk
+func (c *Client) ResizeInstanceDisk(ctx context.Context, linodeID int, diskID int, size int) (*InstanceDisk, error) {
+	var body string
+	e, err := c.InstanceDisks.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, diskID)
+
+	req := c.R(ctx).SetResult(&InstanceDisk{})
+	updateOpts := map[string]interface{}{
+		"size": size,
+	}
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*InstanceDisk).fixDates(), nil
+}
+
+// DeleteInstanceDisk deletes a Linode Instance Disk
+func (c *Client) DeleteInstanceDisk(ctx context.Context, linodeID int, diskID int) error {
+	e, err := c.InstanceDisks.endpointWithID(linodeID)
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, diskID)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}

vendor/github.com/linode/linodego/instance_ips.go

@@ -0,0 +1,106 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// InstanceIPAddressResponse contains the IPv4 and IPv6 details for an Instance
+type InstanceIPAddressResponse struct {
+	IPv4 *InstanceIPv4Response `json:"ipv4"`
+	IPv6 *InstanceIPv6Response `json:"ipv6"`
+}
+
+// InstanceIPv4Response contains the details of all IPv4 addresses associated with an Instance
+type InstanceIPv4Response struct {
+	Public  []*InstanceIP `json:"public"`
+	Private []*InstanceIP `json:"private"`
+	Shared  []*InstanceIP `json:"shared"`
+}
+
+// InstanceIP represents an Instance IP with additional DNS and networking details
+type InstanceIP struct {
+	Address    string `json:"address"`
+	Gateway    string `json:"gateway"`
+	SubnetMask string `json:"subnet_mask"`
+	Prefix     int    `json:"prefix"`
+	Type       string `json:"type"`
+	Public     bool   `json:"public"`
+	RDNS       string `json:"rdns"`
+	LinodeID   int    `json:"linode_id"`
+	Region     string `json:"region"`
+}
+
+// InstanceIPv6Response contains the IPv6 addresses and ranges for an Instance
+type InstanceIPv6Response struct {
+	LinkLocal *InstanceIP  `json:"link_local"`
+	SLAAC     *InstanceIP  `json:"slaac"`
+	Global    []*IPv6Range `json:"global"`
+}
+
+// IPv6Range represents a range of IPv6 addresses routed to a single Linode in a given Region
+type IPv6Range struct {
+	Range  string `json:"range"`
+	Region string `json:"region"`
+}
+
+// GetInstanceIPAddresses gets the IPAddresses for a Linode instance
+func (c *Client) GetInstanceIPAddresses(ctx context.Context, linodeID int) (*InstanceIPAddressResponse, error) {
+	e, err := c.InstanceIPs.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&InstanceIPAddressResponse{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*InstanceIPAddressResponse), nil
+}
+
+// GetInstanceIPAddress gets the IPAddress for a Linode instance matching a supplied IP address
+func (c *Client) GetInstanceIPAddress(ctx context.Context, linodeID int, ipaddress string) (*InstanceIP, error) {
+	e, err := c.InstanceIPs.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, ipaddress)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&InstanceIP{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*InstanceIP), nil
+}
+
+// AddInstanceIPAddress adds a public or private IP to a Linode instance
+func (c *Client) AddInstanceIPAddress(ctx context.Context, linodeID int, public bool) (*InstanceIP, error) {
+	var body string
+	e, err := c.InstanceIPs.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&InstanceIP{})
+
+	instanceipRequest := struct {
+		Type   string `json:"type"`
+		Public bool   `json:"public"`
+	}{"ipv4", public}
+
+	if bodyData, err := json.Marshal(instanceipRequest); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetHeader("Content-Type", "application/json").
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Result().(*InstanceIP), nil
+}

vendor/github.com/linode/linodego/instance_snapshots.go

@@ -0,0 +1,188 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// InstanceBackupsResponse response struct for backup snapshot
+type InstanceBackupsResponse struct {
+	Automatic []*InstanceSnapshot             `json:"automatic"`
+	Snapshot  *InstanceBackupSnapshotResponse `json:"snapshot"`
+}
+
+// InstanceBackupSnapshotResponse fields are those representing Instance Backup Snapshots
+type InstanceBackupSnapshotResponse struct {
+	Current    *InstanceSnapshot `json:"current"`
+	InProgress *InstanceSnapshot `json:"in_progress"`
+}
+
+// RestoreInstanceOptions fields are those accepted by InstanceRestore
+type RestoreInstanceOptions struct {
+	LinodeID  int  `json:"linode_id"`
+	Overwrite bool `json:"overwrite"`
+}
+
+// InstanceSnapshot represents a linode backup snapshot
+type InstanceSnapshot struct {
+	CreatedStr  string `json:"created"`
+	UpdatedStr  string `json:"updated"`
+	FinishedStr string `json:"finished"`
+
+	ID       int                     `json:"id"`
+	Label    string                  `json:"label"`
+	Status   InstanceSnapshotStatus  `json:"status"`
+	Type     string                  `json:"type"`
+	Created  *time.Time              `json:"-"`
+	Updated  *time.Time              `json:"-"`
+	Finished *time.Time              `json:"-"`
+	Configs  []string                `json:"configs"`
+	Disks    []*InstanceSnapshotDisk `json:"disks"`
+}
+
+// InstanceSnapshotDisk fields represent the source disk of a Snapshot
+type InstanceSnapshotDisk struct {
+	Label      string `json:"label"`
+	Size       int    `json:"size"`
+	Filesystem string `json:"filesystem"`
+}
+
+// InstanceSnapshotStatus constants start with Snapshot and include Linode API Instance Backup Snapshot status values
+type InstanceSnapshotStatus string
+
+// InstanceSnapshotStatus constants reflect the current status of an Instance Snapshot
+var (
+	SnapshotPaused              InstanceSnapshotStatus = "paused"
+	SnapshotPending             InstanceSnapshotStatus = "pending"
+	SnapshotRunning             InstanceSnapshotStatus = "running"
+	SnapshotNeedsPostProcessing InstanceSnapshotStatus = "needsPostProcessing"
+	SnapshotSuccessful          InstanceSnapshotStatus = "successful"
+	SnapshotFailed              InstanceSnapshotStatus = "failed"
+	SnapshotUserAborted         InstanceSnapshotStatus = "userAborted"
+)
+
+func (l *InstanceSnapshot) fixDates() *InstanceSnapshot {
+	l.Created, _ = parseDates(l.CreatedStr)
+	l.Updated, _ = parseDates(l.UpdatedStr)
+	l.Finished, _ = parseDates(l.FinishedStr)
+	return l
+}
+
+// GetInstanceSnapshot gets the snapshot with the provided ID
+func (c *Client) GetInstanceSnapshot(ctx context.Context, linodeID int, snapshotID int) (*InstanceSnapshot, error) {
+	e, err := c.InstanceSnapshots.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, snapshotID)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&InstanceSnapshot{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*InstanceSnapshot).fixDates(), nil
+}
+
+// CreateInstanceSnapshot Creates or Replaces the snapshot Backup of a Linode. If a previous snapshot exists for this Linode, it will be deleted.
+func (c *Client) CreateInstanceSnapshot(ctx context.Context, linodeID int, label string) (*InstanceSnapshot, error) {
+	o, err := json.Marshal(map[string]string{"label": label})
+	if err != nil {
+		return nil, err
+	}
+	body := string(o)
+	e, err := c.InstanceSnapshots.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+
+	r, err := coupleAPIErrors(c.R(ctx).
+		SetBody(body).
+		SetResult(&InstanceSnapshot{}).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Result().(*InstanceSnapshot).fixDates(), nil
+}
+
+// GetInstanceBackups gets the Instance's available Backups.
+// This is not called ListInstanceBackups because a single object is returned, matching the API response.
+func (c *Client) GetInstanceBackups(ctx context.Context, linodeID int) (*InstanceBackupsResponse, error) {
+	e, err := c.InstanceSnapshots.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+	r, err := coupleAPIErrors(c.R(ctx).
+		SetResult(&InstanceBackupsResponse{}).
+		Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*InstanceBackupsResponse).fixDates(), nil
+}
+
+// EnableInstanceBackups Enables backups for the specified Linode.
+func (c *Client) EnableInstanceBackups(ctx context.Context, linodeID int) error {
+	e, err := c.InstanceSnapshots.endpointWithID(linodeID)
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/enable", e)
+
+	_, err = coupleAPIErrors(c.R(ctx).Post(e))
+	return err
+}
+
+// CancelInstanceBackups Cancels backups for the specified Linode.
+func (c *Client) CancelInstanceBackups(ctx context.Context, linodeID int) error {
+	e, err := c.InstanceSnapshots.endpointWithID(linodeID)
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/cancel", e)
+
+	_, err = coupleAPIErrors(c.R(ctx).Post(e))
+	return err
+}
+
+// RestoreInstanceBackup Restores a Linode's Backup to the specified Linode.
+func (c *Client) RestoreInstanceBackup(ctx context.Context, linodeID int, backupID int, opts RestoreInstanceOptions) error {
+	o, err := json.Marshal(opts)
+	if err != nil {
+		return NewError(err)
+	}
+	body := string(o)
+	e, err := c.InstanceSnapshots.endpointWithID(linodeID)
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d/restore", e, backupID)
+
+	_, err = coupleAPIErrors(c.R(ctx).SetBody(body).Post(e))
+
+	return err
+
+}
+
+func (l *InstanceBackupSnapshotResponse) fixDates() *InstanceBackupSnapshotResponse {
+	if l.Current != nil {
+		l.Current.fixDates()
+	}
+	if l.InProgress != nil {
+		l.InProgress.fixDates()
+	}
+	return l
+}
+
+func (l *InstanceBackupsResponse) fixDates() *InstanceBackupsResponse {
+	for i := range l.Automatic {
+		l.Automatic[i].fixDates()
+	}
+	if l.Snapshot != nil {
+		l.Snapshot.fixDates()
+	}
+	return l
+}

vendor/github.com/linode/linodego/instance_volumes.go

@@ -0,0 +1,38 @@
+package linodego
+
+import (
+	"context"
+)
+
+// InstanceVolumesPagedResponse represents a paginated InstanceVolume API response
+type InstanceVolumesPagedResponse struct {
+	*PageOptions
+	Data []Volume `json:"data"`
+}
+
+// endpoint gets the endpoint URL for InstanceVolume
+func (InstanceVolumesPagedResponse) endpointWithID(c *Client, id int) string {
+	endpoint, err := c.InstanceVolumes.endpointWithID(id)
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends InstanceVolumes when processing paginated InstanceVolume responses
+func (resp *InstanceVolumesPagedResponse) appendData(r *InstanceVolumesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListInstanceVolumes lists InstanceVolumes
+func (c *Client) ListInstanceVolumes(ctx context.Context, linodeID int, opts *ListOptions) ([]Volume, error) {
+	response := InstanceVolumesPagedResponse{}
+	err := c.listHelperWithID(ctx, &response, linodeID, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}

vendor/github.com/linode/linodego/instances.go

@@ -0,0 +1,438 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net"
+	"time"
+)
+
+/*
+ * https://developers.linode.com/v4/reference/endpoints/linode/instances
+ */
+
+// InstanceStatus constants start with Instance and include Linode API Instance Status values
+type InstanceStatus string
+
+// InstanceStatus constants reflect the current status of an Instance
+const (
+	InstanceBooting      InstanceStatus = "booting"
+	InstanceRunning      InstanceStatus = "running"
+	InstanceOffline      InstanceStatus = "offline"
+	InstanceShuttingDown InstanceStatus = "shutting_down"
+	InstanceRebooting    InstanceStatus = "rebooting"
+	InstanceProvisioning InstanceStatus = "provisioning"
+	InstanceDeleting     InstanceStatus = "deleting"
+	InstanceMigrating    InstanceStatus = "migrating"
+	InstanceRebuilding   InstanceStatus = "rebuilding"
+	InstanceCloning      InstanceStatus = "cloning"
+	InstanceRestoring    InstanceStatus = "restoring"
+	InstanceResizing     InstanceStatus = "resizing"
+)
+
+// Instance represents a linode object
+type Instance struct {
+	CreatedStr string `json:"created"`
+	UpdatedStr string `json:"updated"`
+
+	ID         int             `json:"id"`
+	Created    *time.Time      `json:"-"`
+	Updated    *time.Time      `json:"-"`
+	Region     string          `json:"region"`
+	Alerts     *InstanceAlert  `json:"alerts"`
+	Backups    *InstanceBackup `json:"backups"`
+	Image      string          `json:"image"`
+	Group      string          `json:"group"`
+	IPv4       []*net.IP       `json:"ipv4"`
+	IPv6       string          `json:"ipv6"`
+	Label      string          `json:"label"`
+	Type       string          `json:"type"`
+	Status     InstanceStatus  `json:"status"`
+	Hypervisor string          `json:"hypervisor"`
+	Specs      *InstanceSpec   `json:"specs"`
+}
+
+// InstanceSpec represents a linode spec
+type InstanceSpec struct {
+	Disk     int `json:"disk"`
+	Memory   int `json:"memory"`
+	VCPUs    int `json:"vcpus"`
+	Transfer int `json:"transfer"`
+}
+
+// InstanceAlert represents a metric alert
+type InstanceAlert struct {
+	CPU           int `json:"cpu"`
+	IO            int `json:"io"`
+	NetworkIn     int `json:"network_in"`
+	NetworkOut    int `json:"network_out"`
+	TransferQuota int `json:"transfer_quota"`
+}
+
+// InstanceBackup represents backup settings for an instance
+type InstanceBackup struct {
+	Enabled  bool `json:"enabled"`
+	Schedule struct {
+		Day    string `json:"day,omitempty"`
+		Window string `json:"window,omitempty"`
+	}
+}
+
+// InstanceCreateOptions require only Region and Type
+type InstanceCreateOptions struct {
+	Region          string            `json:"region"`
+	Type            string            `json:"type"`
+	Label           string            `json:"label,omitempty"`
+	Group           string            `json:"group,omitempty"`
+	RootPass        string            `json:"root_pass,omitempty"`
+	AuthorizedKeys  []string          `json:"authorized_keys,omitempty"`
+	AuthorizedUsers []string          `json:"authorized_users,omitempty"`
+	StackScriptID   int               `json:"stackscript_id,omitempty"`
+	StackScriptData map[string]string `json:"stackscript_data,omitempty"`
+	BackupID        int               `json:"backup_id,omitempty"`
+	Image           string            `json:"image,omitempty"`
+	BackupsEnabled  bool              `json:"backups_enabled,omitempty"`
+	PrivateIP       bool              `json:"private_ip,omitempty"`
+
+	// Creation fields that need to be set explicitly false, "", or 0 use pointers
+	SwapSize *int  `json:"swap_size,omitempty"`
+	Booted   *bool `json:"booted,omitempty"`
+}
+
+// InstanceUpdateOptions is an options struct used when Updating an Instance
+type InstanceUpdateOptions struct {
+	Label           string          `json:"label,omitempty"`
+	Group           string          `json:"group,omitempty"`
+	Backups         *InstanceBackup `json:"backups,omitempty"`
+	Alerts          *InstanceAlert  `json:"alerts,omitempty"`
+	WatchdogEnabled *bool           `json:"watchdog_enabled,omitempty"`
+}
+
+// InstanceCloneOptions is an options struct sent when Cloning an Instance
+type InstanceCloneOptions struct {
+	Region string `json:"region,omitempty"`
+	Type   string `json:"type,omitempty"`
+
+	// LinodeID is an optional existing instance to use as the target of the clone
+	LinodeID       int    `json:"linode_id,omitempty"`
+	Label          string `json:"label,omitempty"`
+	Group          string `json:"group,omitempty"`
+	BackupsEnabled bool   `json:"backups_enabled"`
+	Disks          []int  `json:"disks,omitempty"`
+	Configs        []int  `json:"configs,omitempty"`
+}
+
+func (l *Instance) fixDates() *Instance {
+	l.Created, _ = parseDates(l.CreatedStr)
+	l.Updated, _ = parseDates(l.UpdatedStr)
+	return l
+}
+
+// InstancesPagedResponse represents a linode API response for listing
+type InstancesPagedResponse struct {
+	*PageOptions
+	Data []Instance `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Instance
+func (InstancesPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Instances.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends Instances when processing paginated Instance responses
+func (resp *InstancesPagedResponse) appendData(r *InstancesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListInstances lists linode instances
+func (c *Client) ListInstances(ctx context.Context, opts *ListOptions) ([]Instance, error) {
+	response := InstancesPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// GetInstance gets the instance with the provided ID
+func (c *Client) GetInstance(ctx context.Context, linodeID int) (*Instance, error) {
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, linodeID)
+	r, err := coupleAPIErrors(c.R(ctx).
+		SetResult(Instance{}).
+		Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Instance).fixDates(), nil
+}
+
+// CreateInstance creates a Linode instance
+func (c *Client) CreateInstance(ctx context.Context, instance InstanceCreateOptions) (*Instance, error) {
+	var body string
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&Instance{})
+
+	if bodyData, err := json.Marshal(instance); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Instance).fixDates(), nil
+}
+
+// UpdateInstance creates a Linode instance
+func (c *Client) UpdateInstance(ctx context.Context, id int, instance InstanceUpdateOptions) (*Instance, error) {
+	var body string
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	req := c.R(ctx).SetResult(&Instance{})
+
+	if bodyData, err := json.Marshal(instance); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Instance).fixDates(), nil
+}
+
+// RenameInstance renames an Instance
+func (c *Client) RenameInstance(ctx context.Context, linodeID int, label string) (*Instance, error) {
+	return c.UpdateInstance(ctx, linodeID, InstanceUpdateOptions{Label: label})
+}
+
+// DeleteInstance deletes a Linode instance
+func (c *Client) DeleteInstance(ctx context.Context, id int) error {
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}
+
+// BootInstance will boot a Linode instance
+// A configID of 0 will cause Linode to choose the last/best config
+func (c *Client) BootInstance(ctx context.Context, id int, configID int) error {
+	bodyStr := ""
+
+	if configID != 0 {
+		bodyMap := map[string]int{"config_id": configID}
+		bodyJSON, err := json.Marshal(bodyMap)
+		if err != nil {
+			return NewError(err)
+		}
+		bodyStr = string(bodyJSON)
+	}
+
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return err
+	}
+
+	e = fmt.Sprintf("%s/%d/boot", e, id)
+	_, err = coupleAPIErrors(c.R(ctx).
+		SetBody(bodyStr).
+		Post(e))
+
+	return err
+}
+
+// CloneInstance clone an existing Instances Disks and Configuration profiles to another Linode Instance
+func (c *Client) CloneInstance(ctx context.Context, id int, options InstanceCloneOptions) (*Instance, error) {
+	var body string
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d/clone", e, id)
+
+	req := c.R(ctx).SetResult(&Instance{})
+
+	if bodyData, err := json.Marshal(options); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Result().(*Instance).fixDates(), nil
+}
+
+// RebootInstance reboots a Linode instance
+// A configID of 0 will cause Linode to choose the last/best config
+func (c *Client) RebootInstance(ctx context.Context, id int, configID int) error {
+	bodyStr := "{}"
+
+	if configID != 0 {
+		bodyMap := map[string]int{"config_id": configID}
+		bodyJSON, err := json.Marshal(bodyMap)
+		if err != nil {
+			return NewError(err)
+		}
+		bodyStr = string(bodyJSON)
+	}
+
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return err
+	}
+
+	e = fmt.Sprintf("%s/%d/reboot", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).
+		SetBody(bodyStr).
+		Post(e))
+
+	return err
+}
+
+// RebuildInstanceOptions is a struct representing the options to send to the rebuild linode endpoint
+type RebuildInstanceOptions struct {
+	Image           string            `json:"image"`
+	RootPass        string            `json:"root_pass"`
+	AuthorizedKeys  []string          `json:"authorized_keys"`
+	AuthorizedUsers []string          `json:"authorized_users"`
+	StackscriptID   int               `json:"stackscript_id"`
+	StackscriptData map[string]string `json:"stackscript_data"`
+	Booted          bool              `json:"booted"`
+}
+
+// RebuildInstance Deletes all Disks and Configs on this Linode,
+// then deploys a new Image to this Linode with the given attributes.
+func (c *Client) RebuildInstance(ctx context.Context, id int, opts RebuildInstanceOptions) (*Instance, error) {
+	o, err := json.Marshal(opts)
+	if err != nil {
+		return nil, NewError(err)
+	}
+	b := string(o)
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d/rebuild", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).
+		SetBody(b).
+		SetResult(&Instance{}).
+		Post(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Instance).fixDates(), nil
+}
+
+// RescueInstanceOptions fields are those accepted by RescueInstance
+type RescueInstanceOptions struct {
+	Devices InstanceConfigDeviceMap `json:"devices"`
+}
+
+// RescueInstance reboots an instance into a safe environment for performing many system recovery and disk management tasks.
+// Rescue Mode is based on the Finnix recovery distribution, a self-contained and bootable Linux distribution.
+// You can also use Rescue Mode for tasks other than disaster recovery, such as formatting disks to use different filesystems,
+// copying data between disks, and downloading files from a disk via SSH and SFTP.
+func (c *Client) RescueInstance(ctx context.Context, id int, opts RescueInstanceOptions) error {
+	o, err := json.Marshal(opts)
+	if err != nil {
+		return NewError(err)
+	}
+	b := string(o)
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d/rescue", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).
+		SetBody(b).
+		Post(e))
+
+	return err
+}
+
+// ResizeInstance resizes an instance to new Linode type
+func (c *Client) ResizeInstance(ctx context.Context, id int, linodeType string) error {
+	body := fmt.Sprintf("{\"type\":\"%s\"}", linodeType)
+
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d/resize", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).
+		SetBody(body).
+		Post(e))
+
+	return err
+}
+
+// ShutdownInstance - Shutdown an instance
+func (c *Client) ShutdownInstance(ctx context.Context, id int) error {
+	return c.simpleInstanceAction(ctx, "shutdown", id)
+}
+
+// MutateInstance Upgrades a Linode to its next generation.
+func (c *Client) MutateInstance(ctx context.Context, id int) error {
+	return c.simpleInstanceAction(ctx, "mutate", id)
+}
+
+// MigrateInstance - Migrate an instance
+func (c *Client) MigrateInstance(ctx context.Context, id int) error {
+	return c.simpleInstanceAction(ctx, "migrate", id)
+}
+
+// simpleInstanceAction is a helper for Instance actions that take no parameters
+// and return empty responses `{}` unless they return a standard error
+func (c *Client) simpleInstanceAction(ctx context.Context, action string, id int) error {
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d/%s", e, id, action)
+	_, err = coupleAPIErrors(c.R(ctx).Post(e))
+	return err
+}

vendor/github.com/linode/linodego/kernels.go

@@ -0,0 +1,61 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+)
+
+// LinodeKernel represents a Linode Instance kernel object
+type LinodeKernel struct {
+	ID           string `json:"id"`
+	Label        string `json:"label"`
+	Version      string `json:"version"`
+	Architecture string `json:"architecture"`
+	KVM          bool   `json:"kvm"`
+	XEN          bool   `json:"xen"`
+	PVOPS        bool   `json:"pvops"`
+}
+
+// LinodeKernelsPagedResponse represents a Linode kernels API response for listing
+type LinodeKernelsPagedResponse struct {
+	*PageOptions
+	Data []LinodeKernel `json:"data"`
+}
+
+// ListKernels lists linode kernels
+func (c *Client) ListKernels(ctx context.Context, opts *ListOptions) ([]LinodeKernel, error) {
+	response := LinodeKernelsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+func (LinodeKernelsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Kernels.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+func (resp *LinodeKernelsPagedResponse) appendData(r *LinodeKernelsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// GetKernel gets the kernel with the provided ID
+func (c *Client) GetKernel(ctx context.Context, kernelID string) (*LinodeKernel, error) {
+	e, err := c.Kernels.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, kernelID)
+	r, err := c.R(ctx).
+		SetResult(&LinodeKernel{}).
+		Get(e)
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*LinodeKernel), nil
+}

vendor/github.com/linode/linodego/longview.go

@@ -0,0 +1,67 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+)
+
+// LongviewClient represents a LongviewClient object
+type LongviewClient struct {
+	ID int `json:"id"`
+	// UpdatedStr string `json:"updated"`
+	// Updated *time.Time `json:"-"`
+}
+
+// LongviewClientsPagedResponse represents a paginated LongviewClient API response
+type LongviewClientsPagedResponse struct {
+	*PageOptions
+	Data []LongviewClient `json:"data"`
+}
+
+// endpoint gets the endpoint URL for LongviewClient
+func (LongviewClientsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.LongviewClients.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends LongviewClients when processing paginated LongviewClient responses
+func (resp *LongviewClientsPagedResponse) appendData(r *LongviewClientsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListLongviewClients lists LongviewClients
+func (c *Client) ListLongviewClients(ctx context.Context, opts *ListOptions) ([]LongviewClient, error) {
+	response := LongviewClientsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (v *LongviewClient) fixDates() *LongviewClient {
+	// v.Created, _ = parseDates(v.CreatedStr)
+	// v.Updated, _ = parseDates(v.UpdatedStr)
+	return v
+}
+
+// GetLongviewClient gets the template with the provided ID
+func (c *Client) GetLongviewClient(ctx context.Context, id string) (*LongviewClient, error) {
+	e, err := c.LongviewClients.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+	r, err := c.R(ctx).SetResult(&LongviewClient{}).Get(e)
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*LongviewClient).fixDates(), nil
+}

vendor/github.com/linode/linodego/longview_subscriptions.go

@@ -0,0 +1,70 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+)
+
+// LongviewSubscription represents a LongviewSubscription object
+type LongviewSubscription struct {
+	ID              string       `json:"id"`
+	Label           string       `json:"label"`
+	ClientsIncluded int          `json:"clients_included"`
+	Price           *LinodePrice `json:"price"`
+	// UpdatedStr string `json:"updated"`
+	// Updated *time.Time `json:"-"`
+}
+
+// LongviewSubscriptionsPagedResponse represents a paginated LongviewSubscription API response
+type LongviewSubscriptionsPagedResponse struct {
+	*PageOptions
+	Data []LongviewSubscription `json:"data"`
+}
+
+// endpoint gets the endpoint URL for LongviewSubscription
+func (LongviewSubscriptionsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.LongviewSubscriptions.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends LongviewSubscriptions when processing paginated LongviewSubscription responses
+func (resp *LongviewSubscriptionsPagedResponse) appendData(r *LongviewSubscriptionsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListLongviewSubscriptions lists LongviewSubscriptions
+func (c *Client) ListLongviewSubscriptions(ctx context.Context, opts *ListOptions) ([]LongviewSubscription, error) {
+	response := LongviewSubscriptionsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (v *LongviewSubscription) fixDates() *LongviewSubscription {
+	// v.Created, _ = parseDates(v.CreatedStr)
+	// v.Updated, _ = parseDates(v.UpdatedStr)
+	return v
+}
+
+// GetLongviewSubscription gets the template with the provided ID
+func (c *Client) GetLongviewSubscription(ctx context.Context, id string) (*LongviewSubscription, error) {
+	e, err := c.LongviewSubscriptions.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+	r, err := c.R(ctx).SetResult(&LongviewSubscription{}).Get(e)
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*LongviewSubscription).fixDates(), nil
+}

vendor/github.com/linode/linodego/managed.go

@@ -0,0 +1 @@
+package linodego

vendor/github.com/linode/linodego/network_ips.go

@@ -0,0 +1,50 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+)
+
+// IPAddressesPagedResponse represents a paginated IPAddress API response
+type IPAddressesPagedResponse struct {
+	*PageOptions
+	Data []InstanceIP `json:"data"`
+}
+
+// endpoint gets the endpoint URL for IPAddress
+func (IPAddressesPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.IPAddresses.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends IPAddresses when processing paginated InstanceIPAddress responses
+func (resp *IPAddressesPagedResponse) appendData(r *IPAddressesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListIPAddresses lists IPAddresses
+func (c *Client) ListIPAddresses(ctx context.Context, opts *ListOptions) ([]InstanceIP, error) {
+	response := IPAddressesPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// GetIPAddress gets the template with the provided ID
+func (c *Client) GetIPAddress(ctx context.Context, id string) (*InstanceIP, error) {
+	e, err := c.IPAddresses.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&InstanceIP{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*InstanceIP), nil
+}

vendor/github.com/linode/linodego/network_pools.go

@@ -0,0 +1,50 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+)
+
+// IPv6PoolsPagedResponse represents a paginated IPv6Pool API response
+type IPv6PoolsPagedResponse struct {
+	*PageOptions
+	Data []IPv6Range `json:"data"`
+}
+
+// endpoint gets the endpoint URL for IPv6Pool
+func (IPv6PoolsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.IPv6Pools.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends IPv6Pools when processing paginated IPv6Pool responses
+func (resp *IPv6PoolsPagedResponse) appendData(r *IPv6PoolsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListIPv6Pools lists IPv6Pools
+func (c *Client) ListIPv6Pools(ctx context.Context, opts *ListOptions) ([]IPv6Range, error) {
+	response := IPv6PoolsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// GetIPv6Pool gets the template with the provided ID
+func (c *Client) GetIPv6Pool(ctx context.Context, id string) (*IPv6Range, error) {
+	e, err := c.IPv6Pools.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&IPv6Range{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*IPv6Range), nil
+}

vendor/github.com/linode/linodego/network_ranges.go

@@ -0,0 +1,50 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+)
+
+// IPv6RangesPagedResponse represents a paginated IPv6Range API response
+type IPv6RangesPagedResponse struct {
+	*PageOptions
+	Data []IPv6Range `json:"data"`
+}
+
+// endpoint gets the endpoint URL for IPv6Range
+func (IPv6RangesPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.IPv6Ranges.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends IPv6Ranges when processing paginated IPv6Range responses
+func (resp *IPv6RangesPagedResponse) appendData(r *IPv6RangesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListIPv6Ranges lists IPv6Ranges
+func (c *Client) ListIPv6Ranges(ctx context.Context, opts *ListOptions) ([]IPv6Range, error) {
+	response := IPv6RangesPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// GetIPv6Range gets the template with the provided ID
+func (c *Client) GetIPv6Range(ctx context.Context, id string) (*IPv6Range, error) {
+	e, err := c.IPv6Ranges.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&IPv6Range{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*IPv6Range), nil
+}

vendor/github.com/linode/linodego/nodebalancer.go

@@ -0,0 +1,192 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// NodeBalancer represents a NodeBalancer object
+type NodeBalancer struct {
+	CreatedStr string `json:"created"`
+	UpdatedStr string `json:"updated"`
+	// This NodeBalancer's unique ID.
+	ID int `json:"id"`
+	// This NodeBalancer's label. These must be unique on your Account.
+	Label *string `json:"label"`
+	// The Region where this NodeBalancer is located. NodeBalancers only support backends in the same Region.
+	Region string `json:"region"`
+	// This NodeBalancer's hostname, ending with .nodebalancer.linode.com
+	Hostname *string `json:"hostname"`
+	// This NodeBalancer's public IPv4 address.
+	IPv4 *string `json:"ipv4"`
+	// This NodeBalancer's public IPv6 address.
+	IPv6 *string `json:"ipv6"`
+	// Throttle connections per second (0-20). Set to 0 (zero) to disable throttling.
+	ClientConnThrottle int `json:"client_conn_throttle"`
+	// Information about the amount of transfer this NodeBalancer has had so far this month.
+	Transfer NodeBalancerTransfer `json:"transfer"`
+
+	Created *time.Time `json:"-"`
+	Updated *time.Time `json:"-"`
+}
+
+// NodeBalancerTransfer contains information about the amount of transfer a NodeBalancer has had in the current month
+type NodeBalancerTransfer struct {
+	// The total transfer, in MB, used by this NodeBalancer this month.
+	Total *float64 `json:"total"`
+	// The total inbound transfer, in MB, used for this NodeBalancer this month.
+	Out *float64 `json:"out"`
+	// The total outbound transfer, in MB, used for this NodeBalancer this month.
+	In *float64 `json:"in"`
+}
+
+// NodeBalancerCreateOptions are the options permitted for CreateNodeBalancer
+type NodeBalancerCreateOptions struct {
+	Label              *string                            `json:"label,omitempty"`
+	Region             string                             `json:"region,omitempty"`
+	ClientConnThrottle *int                               `json:"client_conn_throttle,omitempty"`
+	Configs            []*NodeBalancerConfigCreateOptions `json:"configs,omitempty"`
+}
+
+// NodeBalancerUpdateOptions are the options permitted for UpdateNodeBalancer
+type NodeBalancerUpdateOptions struct {
+	Label              *string `json:"label,omitempty"`
+	ClientConnThrottle *int    `json:"client_conn_throttle,omitempty"`
+}
+
+// GetCreateOptions converts a NodeBalancer to NodeBalancerCreateOptions for use in CreateNodeBalancer
+func (i NodeBalancer) GetCreateOptions() NodeBalancerCreateOptions {
+	return NodeBalancerCreateOptions{
+		Label:              i.Label,
+		Region:             i.Region,
+		ClientConnThrottle: &i.ClientConnThrottle,
+	}
+}
+
+// GetUpdateOptions converts a NodeBalancer to NodeBalancerUpdateOptions for use in UpdateNodeBalancer
+func (i NodeBalancer) GetUpdateOptions() NodeBalancerUpdateOptions {
+	return NodeBalancerUpdateOptions{
+		Label:              i.Label,
+		ClientConnThrottle: &i.ClientConnThrottle,
+	}
+}
+
+// NodeBalancersPagedResponse represents a paginated NodeBalancer API response
+type NodeBalancersPagedResponse struct {
+	*PageOptions
+	Data []NodeBalancer `json:"data"`
+}
+
+func (NodeBalancersPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.NodeBalancers.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+func (resp *NodeBalancersPagedResponse) appendData(r *NodeBalancersPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListNodeBalancers lists NodeBalancers
+func (c *Client) ListNodeBalancers(ctx context.Context, opts *ListOptions) ([]NodeBalancer, error) {
+	response := NodeBalancersPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (i *NodeBalancer) fixDates() *NodeBalancer {
+	i.Created, _ = parseDates(i.CreatedStr)
+	i.Updated, _ = parseDates(i.UpdatedStr)
+	return i
+}
+
+// GetNodeBalancer gets the NodeBalancer with the provided ID
+func (c *Client) GetNodeBalancer(ctx context.Context, id int) (*NodeBalancer, error) {
+	e, err := c.NodeBalancers.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).
+		SetResult(&NodeBalancer{}).
+		Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancer).fixDates(), nil
+}
+
+// CreateNodeBalancer creates a NodeBalancer
+func (c *Client) CreateNodeBalancer(ctx context.Context, nodebalancer NodeBalancerCreateOptions) (*NodeBalancer, error) {
+	var body string
+	e, err := c.NodeBalancers.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&NodeBalancer{})
+
+	if bodyData, err := json.Marshal(nodebalancer); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetHeader("Content-Type", "application/json").
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancer).fixDates(), nil
+}
+
+// UpdateNodeBalancer updates the NodeBalancer with the specified id
+func (c *Client) UpdateNodeBalancer(ctx context.Context, id int, updateOpts NodeBalancerUpdateOptions) (*NodeBalancer, error) {
+	var body string
+	e, err := c.NodeBalancers.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	req := c.R(ctx).SetResult(&NodeBalancer{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancer).fixDates(), nil
+}
+
+// DeleteNodeBalancer deletes the NodeBalancer with the specified id
+func (c *Client) DeleteNodeBalancer(ctx context.Context, id int) error {
+	e, err := c.NodeBalancers.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+
+	return err
+}

vendor/github.com/linode/linodego/nodebalancer_config_nodes.go

@@ -0,0 +1,186 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// NodeBalancerNode objects represent a backend that can accept traffic for a NodeBalancer Config
+type NodeBalancerNode struct {
+	ID             int      `json:"id"`
+	Address        string   `json:"address"`
+	Label          string   `json:"label"`
+	Status         string   `json:"status"`
+	Weight         int      `json:"weight"`
+	Mode           NodeMode `json:"mode"`
+	ConfigID       int      `json:"config_id"`
+	NodeBalancerID int      `json:"nodebalancer_id"`
+}
+
+// NodeMode is the mode a NodeBalancer should use when sending traffic to a NodeBalancer Node
+type NodeMode string
+
+var (
+	// ModeAccept is the NodeMode indicating a NodeBalancer Node is accepting traffic
+	ModeAccept NodeMode = "accept"
+
+	// ModeReject is the NodeMode indicating a NodeBalancer Node is not receiving traffic
+	ModeReject NodeMode = "reject"
+
+	// ModeDrain is the NodeMode indicating a NodeBalancer Node is not receiving new traffic, but may continue receiving traffic from pinned connections
+	ModeDrain NodeMode = "drain"
+)
+
+// NodeBalancerNodeCreateOptions fields are those accepted by CreateNodeBalancerNode
+type NodeBalancerNodeCreateOptions struct {
+	Address string   `json:"address"`
+	Label   string   `json:"label"`
+	Weight  int      `json:"weight,omitempty"`
+	Mode    NodeMode `json:"mode,omitempty"`
+}
+
+// NodeBalancerNodeUpdateOptions fields are those accepted by UpdateNodeBalancerNode
+type NodeBalancerNodeUpdateOptions struct {
+	Address string   `json:"address,omitempty"`
+	Label   string   `json:"label,omitempty"`
+	Weight  int      `json:"weight,omitempty"`
+	Mode    NodeMode `json:"mode,omitempty"`
+}
+
+// GetCreateOptions converts a NodeBalancerNode to NodeBalancerNodeCreateOptions for use in CreateNodeBalancerNode
+func (i NodeBalancerNode) GetCreateOptions() NodeBalancerNodeCreateOptions {
+	return NodeBalancerNodeCreateOptions{
+		Address: i.Address,
+		Label:   i.Label,
+		Weight:  i.Weight,
+		Mode:    i.Mode,
+	}
+}
+
+// GetUpdateOptions converts a NodeBalancerNode to NodeBalancerNodeUpdateOptions for use in UpdateNodeBalancerNode
+func (i NodeBalancerNode) GetUpdateOptions() NodeBalancerNodeUpdateOptions {
+	return NodeBalancerNodeUpdateOptions{
+		Address: i.Address,
+		Label:   i.Label,
+		Weight:  i.Weight,
+		Mode:    i.Mode,
+	}
+}
+
+// NodeBalancerNodesPagedResponse represents a paginated NodeBalancerNode API response
+type NodeBalancerNodesPagedResponse struct {
+	*PageOptions
+	Data []NodeBalancerNode `json:"data"`
+}
+
+// endpoint gets the endpoint URL for NodeBalancerNode
+func (NodeBalancerNodesPagedResponse) endpointWithTwoIDs(c *Client, nodebalancerID int, configID int) string {
+	endpoint, err := c.NodeBalancerNodes.endpointWithID(nodebalancerID, configID)
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends NodeBalancerNodes when processing paginated NodeBalancerNode responses
+func (resp *NodeBalancerNodesPagedResponse) appendData(r *NodeBalancerNodesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListNodeBalancerNodes lists NodeBalancerNodes
+func (c *Client) ListNodeBalancerNodes(ctx context.Context, nodebalancerID int, configID int, opts *ListOptions) ([]NodeBalancerNode, error) {
+	response := NodeBalancerNodesPagedResponse{}
+	err := c.listHelperWithTwoIDs(ctx, &response, nodebalancerID, configID, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (i *NodeBalancerNode) fixDates() *NodeBalancerNode {
+	return i
+}
+
+// GetNodeBalancerNode gets the template with the provided ID
+func (c *Client) GetNodeBalancerNode(ctx context.Context, nodebalancerID int, configID int, nodeID int) (*NodeBalancerNode, error) {
+	e, err := c.NodeBalancerNodes.endpointWithID(nodebalancerID, configID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, nodeID)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&NodeBalancerNode{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancerNode).fixDates(), nil
+}
+
+// CreateNodeBalancerNode creates a NodeBalancerNode
+func (c *Client) CreateNodeBalancerNode(ctx context.Context, nodebalancerID int, configID int, createOpts NodeBalancerNodeCreateOptions) (*NodeBalancerNode, error) {
+	var body string
+	e, err := c.NodeBalancerNodes.endpointWithID(nodebalancerID, configID)
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&NodeBalancerNode{})
+
+	if bodyData, err := json.Marshal(createOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancerNode).fixDates(), nil
+}
+
+// UpdateNodeBalancerNode updates the NodeBalancerNode with the specified id
+func (c *Client) UpdateNodeBalancerNode(ctx context.Context, nodebalancerID int, configID int, nodeID int, updateOpts NodeBalancerNodeUpdateOptions) (*NodeBalancerNode, error) {
+	var body string
+	e, err := c.NodeBalancerNodes.endpointWithID(nodebalancerID, configID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, nodeID)
+
+	req := c.R(ctx).SetResult(&NodeBalancerNode{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancerNode).fixDates(), nil
+}
+
+// DeleteNodeBalancerNode deletes the NodeBalancerNode with the specified id
+func (c *Client) DeleteNodeBalancerNode(ctx context.Context, nodebalancerID int, configID int, nodeID int) error {
+	e, err := c.NodeBalancerNodes.endpointWithID(nodebalancerID, configID)
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, nodeID)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}

vendor/github.com/linode/linodego/nodebalancer_configs.go

@@ -0,0 +1,334 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// NodeBalancerConfig objects allow a NodeBalancer to accept traffic on a new port
+type NodeBalancerConfig struct {
+	ID             int                     `json:"id"`
+	Port           int                     `json:"port"`
+	Protocol       ConfigProtocol          `json:"protocol"`
+	Algorithm      ConfigAlgorithm         `json:"algorithm"`
+	Stickiness     ConfigStickiness        `json:"stickiness"`
+	Check          ConfigCheck             `json:"check"`
+	CheckInterval  int                     `json:"check_interval"`
+	CheckAttempts  int                     `json:"check_attempts"`
+	CheckPath      string                  `json:"check_path"`
+	CheckBody      string                  `json:"check_body"`
+	CheckPassive   bool                    `json:"check_passive"`
+	CheckTimeout   int                     `json:"check_timeout"`
+	CipherSuite    ConfigCipher            `json:"cipher_suite"`
+	NodeBalancerID int                     `json:"nodebalancer_id"`
+	SSLCommonName  string                  `json:"ssl_commonname"`
+	SSLFingerprint string                  `json:"ssl_fingerprint"`
+	SSLCert        string                  `json:"ssl_cert"`
+	SSLKey         string                  `json:"ssl_key"`
+	NodesStatus    *NodeBalancerNodeStatus `json:"nodes_status"`
+}
+
+// ConfigAlgorithm constants start with Algorithm and include Linode API NodeBalancer Config Algorithms
+type ConfigAlgorithm string
+
+// ConfigAlgorithm constants reflect the NodeBalancer Config Algorithm
+const (
+	AlgorithmRoundRobin ConfigAlgorithm = "roundrobin"
+	AlgorithmLeastConn  ConfigAlgorithm = "leastconn"
+	AlgorithmSource     ConfigAlgorithm = "source"
+)
+
+// ConfigStickiness constants start with Stickiness and include Linode API NodeBalancer Config Stickiness
+type ConfigStickiness string
+
+// ConfigStickiness constants reflect the node stickiness method for a NodeBalancer Config
+const (
+	StickinessNone       ConfigStickiness = "none"
+	StickinessTable      ConfigStickiness = "table"
+	StickinessHTTPCookie ConfigStickiness = "http_cookie"
+)
+
+// ConfigCheck constants start with Check and include Linode API NodeBalancer Config Check methods
+type ConfigCheck string
+
+// ConfigCheck constants reflect the node health status checking method for a NodeBalancer Config
+const (
+	CheckNone       ConfigCheck = "none"
+	CheckConnection ConfigCheck = "connection"
+	CheckHTTP       ConfigCheck = "http"
+	CheckHTTPBody   ConfigCheck = "http_body"
+)
+
+// ConfigProtocol constants start with Protocol and include Linode API Nodebalancer Config protocols
+type ConfigProtocol string
+
+// ConfigProtocol constants reflect the protocol used by a NodeBalancer Config
+const (
+	ProtocolHTTP  ConfigProtocol = "http"
+	ProtocolHTTPS ConfigProtocol = "https"
+	ProtocolTCP   ConfigProtocol = "tcp"
+)
+
+// ConfigCipher constants start with Cipher and include Linode API NodeBalancer Config Cipher values
+type ConfigCipher string
+
+// ConfigCipher constants reflect the preferred cipher set for a NodeBalancer Config
+const (
+	CipherRecommended ConfigCipher = "recommended"
+	CipherLegacy      ConfigCipher = "legacy"
+)
+
+// NodeBalancerNodeStatus represents the total number of nodes whose status is Up or Down
+type NodeBalancerNodeStatus struct {
+	Up   int `json:"up"`
+	Down int `json:"down"`
+}
+
+// NodeBalancerConfigCreateOptions are permitted by CreateNodeBalancerConfig
+type NodeBalancerConfigCreateOptions struct {
+	Port          int                             `json:"port"`
+	Protocol      ConfigProtocol                  `json:"protocol,omitempty"`
+	Algorithm     ConfigAlgorithm                 `json:"algorithm,omitempty"`
+	Stickiness    ConfigStickiness                `json:"stickiness,omitempty"`
+	Check         ConfigCheck                     `json:"check,omitempty"`
+	CheckInterval int                             `json:"check_interval,omitempty"`
+	CheckAttempts int                             `json:"check_attempts,omitempty"`
+	CheckPath     string                          `json:"check_path,omitempty"`
+	CheckBody     string                          `json:"check_body,omitempty"`
+	CheckPassive  *bool                           `json:"check_passive,omitempty"`
+	CheckTimeout  int                             `json:"check_timeout,omitempty"`
+	CipherSuite   ConfigCipher                    `json:"cipher_suite,omitempty"`
+	SSLCert       string                          `json:"ssl_cert,omitempty"`
+	SSLKey        string                          `json:"ssl_key,omitempty"`
+	Nodes         []NodeBalancerNodeCreateOptions `json:"nodes,omitempty"`
+}
+
+// NodeBalancerConfigRebuildOptions used by RebuildNodeBalancerConfig
+type NodeBalancerConfigRebuildOptions struct {
+	Port          int                             `json:"port"`
+	Protocol      ConfigProtocol                  `json:"protocol,omitempty"`
+	Algorithm     ConfigAlgorithm                 `json:"algorithm,omitempty"`
+	Stickiness    ConfigStickiness                `json:"stickiness,omitempty"`
+	Check         ConfigCheck                     `json:"check,omitempty"`
+	CheckInterval int                             `json:"check_interval,omitempty"`
+	CheckAttempts int                             `json:"check_attempts,omitempty"`
+	CheckPath     string                          `json:"check_path,omitempty"`
+	CheckBody     string                          `json:"check_body,omitempty"`
+	CheckPassive  *bool                           `json:"check_passive,omitempty"`
+	CheckTimeout  int                             `json:"check_timeout,omitempty"`
+	CipherSuite   ConfigCipher                    `json:"cipher_suite,omitempty"`
+	SSLCert       string                          `json:"ssl_cert,omitempty"`
+	SSLKey        string                          `json:"ssl_key,omitempty"`
+	Nodes         []NodeBalancerNodeCreateOptions `json:"nodes"`
+}
+
+// NodeBalancerConfigUpdateOptions are permitted by UpdateNodeBalancerConfig
+type NodeBalancerConfigUpdateOptions NodeBalancerConfigCreateOptions
+
+// GetCreateOptions converts a NodeBalancerConfig to NodeBalancerConfigCreateOptions for use in CreateNodeBalancerConfig
+func (i NodeBalancerConfig) GetCreateOptions() NodeBalancerConfigCreateOptions {
+	return NodeBalancerConfigCreateOptions{
+		Port:          i.Port,
+		Protocol:      i.Protocol,
+		Algorithm:     i.Algorithm,
+		Stickiness:    i.Stickiness,
+		Check:         i.Check,
+		CheckInterval: i.CheckInterval,
+		CheckAttempts: i.CheckAttempts,
+		CheckTimeout:  i.CheckTimeout,
+		CheckPath:     i.CheckPath,
+		CheckBody:     i.CheckBody,
+		CheckPassive:  &i.CheckPassive,
+		CipherSuite:   i.CipherSuite,
+		SSLCert:       i.SSLCert,
+		SSLKey:        i.SSLKey,
+	}
+}
+
+// GetUpdateOptions converts a NodeBalancerConfig to NodeBalancerConfigUpdateOptions for use in UpdateNodeBalancerConfig
+func (i NodeBalancerConfig) GetUpdateOptions() NodeBalancerConfigUpdateOptions {
+	return NodeBalancerConfigUpdateOptions{
+		Port:          i.Port,
+		Protocol:      i.Protocol,
+		Algorithm:     i.Algorithm,
+		Stickiness:    i.Stickiness,
+		Check:         i.Check,
+		CheckInterval: i.CheckInterval,
+		CheckAttempts: i.CheckAttempts,
+		CheckPath:     i.CheckPath,
+		CheckBody:     i.CheckBody,
+		CheckPassive:  &i.CheckPassive,
+		CheckTimeout:  i.CheckTimeout,
+		CipherSuite:   i.CipherSuite,
+		SSLCert:       i.SSLCert,
+		SSLKey:        i.SSLKey,
+	}
+}
+
+// GetRebuildOptions converts a NodeBalancerConfig to NodeBalancerConfigRebuildOptions for use in RebuildNodeBalancerConfig
+func (i NodeBalancerConfig) GetRebuildOptions() NodeBalancerConfigRebuildOptions {
+	return NodeBalancerConfigRebuildOptions{
+		Port:          i.Port,
+		Protocol:      i.Protocol,
+		Algorithm:     i.Algorithm,
+		Stickiness:    i.Stickiness,
+		Check:         i.Check,
+		CheckInterval: i.CheckInterval,
+		CheckAttempts: i.CheckAttempts,
+		CheckTimeout:  i.CheckTimeout,
+		CheckPath:     i.CheckPath,
+		CheckBody:     i.CheckBody,
+		CheckPassive:  &i.CheckPassive,
+		CipherSuite:   i.CipherSuite,
+		SSLCert:       i.SSLCert,
+		SSLKey:        i.SSLKey,
+		Nodes:         make([]NodeBalancerNodeCreateOptions, 0),
+	}
+}
+
+// NodeBalancerConfigsPagedResponse represents a paginated NodeBalancerConfig API response
+type NodeBalancerConfigsPagedResponse struct {
+	*PageOptions
+	Data []NodeBalancerConfig `json:"data"`
+}
+
+// endpointWithID gets the endpoint URL for NodeBalancerConfig
+func (NodeBalancerConfigsPagedResponse) endpointWithID(c *Client, id int) string {
+	endpoint, err := c.NodeBalancerConfigs.endpointWithID(id)
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends NodeBalancerConfigs when processing paginated NodeBalancerConfig responses
+func (resp *NodeBalancerConfigsPagedResponse) appendData(r *NodeBalancerConfigsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListNodeBalancerConfigs lists NodeBalancerConfigs
+func (c *Client) ListNodeBalancerConfigs(ctx context.Context, nodebalancerID int, opts *ListOptions) ([]NodeBalancerConfig, error) {
+	response := NodeBalancerConfigsPagedResponse{}
+	err := c.listHelperWithID(ctx, &response, nodebalancerID, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (i *NodeBalancerConfig) fixDates() *NodeBalancerConfig {
+	return i
+}
+
+// GetNodeBalancerConfig gets the template with the provided ID
+func (c *Client) GetNodeBalancerConfig(ctx context.Context, nodebalancerID int, configID int) (*NodeBalancerConfig, error) {
+	e, err := c.NodeBalancerConfigs.endpointWithID(nodebalancerID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, configID)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&NodeBalancerConfig{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancerConfig).fixDates(), nil
+}
+
+// CreateNodeBalancerConfig creates a NodeBalancerConfig
+func (c *Client) CreateNodeBalancerConfig(ctx context.Context, nodebalancerID int, nodebalancerConfig NodeBalancerConfigCreateOptions) (*NodeBalancerConfig, error) {
+	var body string
+	e, err := c.NodeBalancerConfigs.endpointWithID(nodebalancerID)
+
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&NodeBalancerConfig{})
+
+	if bodyData, err := json.Marshal(nodebalancerConfig); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetHeader("Content-Type", "application/json").
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancerConfig).fixDates(), nil
+}
+
+// UpdateNodeBalancerConfig updates the NodeBalancerConfig with the specified id
+func (c *Client) UpdateNodeBalancerConfig(ctx context.Context, nodebalancerID int, configID int, updateOpts NodeBalancerConfigUpdateOptions) (*NodeBalancerConfig, error) {
+	var body string
+	e, err := c.NodeBalancerConfigs.endpointWithID(nodebalancerID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, configID)
+
+	req := c.R(ctx).SetResult(&NodeBalancerConfig{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancerConfig).fixDates(), nil
+}
+
+// DeleteNodeBalancerConfig deletes the NodeBalancerConfig with the specified id
+func (c *Client) DeleteNodeBalancerConfig(ctx context.Context, nodebalancerID int, configID int) error {
+	e, err := c.NodeBalancerConfigs.endpointWithID(nodebalancerID)
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, configID)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}
+
+// RebuildNodeBalancerConfig updates the NodeBalancer with the specified id
+func (c *Client) RebuildNodeBalancerConfig(ctx context.Context, nodeBalancerID int, configID int, rebuildOpts NodeBalancerConfigRebuildOptions) (*NodeBalancerConfig, error) {
+	var body string
+	e, err := c.NodeBalancerConfigs.endpointWithID(nodeBalancerID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d/rebuild", e, configID)
+
+	req := c.R(ctx).SetResult(&NodeBalancerConfig{})
+
+	if bodyData, err := json.Marshal(rebuildOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancerConfig).fixDates(), nil
+}

vendor/github.com/linode/linodego/pagination.go

@@ -0,0 +1,481 @@
+package linodego
+
+/**
+ * Pagination and Filtering types and helpers
+ */
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"strconv"
+
+	"github.com/go-resty/resty"
+)
+
+// PageOptions are the pagination parameters for List endpoints
+type PageOptions struct {
+	Page    int `url:"page,omitempty" json:"page"`
+	Pages   int `url:"pages,omitempty" json:"pages"`
+	Results int `url:"results,omitempty" json:"results"`
+}
+
+// ListOptions are the pagination and filtering (TODO) parameters for endpoints
+type ListOptions struct {
+	*PageOptions
+	Filter string
+}
+
+// NewListOptions simplified construction of ListOptions using only
+// the two writable properties, Page and Filter
+func NewListOptions(Page int, Filter string) *ListOptions {
+	return &ListOptions{PageOptions: &PageOptions{Page: Page}, Filter: Filter}
+
+}
+
+// listHelper abstracts fetching and pagination for GET endpoints that
+// do not require any Ids (top level endpoints).
+// When opts (or opts.Page) is nil, all pages will be fetched and
+// returned in a single (endpoint-specific)PagedResponse
+// opts.results and opts.pages will be updated from the API response
+func (c *Client) listHelper(ctx context.Context, i interface{}, opts *ListOptions) error {
+	req := c.R(ctx)
+	if opts != nil && opts.PageOptions != nil && opts.Page > 0 {
+		req.SetQueryParam("page", strconv.Itoa(opts.Page))
+	}
+
+	var (
+		err     error
+		pages   int
+		results int
+		r       *resty.Response
+	)
+
+	if opts != nil && len(opts.Filter) > 0 {
+		req.SetHeader("X-Filter", opts.Filter)
+	}
+
+	switch v := i.(type) {
+	case *LinodeKernelsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(LinodeKernelsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*LinodeKernelsPagedResponse).Pages
+			results = r.Result().(*LinodeKernelsPagedResponse).Results
+			v.appendData(r.Result().(*LinodeKernelsPagedResponse))
+		}
+	case *LinodeTypesPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(LinodeTypesPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*LinodeTypesPagedResponse).Pages
+			results = r.Result().(*LinodeTypesPagedResponse).Results
+			v.appendData(r.Result().(*LinodeTypesPagedResponse))
+		}
+	case *ImagesPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(ImagesPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*ImagesPagedResponse).Pages
+			results = r.Result().(*ImagesPagedResponse).Results
+			v.appendData(r.Result().(*ImagesPagedResponse))
+		}
+	case *StackscriptsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(StackscriptsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*StackscriptsPagedResponse).Pages
+			results = r.Result().(*StackscriptsPagedResponse).Results
+			v.appendData(r.Result().(*StackscriptsPagedResponse))
+		}
+	case *InstancesPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(InstancesPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*InstancesPagedResponse).Pages
+			results = r.Result().(*InstancesPagedResponse).Results
+			v.appendData(r.Result().(*InstancesPagedResponse))
+		}
+	case *RegionsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(RegionsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*RegionsPagedResponse).Pages
+			results = r.Result().(*RegionsPagedResponse).Results
+			v.appendData(r.Result().(*RegionsPagedResponse))
+		}
+	case *VolumesPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(VolumesPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*VolumesPagedResponse).Pages
+			results = r.Result().(*VolumesPagedResponse).Results
+			v.appendData(r.Result().(*VolumesPagedResponse))
+		}
+	case *DomainsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(DomainsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			response, ok := r.Result().(*DomainsPagedResponse)
+			if !ok {
+				return fmt.Errorf("Response is not a *DomainsPagedResponse")
+			}
+			pages = response.Pages
+			results = response.Results
+			v.appendData(response)
+		}
+	case *EventsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(EventsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*EventsPagedResponse).Pages
+			results = r.Result().(*EventsPagedResponse).Results
+			v.appendData(r.Result().(*EventsPagedResponse))
+		}
+	case *LongviewSubscriptionsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(LongviewSubscriptionsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*LongviewSubscriptionsPagedResponse).Pages
+			results = r.Result().(*LongviewSubscriptionsPagedResponse).Results
+			v.appendData(r.Result().(*LongviewSubscriptionsPagedResponse))
+		}
+	case *LongviewClientsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(LongviewClientsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*LongviewClientsPagedResponse).Pages
+			results = r.Result().(*LongviewClientsPagedResponse).Results
+			v.appendData(r.Result().(*LongviewClientsPagedResponse))
+		}
+	case *IPAddressesPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(IPAddressesPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*IPAddressesPagedResponse).Pages
+			results = r.Result().(*IPAddressesPagedResponse).Results
+			v.appendData(r.Result().(*IPAddressesPagedResponse))
+		}
+	case *IPv6PoolsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(IPv6PoolsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*IPv6PoolsPagedResponse).Pages
+			results = r.Result().(*IPv6PoolsPagedResponse).Results
+			v.appendData(r.Result().(*IPv6PoolsPagedResponse))
+		}
+	case *IPv6RangesPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(IPv6RangesPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*IPv6RangesPagedResponse).Pages
+			results = r.Result().(*IPv6RangesPagedResponse).Results
+			v.appendData(r.Result().(*IPv6RangesPagedResponse))
+			// @TODO consolidate this type with IPv6PoolsPagedResponse?
+		}
+	case *SSHKeysPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(SSHKeysPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			response, ok := r.Result().(*SSHKeysPagedResponse)
+			if !ok {
+				return fmt.Errorf("Response is not a *SSHKeysPagedResponse")
+			}
+			pages = response.Pages
+			results = response.Results
+			v.appendData(response)
+		}
+	case *TicketsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(TicketsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*TicketsPagedResponse).Pages
+			results = r.Result().(*TicketsPagedResponse).Results
+			v.appendData(r.Result().(*TicketsPagedResponse))
+		}
+	case *InvoicesPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(InvoicesPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*InvoicesPagedResponse).Pages
+			results = r.Result().(*InvoicesPagedResponse).Results
+			v.appendData(r.Result().(*InvoicesPagedResponse))
+		}
+	case *NotificationsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(NotificationsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*NotificationsPagedResponse).Pages
+			results = r.Result().(*NotificationsPagedResponse).Results
+			v.appendData(r.Result().(*NotificationsPagedResponse))
+		}
+	case *NodeBalancersPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(NodeBalancersPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*NodeBalancersPagedResponse).Pages
+			results = r.Result().(*NodeBalancersPagedResponse).Results
+			v.appendData(r.Result().(*NodeBalancersPagedResponse))
+		}
+	/**
+	case AccountOauthClientsPagedResponse:
+		if r, err = req.SetResult(v).Get(v.endpoint(c)); r.Error() != nil {
+			return NewError(r)
+		} else if err == nil {
+			pages = r.Result().(*AccountOauthClientsPagedResponse).Pages
+			results = r.Result().(*AccountOauthClientsPagedResponse).Results
+			v.appendData(r.Result().(*AccountOauthClientsPagedResponse))
+		}
+	case AccountPaymentsPagedResponse:
+		if r, err = req.SetResult(v).Get(v.endpoint(c)); r.Error() != nil {
+			return NewError(r)
+		} else if err == nil {
+			pages = r.Result().(*AccountPaymentsPagedResponse).Pages
+			results = r.Result().(*AccountPaymentsPagedResponse).Results
+			v.appendData(r.Result().(*AccountPaymentsPagedResponse))
+		}
+	case AccountUsersPagedResponse:
+		if r, err = req.SetResult(v).Get(v.endpoint(c)); r.Error() != nil {
+			return NewError(r)
+		} else if err == nil {
+			pages = r.Result().(*AccountUsersPagedResponse).Pages
+			results = r.Result().(*AccountUsersPagedResponse).Results
+			v.appendData(r.Result().(*AccountUsersPagedResponse))
+		}
+	case ProfileAppsPagedResponse:
+		if r, err = req.SetResult(v).Get(v.endpoint(c)); r.Error() != nil {
+			return NewError(r)
+		} else if err == nil {
+			pages = r.Result().(*ProfileAppsPagedResponse).Pages
+			results = r.Result().(*ProfileAppsPagedResponse).Results
+			v.appendData(r.Result().(*ProfileAppsPagedResponse))
+		}
+	case ProfileTokensPagedResponse:
+		if r, err = req.SetResult(v).Get(v.endpoint(c)); r.Error() != nil {
+			return NewError(r)
+		} else if err == nil {
+			pages = r.Result().(*ProfileTokensPagedResponse).Pages
+			results = r.Result().(*ProfileTokensPagedResponse).Results
+			v.appendData(r.Result().(*ProfileTokensPagedResponse))
+		}
+	case ProfileWhitelistPagedResponse:
+		if r, err = req.SetResult(v).Get(v.endpoint(c)); r.Error() != nil {
+			return NewError(r)
+		} else if err == nil {
+			pages = r.Result().(*ProfileWhitelistPagedResponse).Pages
+			results = r.Result().(*ProfileWhitelistPagedResponse).Results
+			v.appendData(r.Result().(*ProfileWhitelistPagedResponse))
+		}
+	case ManagedContactsPagedResponse:
+		if r, err = req.SetResult(v).Get(v.endpoint(c)); r.Error() != nil {
+			return NewError(r)
+		} else if err == nil {
+			pages = r.Result().(*ManagedContactsPagedResponse).Pages
+			results = r.Result().(*ManagedContactsPagedResponse).Results
+			v.appendData(r.Result().(*ManagedContactsPagedResponse))
+		}
+	case ManagedCredentialsPagedResponse:
+		if r, err = req.SetResult(v).Get(v.endpoint(c)); r.Error() != nil {
+			return NewError(r)
+		} else if err == nil {
+			pages = r.Result().(*ManagedCredentialsPagedResponse).Pages
+			results = r.Result().(*ManagedCredentialsPagedResponse).Results
+			v.appendData(r.Result().(*ManagedCredentialsPagedResponse))
+		}
+	case ManagedIssuesPagedResponse:
+		if r, err = req.SetResult(v).Get(v.endpoint(c)); r.Error() != nil {
+			return NewError(r)
+		} else if err == nil {
+			pages = r.Result().(*ManagedIssuesPagedResponse).Pages
+			results = r.Result().(*ManagedIssuesPagedResponse).Results
+			v.appendData(r.Result().(*ManagedIssuesPagedResponse))
+		}
+	case ManagedLinodeSettingsPagedResponse:
+		if r, err = req.SetResult(v).Get(v.endpoint(c)); r.Error() != nil {
+			return NewError(r)
+		} else if err == nil {
+			pages = r.Result().(*ManagedLinodeSettingsPagedResponse).Pages
+			results = r.Result().(*ManagedLinodeSettingsPagedResponse).Results
+			v.appendData(r.Result().(*ManagedLinodeSettingsPagedResponse))
+		}
+	case ManagedServicesPagedResponse:
+		if r, err = req.SetResult(v).Get(v.endpoint(c)); r.Error() != nil {
+			return NewError(r)
+		} else if err == nil {
+			pages = r.Result().(*ManagedServicesPagedResponse).Pages
+			results = r.Result().(*ManagedServicesPagedResponse).Results
+			v.appendData(r.Result().(*ManagedServicesPagedResponse))
+		}
+	**/
+	default:
+		log.Fatalf("listHelper interface{} %+v used", i)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	if opts == nil {
+		for page := 2; page <= pages; page = page + 1 {
+			if err := c.listHelper(ctx, i, &ListOptions{PageOptions: &PageOptions{Page: page}}); err != nil {
+				return err
+			}
+		}
+	} else {
+		if opts.PageOptions == nil {
+			opts.PageOptions = &PageOptions{}
+		}
+
+		if opts.Page == 0 {
+			for page := 2; page <= pages; page = page + 1 {
+				opts.Page = page
+				if err := c.listHelper(ctx, i, opts); err != nil {
+					return err
+				}
+			}
+		}
+		opts.Results = results
+		opts.Pages = pages
+	}
+
+	return nil
+}
+
+// listHelperWithID abstracts fetching and pagination for GET endpoints that
+// require an Id (second level endpoints).
+// When opts (or opts.Page) is nil, all pages will be fetched and
+// returned in a single (endpoint-specific)PagedResponse
+// opts.results and opts.pages will be updated from the API response
+func (c *Client) listHelperWithID(ctx context.Context, i interface{}, id int, opts *ListOptions) error {
+	req := c.R(ctx)
+	if opts != nil && opts.Page > 0 {
+		req.SetQueryParam("page", strconv.Itoa(opts.Page))
+	}
+
+	var (
+		err     error
+		pages   int
+		results int
+		r       *resty.Response
+	)
+
+	if opts != nil && len(opts.Filter) > 0 {
+		req.SetHeader("X-Filter", opts.Filter)
+	}
+
+	switch v := i.(type) {
+	case *InvoiceItemsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(InvoiceItemsPagedResponse{}).Get(v.endpointWithID(c, id))); err == nil {
+			pages = r.Result().(*InvoiceItemsPagedResponse).Pages
+			results = r.Result().(*InvoiceItemsPagedResponse).Results
+			v.appendData(r.Result().(*InvoiceItemsPagedResponse))
+		}
+	case *DomainRecordsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(DomainRecordsPagedResponse{}).Get(v.endpointWithID(c, id))); err == nil {
+			response, ok := r.Result().(*DomainRecordsPagedResponse)
+			if !ok {
+				return fmt.Errorf("Response is not a *DomainRecordsPagedResponse")
+			}
+			pages = response.Pages
+			results = response.Results
+			v.appendData(response)
+		}
+	case *InstanceConfigsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(InstanceConfigsPagedResponse{}).Get(v.endpointWithID(c, id))); err == nil {
+			pages = r.Result().(*InstanceConfigsPagedResponse).Pages
+			results = r.Result().(*InstanceConfigsPagedResponse).Results
+			v.appendData(r.Result().(*InstanceConfigsPagedResponse))
+		}
+	case *InstanceDisksPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(InstanceDisksPagedResponse{}).Get(v.endpointWithID(c, id))); err == nil {
+			pages = r.Result().(*InstanceDisksPagedResponse).Pages
+			results = r.Result().(*InstanceDisksPagedResponse).Results
+			v.appendData(r.Result().(*InstanceDisksPagedResponse))
+		}
+	case *NodeBalancerConfigsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(NodeBalancerConfigsPagedResponse{}).Get(v.endpointWithID(c, id))); err == nil {
+			pages = r.Result().(*NodeBalancerConfigsPagedResponse).Pages
+			results = r.Result().(*NodeBalancerConfigsPagedResponse).Results
+			v.appendData(r.Result().(*NodeBalancerConfigsPagedResponse))
+		}
+	case *InstanceVolumesPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(InstanceVolumesPagedResponse{}).Get(v.endpointWithID(c, id))); err == nil {
+			pages = r.Result().(*InstanceVolumesPagedResponse).Pages
+			results = r.Result().(*InstanceVolumesPagedResponse).Results
+			v.appendData(r.Result().(*InstanceVolumesPagedResponse))
+		}
+	/**
+	case TicketAttachmentsPagedResponse:
+		if r, err = req.SetResult(v).Get(v.endpoint(c)); r.Error() != nil {
+			return NewError(r)
+		} else if err == nil {
+			pages = r.Result().(*TicketAttachmentsPagedResponse).Pages
+			results = r.Result().(*TicketAttachmentsPagedResponse).Results
+			v.appendData(r.Result().(*TicketAttachmentsPagedResponse))
+		}
+	case TicketRepliesPagedResponse:
+		if r, err = req.SetResult(v).Get(v.endpoint(c)); r.Error() != nil {
+			return NewError(r)
+		} else if err == nil {
+			pages = r.Result().(*TicketRepliesPagedResponse).Pages
+			results = r.Result().(*TicketRepliesPagedResponse).Results
+			v.appendData(r.Result().(*TicketRepliesPagedResponse))
+		}
+	**/
+	default:
+		log.Fatalf("Unknown listHelperWithID interface{} %T used", i)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	if opts == nil {
+		for page := 2; page <= pages; page = page + 1 {
+			if err := c.listHelperWithID(ctx, i, id, &ListOptions{PageOptions: &PageOptions{Page: page}}); err != nil {
+				return err
+			}
+		}
+	} else {
+		if opts.PageOptions == nil {
+			opts.PageOptions = &PageOptions{}
+		}
+		if opts.Page == 0 {
+			for page := 2; page <= pages; page = page + 1 {
+				opts.Page = page
+				if err := c.listHelperWithID(ctx, i, id, opts); err != nil {
+					return err
+				}
+			}
+		}
+		opts.Results = results
+		opts.Pages = pages
+	}
+
+	return nil
+}
+
+// listHelperWithTwoIDs abstracts fetching and pagination for GET endpoints that
+// require twos IDs (third level endpoints).
+// When opts (or opts.Page) is nil, all pages will be fetched and
+// returned in a single (endpoint-specific)PagedResponse
+// opts.results and opts.pages will be updated from the API response
+func (c *Client) listHelperWithTwoIDs(ctx context.Context, i interface{}, firstID, secondID int, opts *ListOptions) error {
+	req := c.R(ctx)
+	if opts != nil && opts.Page > 0 {
+		req.SetQueryParam("page", strconv.Itoa(opts.Page))
+	}
+
+	var (
+		err     error
+		pages   int
+		results int
+		r       *resty.Response
+	)
+
+	if opts != nil && len(opts.Filter) > 0 {
+		req.SetHeader("X-Filter", opts.Filter)
+	}
+
+	switch v := i.(type) {
+	case *NodeBalancerNodesPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(NodeBalancerNodesPagedResponse{}).Get(v.endpointWithTwoIDs(c, firstID, secondID))); err == nil {
+			pages = r.Result().(*NodeBalancerNodesPagedResponse).Pages
+			results = r.Result().(*NodeBalancerNodesPagedResponse).Results
+			v.appendData(r.Result().(*NodeBalancerNodesPagedResponse))
+		}
+
+	default:
+		log.Fatalf("Unknown listHelperWithTwoIDs interface{} %T used", i)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	if opts == nil {
+		for page := 2; page <= pages; page = page + 1 {
+			if err := c.listHelper(ctx, i, &ListOptions{PageOptions: &PageOptions{Page: page}}); err != nil {
+				return err
+			}
+		}
+	} else {
+		if opts.PageOptions == nil {
+			opts.PageOptions = &PageOptions{}
+		}
+		if opts.Page == 0 {
+			for page := 2; page <= pages; page = page + 1 {
+				opts.Page = page
+				if err := c.listHelperWithTwoIDs(ctx, i, firstID, secondID, opts); err != nil {
+					return err
+				}
+			}
+		}
+		opts.Results = results
+		opts.Pages = pages
+	}
+
+	return nil
+}

vendor/github.com/linode/linodego/profile.go

@@ -0,0 +1 @@
+package linodego

vendor/github.com/linode/linodego/profile_sshkeys.go

@@ -0,0 +1,160 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// SSHKey represents a SSHKey object
+type SSHKey struct {
+	ID         int        `json:"id"`
+	Label      string     `json:"label"`
+	SSHKey     string     `json:"ssh_key"`
+	CreatedStr string     `json:"created"`
+	Created    *time.Time `json:"-"`
+}
+
+// SSHKeyCreateOptions fields are those accepted by CreateSSHKey
+type SSHKeyCreateOptions struct {
+	Label  string `json:"label"`
+	SSHKey string `json:"ssh_key"`
+}
+
+// SSHKeyUpdateOptions fields are those accepted by UpdateSSHKey
+type SSHKeyUpdateOptions struct {
+	Label string `json:"label"`
+}
+
+// GetCreateOptions converts a SSHKey to SSHKeyCreateOptions for use in CreateSSHKey
+func (i SSHKey) GetCreateOptions() (o SSHKeyCreateOptions) {
+	o.Label = i.Label
+	o.SSHKey = i.SSHKey
+	return
+}
+
+// GetUpdateOptions converts a SSHKey to SSHKeyCreateOptions for use in UpdateSSHKey
+func (i SSHKey) GetUpdateOptions() (o SSHKeyUpdateOptions) {
+	o.Label = i.Label
+	return
+}
+
+// SSHKeysPagedResponse represents a paginated SSHKey API response
+type SSHKeysPagedResponse struct {
+	*PageOptions
+	Data []SSHKey `json:"data"`
+}
+
+// endpoint gets the endpoint URL for SSHKey
+func (SSHKeysPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.SSHKeys.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends SSHKeys when processing paginated SSHKey responses
+func (resp *SSHKeysPagedResponse) appendData(r *SSHKeysPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListSSHKeys lists SSHKeys
+func (c *Client) ListSSHKeys(ctx context.Context, opts *ListOptions) ([]SSHKey, error) {
+	response := SSHKeysPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (i *SSHKey) fixDates() *SSHKey {
+	i.Created, _ = parseDates(i.CreatedStr)
+	return i
+}
+
+// GetSSHKey gets the sshkey with the provided ID
+func (c *Client) GetSSHKey(ctx context.Context, id int) (*SSHKey, error) {
+	e, err := c.SSHKeys.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&SSHKey{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*SSHKey).fixDates(), nil
+}
+
+// CreateSSHKey creates a SSHKey
+func (c *Client) CreateSSHKey(ctx context.Context, createOpts SSHKeyCreateOptions) (*SSHKey, error) {
+	var body string
+	e, err := c.SSHKeys.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&SSHKey{})
+
+	if bodyData, err := json.Marshal(createOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*SSHKey).fixDates(), nil
+}
+
+// UpdateSSHKey updates the SSHKey with the specified id
+func (c *Client) UpdateSSHKey(ctx context.Context, id int, updateOpts SSHKeyUpdateOptions) (*SSHKey, error) {
+	var body string
+	e, err := c.SSHKeys.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	req := c.R(ctx).SetResult(&SSHKey{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*SSHKey).fixDates(), nil
+}
+
+// DeleteSSHKey deletes the SSHKey with the specified id
+func (c *Client) DeleteSSHKey(ctx context.Context, id int) error {
+	e, err := c.SSHKeys.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+
+}

vendor/github.com/linode/linodego/regions.go

@@ -0,0 +1,64 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+)
+
+// Region represents a linode region object
+type Region struct {
+	ID      string `json:"id"`
+	Country string `json:"country"`
+}
+
+// RegionsPagedResponse represents a linode API response for listing
+type RegionsPagedResponse struct {
+	*PageOptions
+	Data []Region `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Region
+func (RegionsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Regions.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends Regions when processing paginated Region responses
+func (resp *RegionsPagedResponse) appendData(r *RegionsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListRegions lists Regions
+func (c *Client) ListRegions(ctx context.Context, opts *ListOptions) ([]Region, error) {
+	response := RegionsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (v *Region) fixDates() *Region {
+	return v
+}
+
+// GetRegion gets the template with the provided ID
+func (c *Client) GetRegion(ctx context.Context, id string) (*Region, error) {
+	e, err := c.Regions.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&Region{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Region).fixDates(), nil
+}

vendor/github.com/linode/linodego/resources.go

@@ -0,0 +1,155 @@
+package linodego
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"text/template"
+
+	"github.com/go-resty/resty"
+)
+
+const (
+	stackscriptsName          = "stackscripts"
+	imagesName                = "images"
+	instancesName             = "instances"
+	instanceDisksName         = "disks"
+	instanceConfigsName       = "configs"
+	instanceIPsName           = "ips"
+	instanceSnapshotsName     = "snapshots"
+	instanceVolumesName       = "instancevolumes"
+	ipaddressesName           = "ipaddresses"
+	ipv6poolsName             = "ipv6pools"
+	ipv6rangesName            = "ipv6ranges"
+	regionsName               = "regions"
+	volumesName               = "volumes"
+	kernelsName               = "kernels"
+	typesName                 = "types"
+	domainsName               = "domains"
+	domainRecordsName         = "records"
+	longviewName              = "longview"
+	longviewclientsName       = "longviewclients"
+	longviewsubscriptionsName = "longviewsubscriptions"
+	nodebalancersName         = "nodebalancers"
+	nodebalancerconfigsName   = "nodebalancerconfigs"
+	nodebalancernodesName     = "nodebalancernodes"
+	sshkeysName               = "sshkeys"
+	ticketsName               = "tickets"
+	accountName               = "account"
+	eventsName                = "events"
+	invoicesName              = "invoices"
+	invoiceItemsName          = "invoiceitems"
+	profileName               = "profile"
+	managedName               = "managed"
+	// notificationsName = "notifications"
+
+	stackscriptsEndpoint          = "linode/stackscripts"
+	imagesEndpoint                = "images"
+	instancesEndpoint             = "linode/instances"
+	instanceConfigsEndpoint       = "linode/instances/{{ .ID }}/configs"
+	instanceDisksEndpoint         = "linode/instances/{{ .ID }}/disks"
+	instanceSnapshotsEndpoint     = "linode/instances/{{ .ID }}/backups"
+	instanceIPsEndpoint           = "linode/instances/{{ .ID }}/ips"
+	instanceVolumesEndpoint       = "linode/instances/{{ .ID }}/volumes"
+	ipaddressesEndpoint           = "network/ips"
+	ipv6poolsEndpoint             = "network/ipv6/pools"
+	ipv6rangesEndpoint            = "network/ipv6/ranges"
+	regionsEndpoint               = "regions"
+	volumesEndpoint               = "volumes"
+	kernelsEndpoint               = "linode/kernels"
+	typesEndpoint                 = "linode/types"
+	domainsEndpoint               = "domains"
+	domainRecordsEndpoint         = "domains/{{ .ID }}/records"
+	longviewEndpoint              = "longview"
+	longviewclientsEndpoint       = "longview/clients"
+	longviewsubscriptionsEndpoint = "longview/subscriptions"
+	nodebalancersEndpoint         = "nodebalancers"
+	// @TODO we can't use these nodebalancer endpoints unless we include these templated fields
+	// The API seems inconsistent about including parent IDs in objects, (compare instance configs to nb configs)
+	// Parent IDs would be immutable for updates and are ignored in create requests ..
+	// Should we include these fields in CreateOpts and UpdateOpts?
+	nodebalancerconfigsEndpoint = "nodebalancers/{{ .ID }}/configs"
+	nodebalancernodesEndpoint   = "nodebalancers/{{ .ID }}/configs/{{ .SecondID }}/nodes"
+	sshkeysEndpoint             = "profile/sshkeys"
+	ticketsEndpoint             = "support/tickets"
+	accountEndpoint             = "account"
+	eventsEndpoint              = "account/events"
+	invoicesEndpoint            = "account/invoices"
+	invoiceItemsEndpoint        = "account/invoices/{{ .ID }}/items"
+	profileEndpoint             = "profile"
+	managedEndpoint             = "managed"
+	// notificationsEndpoint       = "account/notifications"
+)
+
+// Resource represents a linode API resource
+type Resource struct {
+	name             string
+	endpoint         string
+	isTemplate       bool
+	endpointTemplate *template.Template
+	R                func(ctx context.Context) *resty.Request
+	PR               func(ctx context.Context) *resty.Request
+}
+
+// NewResource is the factory to create a new Resource struct. If it has a template string the useTemplate bool must be set.
+func NewResource(client *Client, name string, endpoint string, useTemplate bool, singleType interface{}, pagedType interface{}) *Resource {
+	var tmpl *template.Template
+
+	if useTemplate {
+		tmpl = template.Must(template.New(name).Parse(endpoint))
+	}
+
+	r := func(ctx context.Context) *resty.Request {
+		return client.R(ctx).SetResult(singleType)
+	}
+
+	pr := func(ctx context.Context) *resty.Request {
+		return client.R(ctx).SetResult(pagedType)
+	}
+
+	return &Resource{name, endpoint, useTemplate, tmpl, r, pr}
+}
+
+func (r Resource) render(data ...interface{}) (string, error) {
+	if data == nil {
+		return "", NewError("Cannot template endpoint with <nil> data")
+	}
+	out := ""
+	buf := bytes.NewBufferString(out)
+
+	var substitutions interface{}
+	if len(data) == 1 {
+		substitutions = struct{ ID interface{} }{data[0]}
+	} else if len(data) == 2 {
+		substitutions = struct {
+			ID       interface{}
+			SecondID interface{}
+		}{data[0], data[1]}
+	} else {
+		return "", NewError("Too many arguments to render template (expected 1 or 2)")
+	}
+	if err := r.endpointTemplate.Execute(buf, substitutions); err != nil {
+		return "", NewError(err)
+	}
+	return buf.String(), nil
+}
+
+// endpointWithID will return the rendered endpoint string for the resource with provided id
+func (r Resource) endpointWithID(id ...int) (string, error) {
+	if !r.isTemplate {
+		return r.endpoint, nil
+	}
+	data := make([]interface{}, len(id))
+	for i, v := range id {
+		data[i] = v
+	}
+	return r.render(data...)
+}
+
+// Endpoint will return the non-templated endpoint string for resource
+func (r Resource) Endpoint() (string, error) {
+	if r.isTemplate {
+		return "", NewError(fmt.Sprintf("Tried to get endpoint for %s without providing data for template", r.name))
+	}
+	return r.endpoint, nil
+}

vendor/github.com/linode/linodego/stackscripts.go

@@ -0,0 +1,208 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// Stackscript represents a Linode StackScript
+type Stackscript struct {
+	CreatedStr string `json:"created"`
+	UpdatedStr string `json:"updated"`
+
+	ID                int               `json:"id"`
+	Username          string            `json:"username"`
+	Label             string            `json:"label"`
+	Description       string            `json:"description"`
+	Images            []string          `json:"images"`
+	DeploymentsTotal  int               `json:"deployments_total"`
+	DeploymentsActive int               `json:"deployments_active"`
+	IsPublic          bool              `json:"is_public"`
+	Created           *time.Time        `json:"-"`
+	Updated           *time.Time        `json:"-"`
+	RevNote           string            `json:"rev_note"`
+	Script            string            `json:"script"`
+	UserDefinedFields *[]StackscriptUDF `json:"user_defined_fields"`
+	UserGravatarID    string            `json:"user_gravatar_id"`
+}
+
+// StackscriptUDF define a single variable that is accepted by a Stackscript
+type StackscriptUDF struct {
+	// A human-readable label for the field that will serve as the input prompt for entering the value during deployment.
+	Label string `json:"label"`
+
+	// The name of the field.
+	Name string `json:"name"`
+
+	// An example value for the field.
+	Example string `json:"example"`
+
+	// A list of acceptable single values for the field.
+	OneOf string `json:"oneOf,omitempty"`
+
+	// A list of acceptable values for the field in any quantity, combination or order.
+	ManyOf string `json:"manyOf,omitempty"`
+
+	// The default value. If not specified, this value will be used.
+	Default string `json:"default,omitempty"`
+}
+
+// StackscriptCreateOptions fields are those accepted by CreateStackscript
+type StackscriptCreateOptions struct {
+	Label       string   `json:"label"`
+	Description string   `json:"description"`
+	Images      []string `json:"images"`
+	IsPublic    bool     `json:"is_public"`
+	RevNote     string   `json:"rev_note"`
+	Script      string   `json:"script"`
+}
+
+// StackscriptUpdateOptions fields are those accepted by UpdateStackscript
+type StackscriptUpdateOptions StackscriptCreateOptions
+
+// GetCreateOptions converts a Stackscript to StackscriptCreateOptions for use in CreateStackscript
+func (i Stackscript) GetCreateOptions() StackscriptCreateOptions {
+	return StackscriptCreateOptions{
+		Label:       i.Label,
+		Description: i.Description,
+		Images:      i.Images,
+		IsPublic:    i.IsPublic,
+		RevNote:     i.RevNote,
+		Script:      i.Script,
+	}
+}
+
+// GetUpdateOptions converts a Stackscript to StackscriptUpdateOptions for use in UpdateStackscript
+func (i Stackscript) GetUpdateOptions() StackscriptUpdateOptions {
+	return StackscriptUpdateOptions{
+		Label:       i.Label,
+		Description: i.Description,
+		Images:      i.Images,
+		IsPublic:    i.IsPublic,
+		RevNote:     i.RevNote,
+		Script:      i.Script,
+	}
+}
+
+// StackscriptsPagedResponse represents a paginated Stackscript API response
+type StackscriptsPagedResponse struct {
+	*PageOptions
+	Data []Stackscript `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Stackscript
+func (StackscriptsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.StackScripts.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends Stackscripts when processing paginated Stackscript responses
+func (resp *StackscriptsPagedResponse) appendData(r *StackscriptsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListStackscripts lists Stackscripts
+func (c *Client) ListStackscripts(ctx context.Context, opts *ListOptions) ([]Stackscript, error) {
+	response := StackscriptsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (i *Stackscript) fixDates() *Stackscript {
+	i.Created, _ = parseDates(i.CreatedStr)
+	i.Updated, _ = parseDates(i.UpdatedStr)
+	return i
+}
+
+// GetStackscript gets the Stackscript with the provided ID
+func (c *Client) GetStackscript(ctx context.Context, id int) (*Stackscript, error) {
+	e, err := c.StackScripts.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).
+		SetResult(&Stackscript{}).
+		Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Stackscript).fixDates(), nil
+}
+
+// CreateStackscript creates a StackScript
+func (c *Client) CreateStackscript(ctx context.Context, createOpts StackscriptCreateOptions) (*Stackscript, error) {
+	var body string
+	e, err := c.StackScripts.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&Stackscript{})
+
+	if bodyData, err := json.Marshal(createOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Stackscript).fixDates(), nil
+}
+
+// UpdateStackscript updates the StackScript with the specified id
+func (c *Client) UpdateStackscript(ctx context.Context, id int, updateOpts StackscriptUpdateOptions) (*Stackscript, error) {
+	var body string
+	e, err := c.StackScripts.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	req := c.R(ctx).SetResult(&Stackscript{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Stackscript).fixDates(), nil
+}
+
+// DeleteStackscript deletes the StackScript with the specified id
+func (c *Client) DeleteStackscript(ctx context.Context, id int) error {
+	e, err := c.StackScripts.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}

vendor/github.com/linode/linodego/support.go

@@ -0,0 +1,88 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+// Ticket represents a support ticket object
+type Ticket struct {
+	ID          int           `json:"id"`
+	Attachments []string      `json:"attachments"`
+	Closed      *time.Time    `json:"-"`
+	Description string        `json:"description"`
+	Entity      *TicketEntity `json:"entity"`
+	GravatarID  string        `json:"gravatar_id"`
+	Opened      *time.Time    `json:"-"`
+	OpenedBy    string        `json:"opened_by"`
+	Status      TicketStatus  `json:"status"`
+	Summary     string        `json:"summary"`
+	Updated     *time.Time    `json:"-"`
+	UpdatedBy   string        `json:"updated_by"`
+}
+
+// TicketEntity refers a ticket to a specific entity
+type TicketEntity struct {
+	ID    int    `json:"id"`
+	Label string `json:"label"`
+	Type  string `json:"type"`
+	URL   string `json:"url"`
+}
+
+// TicketStatus constants start with Ticket and include Linode API Ticket Status values
+type TicketStatus string
+
+// TicketStatus constants reflect the current status of a Ticket
+const (
+	TicketNew    TicketStatus = "new"
+	TicketClosed TicketStatus = "closed"
+	TicketOpen   TicketStatus = "open"
+)
+
+// TicketsPagedResponse represents a paginated ticket API response
+type TicketsPagedResponse struct {
+	*PageOptions
+	Data []Ticket `json:"data"`
+}
+
+func (TicketsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Tickets.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+func (resp *TicketsPagedResponse) appendData(r *TicketsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListTickets returns a collection of Support Tickets on the Account. Support Tickets
+// can be both tickets opened with Linode for support, as well as tickets generated by
+// Linode regarding the Account. This collection includes all Support Tickets generated
+// on the Account, with open tickets returned first.
+func (c *Client) ListTickets(ctx context.Context, opts *ListOptions) ([]Ticket, error) {
+	response := TicketsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// GetTicket gets a Support Ticket on the Account with the specified ID
+func (c *Client) GetTicket(ctx context.Context, id int) (*Ticket, error) {
+	e, err := c.Tickets.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).
+		SetResult(&Ticket{}).
+		Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Ticket), nil
+}

vendor/github.com/linode/linodego/template.go

@@ -0,0 +1,167 @@
+// +build ignore
+
+package linodego
+
+/*
+ - replace "Template" with "NameOfResource"
+ - replace "template" with "nameOfResource"
+ - copy template_test.go and do the same
+ - When updating Template structs,
+   - use pointers where ever null'able would have a different meaning if the wrapper
+	 supplied "" or 0 instead
+ - Add "NameOfResource" to client.go, resources.go, pagination.go
+*/
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// Template represents a Template object
+type Template struct {
+	ID int `json:"id"`
+	// UpdatedStr string `json:"updated"`
+	// Updated *time.Time `json:"-"`
+}
+
+// TemplateCreateOptions fields are those accepted by CreateTemplate
+type TemplateCreateOptions struct {
+}
+
+// TemplateUpdateOptions fields are those accepted by UpdateTemplate
+type TemplateUpdateOptions struct {
+}
+
+// GetCreateOptions converts a Template to TemplateCreateOptions for use in CreateTemplate
+func (i Template) GetCreateOptions() (o TemplateCreateOptions) {
+	// o.Label = i.Label
+	// o.Description = copyString(o.Description)
+	return
+}
+
+// GetUpdateOptions converts a Template to TemplateUpdateOptions for use in UpdateTemplate
+func (i Template) GetUpdateOptions() (o TemplateUpdateOptions) {
+	// o.Label = i.Label
+	// o.Description = copyString(o.Description)
+	return
+}
+
+// TemplatesPagedResponse represents a paginated Template API response
+type TemplatesPagedResponse struct {
+	*PageOptions
+	Data []Template `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Template
+func (TemplatesPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Templates.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends Templates when processing paginated Template responses
+func (resp *TemplatesPagedResponse) appendData(r *TemplatesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListTemplates lists Templates
+func (c *Client) ListTemplates(ctx context.Context, opts *ListOptions) ([]Template, error) {
+	response := TemplatesPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (i *Template) fixDates() *Template {
+	// i.Created, _ = parseDates(i.CreatedStr)
+	// i.Updated, _ = parseDates(i.UpdatedStr)
+	return i
+}
+
+// GetTemplate gets the template with the provided ID
+func (c *Client) GetTemplate(ctx context.Context, id int) (*Template, error) {
+	e, err := c.Templates.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&Template{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Template).fixDates(), nil
+}
+
+// CreateTemplate creates a Template
+func (c *Client) CreateTemplate(ctx context.Context, createOpts TemplateCreateOptions) (*Template, error) {
+	var body string
+	e, err := c.Templates.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&Template{})
+
+	if bodyData, err := json.Marshal(createOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Template).fixDates(), nil
+}
+
+// UpdateTemplate updates the Template with the specified id
+func (c *Client) UpdateTemplate(ctx context.Context, id int, updateOpts TemplateUpdateOptions) (*Template, error) {
+	var body string
+	e, err := c.Templates.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	req := c.R(ctx).SetResult(&Template{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Template).fixDates(), nil
+}
+
+// DeleteTemplate deletes the Template with the specified id
+func (c *Client) DeleteTemplate(ctx context.Context, id int) error {
+	e, err := c.Templates.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}

vendor/github.com/linode/linodego/types.go

@@ -0,0 +1,89 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+)
+
+// LinodeType represents a linode type object
+type LinodeType struct {
+	ID         string          `json:"id"`
+	Disk       int             `json:"disk"`
+	Class      LinodeTypeClass `json:"class"` // enum: nanode, standard, highmem
+	Price      *LinodePrice    `json:"price"`
+	Label      string          `json:"label"`
+	Addons     *LinodeAddons   `json:"addons"`
+	NetworkOut int             `json:"network_out"`
+	Memory     int             `json:"memory"`
+	Transfer   int             `json:"transfer"`
+	VCPUs      int             `json:"vcpus"`
+}
+
+// LinodePrice represents a linode type price object
+type LinodePrice struct {
+	Hourly  float32 `json:"hourly"`
+	Monthly float32 `json:"monthly"`
+}
+
+// LinodeBackupsAddon represents a linode backups addon object
+type LinodeBackupsAddon struct {
+	Price *LinodePrice `json:"price"`
+}
+
+// LinodeAddons represent the linode addons object
+type LinodeAddons struct {
+	Backups *LinodeBackupsAddon `json:"backups"`
+}
+
+// LinodeTypeClass constants start with Class and include Linode API Instance Type Classes
+type LinodeTypeClass string
+
+// LinodeTypeClass contants are the Instance Type Classes that an Instance Type can be assigned
+const (
+	ClassNanode   LinodeTypeClass = "nanode"
+	ClassStandard LinodeTypeClass = "standard"
+	ClassHighmem  LinodeTypeClass = "highmem"
+)
+
+// LinodeTypesPagedResponse represents a linode types API response for listing
+type LinodeTypesPagedResponse struct {
+	*PageOptions
+	Data []LinodeType `json:"data"`
+}
+
+func (LinodeTypesPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Types.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+func (resp *LinodeTypesPagedResponse) appendData(r *LinodeTypesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListTypes lists linode types
+func (c *Client) ListTypes(ctx context.Context, opts *ListOptions) ([]LinodeType, error) {
+	response := LinodeTypesPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// GetType gets the type with the provided ID
+func (c *Client) GetType(ctx context.Context, typeID string) (*LinodeType, error) {
+	e, err := c.Types.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, typeID)
+
+	r, err := coupleAPIErrors(c.Types.R(ctx).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*LinodeType), nil
+}

vendor/github.com/linode/linodego/util.go

@@ -0,0 +1,15 @@
+package linodego
+
+import "time"
+
+const (
+	dateLayout = "2006-01-02T15:04:05"
+)
+
+func parseDates(dateStr string) (*time.Time, error) {
+	d, err := time.Parse(dateLayout, dateStr)
+	if err != nil {
+		return nil, err
+	}
+	return &d, nil
+}

vendor/github.com/linode/linodego/volumes.go

@@ -0,0 +1,260 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// VolumeStatus indicates the status of the Volume
+type VolumeStatus string
+
+const (
+	// VolumeCreating indicates the Volume is being created and is not yet available for use
+	VolumeCreating VolumeStatus = "creating"
+
+	// VolumeActive indicates the Volume is online and available for use
+	VolumeActive VolumeStatus = "active"
+
+	// VolumeResizing indicates the Volume is in the process of upgrading its current capacity
+	VolumeResizing VolumeStatus = "resizing"
+
+	// VolumeContactSupport indicates there is a problem with the Volume. A support ticket must be opened to resolve the issue
+	VolumeContactSupport VolumeStatus = "contact_support"
+)
+
+// Volume represents a linode volume object
+type Volume struct {
+	CreatedStr string `json:"created"`
+	UpdatedStr string `json:"updated"`
+
+	ID             int          `json:"id"`
+	Label          string       `json:"label"`
+	Status         VolumeStatus `json:"status"`
+	Region         string       `json:"region"`
+	Size           int          `json:"size"`
+	LinodeID       *int         `json:"linode_id"`
+	FilesystemPath string       `json:"filesystem_path"`
+	Created        time.Time    `json:"-"`
+	Updated        time.Time    `json:"-"`
+}
+
+// VolumeCreateOptions fields are those accepted by CreateVolume
+type VolumeCreateOptions struct {
+	Label    string `json:"label,omitempty"`
+	Region   string `json:"region,omitempty"`
+	LinodeID int    `json:"linode_id,omitempty"`
+	ConfigID int    `json:"config_id,omitempty"`
+	// The Volume's size, in GiB. Minimum size is 10GiB, maximum size is 10240GiB. A "0" value will result in the default size.
+	Size int `json:"size,omitempty"`
+}
+
+// VolumeAttachOptions fields are those accepted by AttachVolume
+type VolumeAttachOptions struct {
+	LinodeID int `json:"linode_id"`
+	ConfigID int `json:"config_id,omitempty"`
+}
+
+// VolumesPagedResponse represents a linode API response for listing of volumes
+type VolumesPagedResponse struct {
+	*PageOptions
+	Data []Volume `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Volume
+func (VolumesPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Volumes.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends Volumes when processing paginated Volume responses
+func (resp *VolumesPagedResponse) appendData(r *VolumesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListVolumes lists Volumes
+func (c *Client) ListVolumes(ctx context.Context, opts *ListOptions) ([]Volume, error) {
+	response := VolumesPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (v *Volume) fixDates() *Volume {
+	if parsed, err := parseDates(v.CreatedStr); err != nil {
+		v.Created = *parsed
+	}
+	if parsed, err := parseDates(v.UpdatedStr); err != nil {
+		v.Updated = *parsed
+	}
+	return v
+}
+
+// GetVolume gets the template with the provided ID
+func (c *Client) GetVolume(ctx context.Context, id int) (*Volume, error) {
+	e, err := c.Volumes.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&Volume{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Volume).fixDates(), nil
+}
+
+// AttachVolume attaches a volume to a Linode instance
+func (c *Client) AttachVolume(ctx context.Context, id int, options *VolumeAttachOptions) (*Volume, error) {
+	body := ""
+	if bodyData, err := json.Marshal(options); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	e, err := c.Volumes.Endpoint()
+	if err != nil {
+		return nil, NewError(err)
+	}
+
+	e = fmt.Sprintf("%s/%d/attach", e, id)
+	resp, err := coupleAPIErrors(c.R(ctx).
+		SetResult(&Volume{}).
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return resp.Result().(*Volume).fixDates(), nil
+}
+
+// CreateVolume creates a Linode Volume
+func (c *Client) CreateVolume(ctx context.Context, createOpts VolumeCreateOptions) (*Volume, error) {
+	body := ""
+	if bodyData, err := json.Marshal(createOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	e, err := c.Volumes.Endpoint()
+	if err != nil {
+		return nil, NewError(err)
+	}
+
+	resp, err := coupleAPIErrors(c.R(ctx).
+		SetResult(&Volume{}).
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return resp.Result().(*Volume).fixDates(), nil
+}
+
+// RenameVolume renames the label of a Linode volume
+// There is no UpdateVolume because the label is the only alterable field.
+func (c *Client) RenameVolume(ctx context.Context, id int, label string) (*Volume, error) {
+	body, _ := json.Marshal(map[string]string{"label": label})
+
+	e, err := c.Volumes.Endpoint()
+	if err != nil {
+		return nil, NewError(err)
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	resp, err := coupleAPIErrors(c.R(ctx).
+		SetResult(&Volume{}).
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return resp.Result().(*Volume).fixDates(), nil
+}
+
+// CloneVolume clones a Linode volume
+func (c *Client) CloneVolume(ctx context.Context, id int, label string) (*Volume, error) {
+	body := fmt.Sprintf("{\"label\":\"%s\"}", label)
+
+	e, err := c.Volumes.Endpoint()
+	if err != nil {
+		return nil, NewError(err)
+	}
+	e = fmt.Sprintf("%s/%d/clone", e, id)
+
+	resp, err := coupleAPIErrors(c.R(ctx).
+		SetResult(&Volume{}).
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return resp.Result().(*Volume).fixDates(), nil
+}
+
+// DetachVolume detaches a Linode volume
+func (c *Client) DetachVolume(ctx context.Context, id int) error {
+	body := ""
+
+	e, err := c.Volumes.Endpoint()
+	if err != nil {
+		return NewError(err)
+	}
+
+	e = fmt.Sprintf("%s/%d/detach", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).
+		SetBody(body).
+		Post(e))
+
+	return err
+}
+
+// ResizeVolume resizes an instance to new Linode type
+func (c *Client) ResizeVolume(ctx context.Context, id int, size int) error {
+	body := fmt.Sprintf("{\"size\": %d}", size)
+
+	e, err := c.Volumes.Endpoint()
+	if err != nil {
+		return NewError(err)
+	}
+	e = fmt.Sprintf("%s/%d/resize", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).
+		SetBody(body).
+		Post(e))
+
+	return err
+}
+
+// DeleteVolume deletes the Volume with the specified id
+func (c *Client) DeleteVolume(ctx context.Context, id int) error {
+	e, err := c.Volumes.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}

vendor/github.com/linode/linodego/waitfor.go

@@ -0,0 +1,240 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// WaitForInstanceStatus waits for the Linode instance to reach the desired state
+// before returning. It will timeout with an error after timeoutSeconds.
+func (client Client) WaitForInstanceStatus(ctx context.Context, instanceID int, status InstanceStatus, timeoutSeconds int) (*Instance, error) {
+	ctx, cancel := context.WithTimeout(ctx, time.Duration(timeoutSeconds)*time.Second)
+	defer cancel()
+
+	ticker := time.NewTicker(time.Second)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ticker.C:
+			instance, err := client.GetInstance(ctx, instanceID)
+			if err != nil {
+				return instance, err
+			}
+			complete := (instance.Status == status)
+
+			if complete {
+				return instance, nil
+			}
+		case <-ctx.Done():
+			return nil, fmt.Errorf("Error waiting for Instance %d status %s: %s", instanceID, status, ctx.Err())
+		}
+	}
+}
+
+// WaitForVolumeStatus waits for the Volume to reach the desired state
+// before returning. It will timeout with an error after timeoutSeconds.
+func (client Client) WaitForVolumeStatus(ctx context.Context, volumeID int, status VolumeStatus, timeoutSeconds int) (*Volume, error) {
+	ctx, cancel := context.WithTimeout(ctx, time.Duration(timeoutSeconds)*time.Second)
+	defer cancel()
+
+	ticker := time.NewTicker(time.Second)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ticker.C:
+			volume, err := client.GetVolume(ctx, volumeID)
+			if err != nil {
+				return volume, err
+			}
+			complete := (volume.Status == status)
+
+			if complete {
+				return volume, nil
+			}
+		case <-ctx.Done():
+			return nil, fmt.Errorf("Error waiting for Volume %d status %s: %s", volumeID, status, ctx.Err())
+		}
+	}
+}
+
+// WaitForSnapshotStatus waits for the Snapshot to reach the desired state
+// before returning. It will timeout with an error after timeoutSeconds.
+func (client Client) WaitForSnapshotStatus(ctx context.Context, instanceID int, snapshotID int, status InstanceSnapshotStatus, timeoutSeconds int) (*InstanceSnapshot, error) {
+	ctx, cancel := context.WithTimeout(ctx, time.Duration(timeoutSeconds)*time.Second)
+	defer cancel()
+
+	ticker := time.NewTicker(time.Second)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ticker.C:
+			snapshot, err := client.GetInstanceSnapshot(ctx, instanceID, snapshotID)
+			if err != nil {
+				return snapshot, err
+			}
+			complete := (snapshot.Status == status)
+
+			if complete {
+				return snapshot, nil
+			}
+		case <-ctx.Done():
+			return nil, fmt.Errorf("Error waiting for Instance %d Snapshot %d status %s: %s", instanceID, snapshotID, status, ctx.Err())
+		}
+	}
+}
+
+// WaitForVolumeLinodeID waits for the Volume to match the desired LinodeID
+// before returning. An active Instance will not immediately attach or detach a volume, so the
+// the LinodeID must be polled to determine volume readiness from the API.
+// WaitForVolumeLinodeID will timeout with an error after timeoutSeconds.
+func (client Client) WaitForVolumeLinodeID(ctx context.Context, volumeID int, linodeID *int, timeoutSeconds int) (*Volume, error) {
+	ctx, cancel := context.WithTimeout(ctx, time.Duration(timeoutSeconds)*time.Second)
+	defer cancel()
+
+	ticker := time.NewTicker(time.Second)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ticker.C:
+			volume, err := client.GetVolume(ctx, volumeID)
+			if err != nil {
+				return volume, err
+			}
+
+			if linodeID == nil && volume.LinodeID == nil {
+				return volume, nil
+			} else if linodeID == nil || volume.LinodeID == nil {
+				// continue waiting
+			} else if *volume.LinodeID == *linodeID {
+				return volume, nil
+			}
+
+		case <-ctx.Done():
+			return nil, fmt.Errorf("Error waiting for Volume %d to have Instance %v: %s", volumeID, linodeID, ctx.Err())
+		}
+	}
+}
+
+// WaitForEventFinished waits for an entity action to reach the 'finished' state
+// before returning. It will timeout with an error after timeoutSeconds.
+// If the event indicates a failure both the failed event and the error will be returned.
+func (client Client) WaitForEventFinished(ctx context.Context, id interface{}, entityType EntityType, action EventAction, minStart time.Time, timeoutSeconds int) (*Event, error) {
+	titledEntityType := strings.Title(string(entityType))
+	filter, _ := json.Marshal(map[string]interface{}{
+		// Entity is not filtered by the API
+		// Perhaps one day they will permit Entity ID/Type filtering.
+		// We'll have to verify these values manually, for now.
+		//"entity": map[string]interface{}{
+		//	"id":   fmt.Sprintf("%v", id),
+		//	"type": entityType,
+		//},
+
+		// Nor is action
+		//"action": action,
+
+		// Created is not correctly filtered by the API
+		// We'll have to verify these values manually, for now.
+		//"created": map[string]interface{}{
+		//	"+gte": minStart.Format(time.RFC3339),
+		//},
+
+		// With potentially 1000+ events coming back, we should filter on something
+		"seen": false,
+
+		// Float the latest events to page 1
+		"+order_by": "created",
+		"+order":    "desc",
+	})
+
+	// Optimistically restrict results to page 1.  We should remove this when more
+	// precise filtering options exist.
+	listOptions := NewListOptions(1, string(filter))
+
+	ctx, cancel := context.WithTimeout(ctx, time.Duration(timeoutSeconds)*time.Second)
+	defer cancel()
+
+	if deadline, ok := ctx.Deadline(); ok {
+		duration := time.Until(deadline)
+		log.Printf("[INFO] Waiting %d seconds for %s events since %v for %s %v", int(duration.Seconds()), action, minStart, titledEntityType, id)
+	}
+
+	ticker := time.NewTicker(time.Second)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ticker.C:
+
+			events, err := client.ListEvents(ctx, listOptions)
+			if err != nil {
+				return nil, err
+			}
+
+			// If there are events for this instance + action, inspect them
+			for _, event := range events {
+				if event.Action != action {
+					// log.Println("action mismatch", event.Action, action)
+					continue
+				}
+				if event.Entity.Type != entityType {
+					// log.Println("type mismatch", event.Entity.Type, entityType)
+					continue
+				}
+
+				var entID string
+
+				switch event.Entity.ID.(type) {
+				case float64, float32:
+					entID = fmt.Sprintf("%.f", event.Entity.ID)
+				case int:
+					entID = strconv.Itoa(event.Entity.ID.(int))
+				default:
+					entID = fmt.Sprintf("%v", event.Entity.ID)
+				}
+
+				var findID string
+				switch id.(type) {
+				case float64, float32:
+					findID = fmt.Sprintf("%.f", id)
+				case int:
+					findID = strconv.Itoa(id.(int))
+				default:
+					findID = fmt.Sprintf("%v", id)
+				}
+
+				if entID != findID {
+					// log.Println("id mismatch", entID, findID)
+					continue
+				}
+
+				// @TODO(displague) This event.Created check shouldn't be needed, but it appears
+				// that the ListEvents method is not populating it correctly
+				if event.Created == nil {
+					log.Printf("[WARN] event.Created is nil when API returned: %#+v", event.CreatedStr)
+				} else if *event.Created != minStart && !event.Created.After(minStart) {
+					// Not the event we were looking for
+					// log.Println(event.Created, "is not >=", minStart)
+					continue
+
+				}
+
+				if event.Status == EventFailed {
+					return &event, fmt.Errorf("%s %v action %s failed", titledEntityType, id, action)
+				} else if event.Status == EventScheduled {
+					log.Printf("[INFO] %s %v action %s is scheduled", titledEntityType, id, action)
+				} else if event.Status == EventFinished {
+					log.Printf("[INFO] %s %v action %s is finished", titledEntityType, id, action)
+					return &event, nil
+				}
+				// TODO(displague) can we bump the ticker to TimeRemaining/2 (>=1) when non-nil?
+				log.Printf("[INFO] %s %v action %s is %s", titledEntityType, id, action, event.Status)
+			}
+		case <-ctx.Done():
+			return nil, fmt.Errorf("Error waiting for Event Status '%s' of %s %v action '%s': %s", EventFinished, titledEntityType, id, action, ctx.Err())
+		}
+	}
+}

vendor/golang.org/x/net/idna/idna.go

@@ -0,0 +1,732 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package idna implements IDNA2008 using the compatibility processing
+// defined by UTS (Unicode Technical Standard) #46, which defines a standard to
+// deal with the transition from IDNA2003.
+//
+// IDNA2008 (Internationalized Domain Names for Applications), is defined in RFC
+// 5890, RFC 5891, RFC 5892, RFC 5893 and RFC 5894.
+// UTS #46 is defined in http://www.unicode.org/reports/tr46.
+// See http://unicode.org/cldr/utility/idna.jsp for a visualization of the
+// differences between these two standards.
+package idna // import "golang.org/x/net/idna"
+
+import (
+	"fmt"
+	"strings"
+	"unicode/utf8"
+
+	"golang.org/x/text/secure/bidirule"
+	"golang.org/x/text/unicode/bidi"
+	"golang.org/x/text/unicode/norm"
+)
+
+// NOTE: Unlike common practice in Go APIs, the functions will return a
+// sanitized domain name in case of errors. Browsers sometimes use a partially
+// evaluated string as lookup.
+// TODO: the current error handling is, in my opinion, the least opinionated.
+// Other strategies are also viable, though:
+// Option 1) Return an empty string in case of error, but allow the user to
+//    specify explicitly which errors to ignore.
+// Option 2) Return the partially evaluated string if it is itself a valid
+//    string, otherwise return the empty string in case of error.
+// Option 3) Option 1 and 2.
+// Option 4) Always return an empty string for now and implement Option 1 as
+//    needed, and document that the return string may not be empty in case of
+//    error in the future.
+// I think Option 1 is best, but it is quite opinionated.
+
+// ToASCII is a wrapper for Punycode.ToASCII.
+func ToASCII(s string) (string, error) {
+	return Punycode.process(s, true)
+}
+
+// ToUnicode is a wrapper for Punycode.ToUnicode.
+func ToUnicode(s string) (string, error) {
+	return Punycode.process(s, false)
+}
+
+// An Option configures a Profile at creation time.
+type Option func(*options)
+
+// Transitional sets a Profile to use the Transitional mapping as defined in UTS
+// #46. This will cause, for example, "ß" to be mapped to "ss". Using the
+// transitional mapping provides a compromise between IDNA2003 and IDNA2008
+// compatibility. It is used by most browsers when resolving domain names. This
+// option is only meaningful if combined with MapForLookup.
+func Transitional(transitional bool) Option {
+	return func(o *options) { o.transitional = true }
+}
+
+// VerifyDNSLength sets whether a Profile should fail if any of the IDN parts
+// are longer than allowed by the RFC.
+func VerifyDNSLength(verify bool) Option {
+	return func(o *options) { o.verifyDNSLength = verify }
+}
+
+// RemoveLeadingDots removes leading label separators. Leading runes that map to
+// dots, such as U+3002 IDEOGRAPHIC FULL STOP, are removed as well.
+//
+// This is the behavior suggested by the UTS #46 and is adopted by some
+// browsers.
+func RemoveLeadingDots(remove bool) Option {
+	return func(o *options) { o.removeLeadingDots = remove }
+}
+
+// ValidateLabels sets whether to check the mandatory label validation criteria
+// as defined in Section 5.4 of RFC 5891. This includes testing for correct use
+// of hyphens ('-'), normalization, validity of runes, and the context rules.
+func ValidateLabels(enable bool) Option {
+	return func(o *options) {
+		// Don't override existing mappings, but set one that at least checks
+		// normalization if it is not set.
+		if o.mapping == nil && enable {
+			o.mapping = normalize
+		}
+		o.trie = trie
+		o.validateLabels = enable
+		o.fromPuny = validateFromPunycode
+	}
+}
+
+// StrictDomainName limits the set of permissible ASCII characters to those
+// allowed in domain names as defined in RFC 1034 (A-Z, a-z, 0-9 and the
+// hyphen). This is set by default for MapForLookup and ValidateForRegistration.
+//
+// This option is useful, for instance, for browsers that allow characters
+// outside this range, for example a '_' (U+005F LOW LINE). See
+// http://www.rfc-editor.org/std/std3.txt for more details This option
+// corresponds to the UseSTD3ASCIIRules option in UTS #46.
+func StrictDomainName(use bool) Option {
+	return func(o *options) {
+		o.trie = trie
+		o.useSTD3Rules = use
+		o.fromPuny = validateFromPunycode
+	}
+}
+
+// NOTE: the following options pull in tables. The tables should not be linked
+// in as long as the options are not used.
+
+// BidiRule enables the Bidi rule as defined in RFC 5893. Any application
+// that relies on proper validation of labels should include this rule.
+func BidiRule() Option {
+	return func(o *options) { o.bidirule = bidirule.ValidString }
+}
+
+// ValidateForRegistration sets validation options to verify that a given IDN is
+// properly formatted for registration as defined by Section 4 of RFC 5891.
+func ValidateForRegistration() Option {
+	return func(o *options) {
+		o.mapping = validateRegistration
+		StrictDomainName(true)(o)
+		ValidateLabels(true)(o)
+		VerifyDNSLength(true)(o)
+		BidiRule()(o)
+	}
+}
+
+// MapForLookup sets validation and mapping options such that a given IDN is
+// transformed for domain name lookup according to the requirements set out in
+// Section 5 of RFC 5891. The mappings follow the recommendations of RFC 5894,
+// RFC 5895 and UTS 46. It does not add the Bidi Rule. Use the BidiRule option
+// to add this check.
+//
+// The mappings include normalization and mapping case, width and other
+// compatibility mappings.
+func MapForLookup() Option {
+	return func(o *options) {
+		o.mapping = validateAndMap
+		StrictDomainName(true)(o)
+		ValidateLabels(true)(o)
+	}
+}
+
+type options struct {
+	transitional      bool
+	useSTD3Rules      bool
+	validateLabels    bool
+	verifyDNSLength   bool
+	removeLeadingDots bool
+
+	trie *idnaTrie
+
+	// fromPuny calls validation rules when converting A-labels to U-labels.
+	fromPuny func(p *Profile, s string) error
+
+	// mapping implements a validation and mapping step as defined in RFC 5895
+	// or UTS 46, tailored to, for example, domain registration or lookup.
+	mapping func(p *Profile, s string) (mapped string, isBidi bool, err error)
+
+	// bidirule, if specified, checks whether s conforms to the Bidi Rule
+	// defined in RFC 5893.
+	bidirule func(s string) bool
+}
+
+// A Profile defines the configuration of an IDNA mapper.
+type Profile struct {
+	options
+}
+
+func apply(o *options, opts []Option) {
+	for _, f := range opts {
+		f(o)
+	}
+}
+
+// New creates a new Profile.
+//
+// With no options, the returned Profile is the most permissive and equals the
+// Punycode Profile. Options can be passed to further restrict the Profile. The
+// MapForLookup and ValidateForRegistration options set a collection of options,
+// for lookup and registration purposes respectively, which can be tailored by
+// adding more fine-grained options, where later options override earlier
+// options.
+func New(o ...Option) *Profile {
+	p := &Profile{}
+	apply(&p.options, o)
+	return p
+}
+
+// ToASCII converts a domain or domain label to its ASCII form. For example,
+// ToASCII("bücher.example.com") is "xn--bcher-kva.example.com", and
+// ToASCII("golang") is "golang". If an error is encountered it will return
+// an error and a (partially) processed result.
+func (p *Profile) ToASCII(s string) (string, error) {
+	return p.process(s, true)
+}
+
+// ToUnicode converts a domain or domain label to its Unicode form. For example,
+// ToUnicode("xn--bcher-kva.example.com") is "bücher.example.com", and
+// ToUnicode("golang") is "golang". If an error is encountered it will return
+// an error and a (partially) processed result.
+func (p *Profile) ToUnicode(s string) (string, error) {
+	pp := *p
+	pp.transitional = false
+	return pp.process(s, false)
+}
+
+// String reports a string with a description of the profile for debugging
+// purposes. The string format may change with different versions.
+func (p *Profile) String() string {
+	s := ""
+	if p.transitional {
+		s = "Transitional"
+	} else {
+		s = "NonTransitional"
+	}
+	if p.useSTD3Rules {
+		s += ":UseSTD3Rules"
+	}
+	if p.validateLabels {
+		s += ":ValidateLabels"
+	}
+	if p.verifyDNSLength {
+		s += ":VerifyDNSLength"
+	}
+	return s
+}
+
+var (
+	// Punycode is a Profile that does raw punycode processing with a minimum
+	// of validation.
+	Punycode *Profile = punycode
+
+	// Lookup is the recommended profile for looking up domain names, according
+	// to Section 5 of RFC 5891. The exact configuration of this profile may
+	// change over time.
+	Lookup *Profile = lookup
+
+	// Display is the recommended profile for displaying domain names.
+	// The configuration of this profile may change over time.
+	Display *Profile = display
+
+	// Registration is the recommended profile for checking whether a given
+	// IDN is valid for registration, according to Section 4 of RFC 5891.
+	Registration *Profile = registration
+
+	punycode = &Profile{}
+	lookup   = &Profile{options{
+		transitional:   true,
+		useSTD3Rules:   true,
+		validateLabels: true,
+		trie:           trie,
+		fromPuny:       validateFromPunycode,
+		mapping:        validateAndMap,
+		bidirule:       bidirule.ValidString,
+	}}
+	display = &Profile{options{
+		useSTD3Rules:   true,
+		validateLabels: true,
+		trie:           trie,
+		fromPuny:       validateFromPunycode,
+		mapping:        validateAndMap,
+		bidirule:       bidirule.ValidString,
+	}}
+	registration = &Profile{options{
+		useSTD3Rules:    true,
+		validateLabels:  true,
+		verifyDNSLength: true,
+		trie:            trie,
+		fromPuny:        validateFromPunycode,
+		mapping:         validateRegistration,
+		bidirule:        bidirule.ValidString,
+	}}
+
+	// TODO: profiles
+	// Register: recommended for approving domain names: don't do any mappings
+	// but rather reject on invalid input. Bundle or block deviation characters.
+)
+
+type labelError struct{ label, code_ string }
+
+func (e labelError) code() string { return e.code_ }
+func (e labelError) Error() string {
+	return fmt.Sprintf("idna: invalid label %q", e.label)
+}
+
+type runeError rune
+
+func (e runeError) code() string { return "P1" }
+func (e runeError) Error() string {
+	return fmt.Sprintf("idna: disallowed rune %U", e)
+}
+
+// process implements the algorithm described in section 4 of UTS #46,
+// see http://www.unicode.org/reports/tr46.
+func (p *Profile) process(s string, toASCII bool) (string, error) {
+	var err error
+	var isBidi bool
+	if p.mapping != nil {
+		s, isBidi, err = p.mapping(p, s)
+	}
+	// Remove leading empty labels.
+	if p.removeLeadingDots {
+		for ; len(s) > 0 && s[0] == '.'; s = s[1:] {
+		}
+	}
+	// TODO: allow for a quick check of the tables data.
+	// It seems like we should only create this error on ToASCII, but the
+	// UTS 46 conformance tests suggests we should always check this.
+	if err == nil && p.verifyDNSLength && s == "" {
+		err = &labelError{s, "A4"}
+	}
+	labels := labelIter{orig: s}
+	for ; !labels.done(); labels.next() {
+		label := labels.label()
+		if label == "" {
+			// Empty labels are not okay. The label iterator skips the last
+			// label if it is empty.
+			if err == nil && p.verifyDNSLength {
+				err = &labelError{s, "A4"}
+			}
+			continue
+		}
+		if strings.HasPrefix(label, acePrefix) {
+			u, err2 := decode(label[len(acePrefix):])
+			if err2 != nil {
+				if err == nil {
+					err = err2
+				}
+				// Spec says keep the old label.
+				continue
+			}
+			isBidi = isBidi || bidirule.DirectionString(u) != bidi.LeftToRight
+			labels.set(u)
+			if err == nil && p.validateLabels {
+				err = p.fromPuny(p, u)
+			}
+			if err == nil {
+				// This should be called on NonTransitional, according to the
+				// spec, but that currently does not have any effect. Use the
+				// original profile to preserve options.
+				err = p.validateLabel(u)
+			}
+		} else if err == nil {
+			err = p.validateLabel(label)
+		}
+	}
+	if isBidi && p.bidirule != nil && err == nil {
+		for labels.reset(); !labels.done(); labels.next() {
+			if !p.bidirule(labels.label()) {
+				err = &labelError{s, "B"}
+				break
+			}
+		}
+	}
+	if toASCII {
+		for labels.reset(); !labels.done(); labels.next() {
+			label := labels.label()
+			if !ascii(label) {
+				a, err2 := encode(acePrefix, label)
+				if err == nil {
+					err = err2
+				}
+				label = a
+				labels.set(a)
+			}
+			n := len(label)
+			if p.verifyDNSLength && err == nil && (n == 0 || n > 63) {
+				err = &labelError{label, "A4"}
+			}
+		}
+	}
+	s = labels.result()
+	if toASCII && p.verifyDNSLength && err == nil {
+		// Compute the length of the domain name minus the root label and its dot.
+		n := len(s)
+		if n > 0 && s[n-1] == '.' {
+			n--
+		}
+		if len(s) < 1 || n > 253 {
+			err = &labelError{s, "A4"}
+		}
+	}
+	return s, err
+}
+
+func normalize(p *Profile, s string) (mapped string, isBidi bool, err error) {
+	// TODO: consider first doing a quick check to see if any of these checks
+	// need to be done. This will make it slower in the general case, but
+	// faster in the common case.
+	mapped = norm.NFC.String(s)
+	isBidi = bidirule.DirectionString(mapped) == bidi.RightToLeft
+	return mapped, isBidi, nil
+}
+
+func validateRegistration(p *Profile, s string) (idem string, bidi bool, err error) {
+	// TODO: filter need for normalization in loop below.
+	if !norm.NFC.IsNormalString(s) {
+		return s, false, &labelError{s, "V1"}
+	}
+	for i := 0; i < len(s); {
+		v, sz := trie.lookupString(s[i:])
+		if sz == 0 {
+			return s, bidi, runeError(utf8.RuneError)
+		}
+		bidi = bidi || info(v).isBidi(s[i:])
+		// Copy bytes not copied so far.
+		switch p.simplify(info(v).category()) {
+		// TODO: handle the NV8 defined in the Unicode idna data set to allow
+		// for strict conformance to IDNA2008.
+		case valid, deviation:
+		case disallowed, mapped, unknown, ignored:
+			r, _ := utf8.DecodeRuneInString(s[i:])
+			return s, bidi, runeError(r)
+		}
+		i += sz
+	}
+	return s, bidi, nil
+}
+
+func (c info) isBidi(s string) bool {
+	if !c.isMapped() {
+		return c&attributesMask == rtl
+	}
+	// TODO: also store bidi info for mapped data. This is possible, but a bit
+	// cumbersome and not for the common case.
+	p, _ := bidi.LookupString(s)
+	switch p.Class() {
+	case bidi.R, bidi.AL, bidi.AN:
+		return true
+	}
+	return false
+}
+
+func validateAndMap(p *Profile, s string) (vm string, bidi bool, err error) {
+	var (
+		b []byte
+		k int
+	)
+	// combinedInfoBits contains the or-ed bits of all runes. We use this
+	// to derive the mayNeedNorm bit later. This may trigger normalization
+	// overeagerly, but it will not do so in the common case. The end result
+	// is another 10% saving on BenchmarkProfile for the common case.
+	var combinedInfoBits info
+	for i := 0; i < len(s); {
+		v, sz := trie.lookupString(s[i:])
+		if sz == 0 {
+			b = append(b, s[k:i]...)
+			b = append(b, "\ufffd"...)
+			k = len(s)
+			if err == nil {
+				err = runeError(utf8.RuneError)
+			}
+			break
+		}
+		combinedInfoBits |= info(v)
+		bidi = bidi || info(v).isBidi(s[i:])
+		start := i
+		i += sz
+		// Copy bytes not copied so far.
+		switch p.simplify(info(v).category()) {
+		case valid:
+			continue
+		case disallowed:
+			if err == nil {
+				r, _ := utf8.DecodeRuneInString(s[start:])
+				err = runeError(r)
+			}
+			continue
+		case mapped, deviation:
+			b = append(b, s[k:start]...)
+			b = info(v).appendMapping(b, s[start:i])
+		case ignored:
+			b = append(b, s[k:start]...)
+			// drop the rune
+		case unknown:
+			b = append(b, s[k:start]...)
+			b = append(b, "\ufffd"...)
+		}
+		k = i
+	}
+	if k == 0 {
+		// No changes so far.
+		if combinedInfoBits&mayNeedNorm != 0 {
+			s = norm.NFC.String(s)
+		}
+	} else {
+		b = append(b, s[k:]...)
+		if norm.NFC.QuickSpan(b) != len(b) {
+			b = norm.NFC.Bytes(b)
+		}
+		// TODO: the punycode converters require strings as input.
+		s = string(b)
+	}
+	return s, bidi, err
+}
+
+// A labelIter allows iterating over domain name labels.
+type labelIter struct {
+	orig     string
+	slice    []string
+	curStart int
+	curEnd   int
+	i        int
+}
+
+func (l *labelIter) reset() {
+	l.curStart = 0
+	l.curEnd = 0
+	l.i = 0
+}
+
+func (l *labelIter) done() bool {
+	return l.curStart >= len(l.orig)
+}
+
+func (l *labelIter) result() string {
+	if l.slice != nil {
+		return strings.Join(l.slice, ".")
+	}
+	return l.orig
+}
+
+func (l *labelIter) label() string {
+	if l.slice != nil {
+		return l.slice[l.i]
+	}
+	p := strings.IndexByte(l.orig[l.curStart:], '.')
+	l.curEnd = l.curStart + p
+	if p == -1 {
+		l.curEnd = len(l.orig)
+	}
+	return l.orig[l.curStart:l.curEnd]
+}
+
+// next sets the value to the next label. It skips the last label if it is empty.
+func (l *labelIter) next() {
+	l.i++
+	if l.slice != nil {
+		if l.i >= len(l.slice) || l.i == len(l.slice)-1 && l.slice[l.i] == "" {
+			l.curStart = len(l.orig)
+		}
+	} else {
+		l.curStart = l.curEnd + 1
+		if l.curStart == len(l.orig)-1 && l.orig[l.curStart] == '.' {
+			l.curStart = len(l.orig)
+		}
+	}
+}
+
+func (l *labelIter) set(s string) {
+	if l.slice == nil {
+		l.slice = strings.Split(l.orig, ".")
+	}
+	l.slice[l.i] = s
+}
+
+// acePrefix is the ASCII Compatible Encoding prefix.
+const acePrefix = "xn--"
+
+func (p *Profile) simplify(cat category) category {
+	switch cat {
+	case disallowedSTD3Mapped:
+		if p.useSTD3Rules {
+			cat = disallowed
+		} else {
+			cat = mapped
+		}
+	case disallowedSTD3Valid:
+		if p.useSTD3Rules {
+			cat = disallowed
+		} else {
+			cat = valid
+		}
+	case deviation:
+		if !p.transitional {
+			cat = valid
+		}
+	case validNV8, validXV8:
+		// TODO: handle V2008
+		cat = valid
+	}
+	return cat
+}
+
+func validateFromPunycode(p *Profile, s string) error {
+	if !norm.NFC.IsNormalString(s) {
+		return &labelError{s, "V1"}
+	}
+	// TODO: detect whether string may have to be normalized in the following
+	// loop.
+	for i := 0; i < len(s); {
+		v, sz := trie.lookupString(s[i:])
+		if sz == 0 {
+			return runeError(utf8.RuneError)
+		}
+		if c := p.simplify(info(v).category()); c != valid && c != deviation {
+			return &labelError{s, "V6"}
+		}
+		i += sz
+	}
+	return nil
+}
+
+const (
+	zwnj = "\u200c"
+	zwj  = "\u200d"
+)
+
+type joinState int8
+
+const (
+	stateStart joinState = iota
+	stateVirama
+	stateBefore
+	stateBeforeVirama
+	stateAfter
+	stateFAIL
+)
+
+var joinStates = [][numJoinTypes]joinState{
+	stateStart: {
+		joiningL:   stateBefore,
+		joiningD:   stateBefore,
+		joinZWNJ:   stateFAIL,
+		joinZWJ:    stateFAIL,
+		joinVirama: stateVirama,
+	},
+	stateVirama: {
+		joiningL: stateBefore,
+		joiningD: stateBefore,
+	},
+	stateBefore: {
+		joiningL:   stateBefore,
+		joiningD:   stateBefore,
+		joiningT:   stateBefore,
+		joinZWNJ:   stateAfter,
+		joinZWJ:    stateFAIL,
+		joinVirama: stateBeforeVirama,
+	},
+	stateBeforeVirama: {
+		joiningL: stateBefore,
+		joiningD: stateBefore,
+		joiningT: stateBefore,
+	},
+	stateAfter: {
+		joiningL:   stateFAIL,
+		joiningD:   stateBefore,
+		joiningT:   stateAfter,
+		joiningR:   stateStart,
+		joinZWNJ:   stateFAIL,
+		joinZWJ:    stateFAIL,
+		joinVirama: stateAfter, // no-op as we can't accept joiners here
+	},
+	stateFAIL: {
+		0:          stateFAIL,
+		joiningL:   stateFAIL,
+		joiningD:   stateFAIL,
+		joiningT:   stateFAIL,
+		joiningR:   stateFAIL,
+		joinZWNJ:   stateFAIL,
+		joinZWJ:    stateFAIL,
+		joinVirama: stateFAIL,
+	},
+}
+
+// validateLabel validates the criteria from Section 4.1. Item 1, 4, and 6 are
+// already implicitly satisfied by the overall implementation.
+func (p *Profile) validateLabel(s string) (err error) {
+	if s == "" {
+		if p.verifyDNSLength {
+			return &labelError{s, "A4"}
+		}
+		return nil
+	}
+	if !p.validateLabels {
+		return nil
+	}
+	trie := p.trie // p.validateLabels is only set if trie is set.
+	if len(s) > 4 && s[2] == '-' && s[3] == '-' {
+		return &labelError{s, "V2"}
+	}
+	if s[0] == '-' || s[len(s)-1] == '-' {
+		return &labelError{s, "V3"}
+	}
+	// TODO: merge the use of this in the trie.
+	v, sz := trie.lookupString(s)
+	x := info(v)
+	if x.isModifier() {
+		return &labelError{s, "V5"}
+	}
+	// Quickly return in the absence of zero-width (non) joiners.
+	if strings.Index(s, zwj) == -1 && strings.Index(s, zwnj) == -1 {
+		return nil
+	}
+	st := stateStart
+	for i := 0; ; {
+		jt := x.joinType()
+		if s[i:i+sz] == zwj {
+			jt = joinZWJ
+		} else if s[i:i+sz] == zwnj {
+			jt = joinZWNJ
+		}
+		st = joinStates[st][jt]
+		if x.isViramaModifier() {
+			st = joinStates[st][joinVirama]
+		}
+		if i += sz; i == len(s) {
+			break
+		}
+		v, sz = trie.lookupString(s[i:])
+		x = info(v)
+	}
+	if st == stateFAIL || st == stateAfter {
+		return &labelError{s, "C"}
+	}
+	return nil
+}
+
+func ascii(s string) bool {
+	for i := 0; i < len(s); i++ {
+		if s[i] >= utf8.RuneSelf {
+			return false
+		}
+	}
+	return true
+}

vendor/golang.org/x/net/idna/punycode.go

@@ -0,0 +1,203 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package idna
+
+// This file implements the Punycode algorithm from RFC 3492.
+
+import (
+	"math"
+	"strings"
+	"unicode/utf8"
+)
+
+// These parameter values are specified in section 5.
+//
+// All computation is done with int32s, so that overflow behavior is identical
+// regardless of whether int is 32-bit or 64-bit.
+const (
+	base        int32 = 36
+	damp        int32 = 700
+	initialBias int32 = 72
+	initialN    int32 = 128
+	skew        int32 = 38
+	tmax        int32 = 26
+	tmin        int32 = 1
+)
+
+func punyError(s string) error { return &labelError{s, "A3"} }
+
+// decode decodes a string as specified in section 6.2.
+func decode(encoded string) (string, error) {
+	if encoded == "" {
+		return "", nil
+	}
+	pos := 1 + strings.LastIndex(encoded, "-")
+	if pos == 1 {
+		return "", punyError(encoded)
+	}
+	if pos == len(encoded) {
+		return encoded[:len(encoded)-1], nil
+	}
+	output := make([]rune, 0, len(encoded))
+	if pos != 0 {
+		for _, r := range encoded[:pos-1] {
+			output = append(output, r)
+		}
+	}
+	i, n, bias := int32(0), initialN, initialBias
+	for pos < len(encoded) {
+		oldI, w := i, int32(1)
+		for k := base; ; k += base {
+			if pos == len(encoded) {
+				return "", punyError(encoded)
+			}
+			digit, ok := decodeDigit(encoded[pos])
+			if !ok {
+				return "", punyError(encoded)
+			}
+			pos++
+			i += digit * w
+			if i < 0 {
+				return "", punyError(encoded)
+			}
+			t := k - bias
+			if t < tmin {
+				t = tmin
+			} else if t > tmax {
+				t = tmax
+			}
+			if digit < t {
+				break
+			}
+			w *= base - t
+			if w >= math.MaxInt32/base {
+				return "", punyError(encoded)
+			}
+		}
+		x := int32(len(output) + 1)
+		bias = adapt(i-oldI, x, oldI == 0)
+		n += i / x
+		i %= x
+		if n > utf8.MaxRune || len(output) >= 1024 {
+			return "", punyError(encoded)
+		}
+		output = append(output, 0)
+		copy(output[i+1:], output[i:])
+		output[i] = n
+		i++
+	}
+	return string(output), nil
+}
+
+// encode encodes a string as specified in section 6.3 and prepends prefix to
+// the result.
+//
+// The "while h < length(input)" line in the specification becomes "for
+// remaining != 0" in the Go code, because len(s) in Go is in bytes, not runes.
+func encode(prefix, s string) (string, error) {
+	output := make([]byte, len(prefix), len(prefix)+1+2*len(s))
+	copy(output, prefix)
+	delta, n, bias := int32(0), initialN, initialBias
+	b, remaining := int32(0), int32(0)
+	for _, r := range s {
+		if r < 0x80 {
+			b++
+			output = append(output, byte(r))
+		} else {
+			remaining++
+		}
+	}
+	h := b
+	if b > 0 {
+		output = append(output, '-')
+	}
+	for remaining != 0 {
+		m := int32(0x7fffffff)
+		for _, r := range s {
+			if m > r && r >= n {
+				m = r
+			}
+		}
+		delta += (m - n) * (h + 1)
+		if delta < 0 {
+			return "", punyError(s)
+		}
+		n = m
+		for _, r := range s {
+			if r < n {
+				delta++
+				if delta < 0 {
+					return "", punyError(s)
+				}
+				continue
+			}
+			if r > n {
+				continue
+			}
+			q := delta
+			for k := base; ; k += base {
+				t := k - bias
+				if t < tmin {
+					t = tmin
+				} else if t > tmax {
+					t = tmax
+				}
+				if q < t {
+					break
+				}
+				output = append(output, encodeDigit(t+(q-t)%(base-t)))
+				q = (q - t) / (base - t)
+			}
+			output = append(output, encodeDigit(q))
+			bias = adapt(delta, h+1, h == b)
+			delta = 0
+			h++
+			remaining--
+		}
+		delta++
+		n++
+	}
+	return string(output), nil
+}
+
+func decodeDigit(x byte) (digit int32, ok bool) {
+	switch {
+	case '0' <= x && x <= '9':
+		return int32(x - ('0' - 26)), true
+	case 'A' <= x && x <= 'Z':
+		return int32(x - 'A'), true
+	case 'a' <= x && x <= 'z':
+		return int32(x - 'a'), true
+	}
+	return 0, false
+}
+
+func encodeDigit(digit int32) byte {
+	switch {
+	case 0 <= digit && digit < 26:
+		return byte(digit + 'a')
+	case 26 <= digit && digit < 36:
+		return byte(digit + ('0' - 26))
+	}
+	panic("idna: internal error in punycode encoding")
+}
+
+// adapt is the bias adaptation function specified in section 6.1.
+func adapt(delta, numPoints int32, firstTime bool) int32 {
+	if firstTime {
+		delta /= damp
+	} else {
+		delta /= 2
+	}
+	delta += delta / numPoints
+	k := int32(0)
+	for delta > ((base-tmin)*tmax)/2 {
+		delta /= base - tmin
+		k += base
+	}
+	return k + (base-tmin+1)*delta/(delta+skew)
+}

vendor/golang.org/x/net/idna/trie.go

@@ -0,0 +1,72 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package idna
+
+// appendMapping appends the mapping for the respective rune. isMapped must be
+// true. A mapping is a categorization of a rune as defined in UTS #46.
+func (c info) appendMapping(b []byte, s string) []byte {
+	index := int(c >> indexShift)
+	if c&xorBit == 0 {
+		s := mappings[index:]
+		return append(b, s[1:s[0]+1]...)
+	}
+	b = append(b, s...)
+	if c&inlineXOR == inlineXOR {
+		// TODO: support and handle two-byte inline masks
+		b[len(b)-1] ^= byte(index)
+	} else {
+		for p := len(b) - int(xorData[index]); p < len(b); p++ {
+			index++
+			b[p] ^= xorData[index]
+		}
+	}
+	return b
+}
+
+// Sparse block handling code.
+
+type valueRange struct {
+	value  uint16 // header: value:stride
+	lo, hi byte   // header: lo:n
+}
+
+type sparseBlocks struct {
+	values []valueRange
+	offset []uint16
+}
+
+var idnaSparse = sparseBlocks{
+	values: idnaSparseValues[:],
+	offset: idnaSparseOffset[:],
+}
+
+// Don't use newIdnaTrie to avoid unconditional linking in of the table.
+var trie = &idnaTrie{}
+
+// lookup determines the type of block n and looks up the value for b.
+// For n < t.cutoff, the block is a simple lookup table. Otherwise, the block
+// is a list of ranges with an accompanying value. Given a matching range r,
+// the value for b is by r.value + (b - r.lo) * stride.
+func (t *sparseBlocks) lookup(n uint32, b byte) uint16 {
+	offset := t.offset[n]
+	header := t.values[offset]
+	lo := offset + 1
+	hi := lo + uint16(header.lo)
+	for lo < hi {
+		m := lo + (hi-lo)/2
+		r := t.values[m]
+		if r.lo <= b && b <= r.hi {
+			return r.value + uint16(b-r.lo)*header.value
+		}
+		if b < r.lo {
+			hi = m
+		} else {
+			lo = m + 1
+		}
+	}
+	return 0
+}

vendor/golang.org/x/net/idna/trieval.go

@@ -0,0 +1,119 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+package idna
+
+// This file contains definitions for interpreting the trie value of the idna
+// trie generated by "go run gen*.go". It is shared by both the generator
+// program and the resultant package. Sharing is achieved by the generator
+// copying gen_trieval.go to trieval.go and changing what's above this comment.
+
+// info holds information from the IDNA mapping table for a single rune. It is
+// the value returned by a trie lookup. In most cases, all information fits in
+// a 16-bit value. For mappings, this value may contain an index into a slice
+// with the mapped string. Such mappings can consist of the actual mapped value
+// or an XOR pattern to be applied to the bytes of the UTF8 encoding of the
+// input rune. This technique is used by the cases packages and reduces the
+// table size significantly.
+//
+// The per-rune values have the following format:
+//
+//   if mapped {
+//     if inlinedXOR {
+//       15..13 inline XOR marker
+//       12..11 unused
+//       10..3  inline XOR mask
+//     } else {
+//       15..3  index into xor or mapping table
+//     }
+//   } else {
+//       15..14 unused
+//       13     mayNeedNorm
+//       12..11 attributes
+//       10..8  joining type
+//        7..3  category type
+//   }
+//      2  use xor pattern
+//   1..0  mapped category
+//
+// See the definitions below for a more detailed description of the various
+// bits.
+type info uint16
+
+const (
+	catSmallMask = 0x3
+	catBigMask   = 0xF8
+	indexShift   = 3
+	xorBit       = 0x4    // interpret the index as an xor pattern
+	inlineXOR    = 0xE000 // These bits are set if the XOR pattern is inlined.
+
+	joinShift = 8
+	joinMask  = 0x07
+
+	// Attributes
+	attributesMask = 0x1800
+	viramaModifier = 0x1800
+	modifier       = 0x1000
+	rtl            = 0x0800
+
+	mayNeedNorm = 0x2000
+)
+
+// A category corresponds to a category defined in the IDNA mapping table.
+type category uint16
+
+const (
+	unknown              category = 0 // not currently defined in unicode.
+	mapped               category = 1
+	disallowedSTD3Mapped category = 2
+	deviation            category = 3
+)
+
+const (
+	valid               category = 0x08
+	validNV8            category = 0x18
+	validXV8            category = 0x28
+	disallowed          category = 0x40
+	disallowedSTD3Valid category = 0x80
+	ignored             category = 0xC0
+)
+
+// join types and additional rune information
+const (
+	joiningL = (iota + 1)
+	joiningD
+	joiningT
+	joiningR
+
+	//the following types are derived during processing
+	joinZWJ
+	joinZWNJ
+	joinVirama
+	numJoinTypes
+)
+
+func (c info) isMapped() bool {
+	return c&0x3 != 0
+}
+
+func (c info) category() category {
+	small := c & catSmallMask
+	if small != 0 {
+		return category(small)
+	}
+	return category(c & catBigMask)
+}
+
+func (c info) joinType() info {
+	if c.isMapped() {
+		return 0
+	}
+	return (c >> joinShift) & joinMask
+}
+
+func (c info) isModifier() bool {
+	return c&(modifier|catSmallMask) == modifier
+}
+
+func (c info) isViramaModifier() bool {
+	return c&(attributesMask|catSmallMask) == viramaModifier
+}

vendor/golang.org/x/net/publicsuffix/gen.go

@@ -0,0 +1,713 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+package main
+
+// This program generates table.go and table_test.go based on the authoritative
+// public suffix list at https://publicsuffix.org/list/effective_tld_names.dat
+//
+// The version is derived from
+// https://api.github.com/repos/publicsuffix/list/commits?path=public_suffix_list.dat
+// and a human-readable form is at
+// https://github.com/publicsuffix/list/commits/master/public_suffix_list.dat
+//
+// To fetch a particular git revision, such as 5c70ccd250, pass
+// -url "https://raw.githubusercontent.com/publicsuffix/list/5c70ccd250/public_suffix_list.dat"
+// and -version "an explicit version string".
+
+import (
+	"bufio"
+	"bytes"
+	"flag"
+	"fmt"
+	"go/format"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"regexp"
+	"sort"
+	"strings"
+
+	"golang.org/x/net/idna"
+)
+
+const (
+	// These sum of these four values must be no greater than 32.
+	nodesBitsChildren   = 10
+	nodesBitsICANN      = 1
+	nodesBitsTextOffset = 15
+	nodesBitsTextLength = 6
+
+	// These sum of these four values must be no greater than 32.
+	childrenBitsWildcard = 1
+	childrenBitsNodeType = 2
+	childrenBitsHi       = 14
+	childrenBitsLo       = 14
+)
+
+var (
+	maxChildren   int
+	maxTextOffset int
+	maxTextLength int
+	maxHi         uint32
+	maxLo         uint32
+)
+
+func max(a, b int) int {
+	if a < b {
+		return b
+	}
+	return a
+}
+
+func u32max(a, b uint32) uint32 {
+	if a < b {
+		return b
+	}
+	return a
+}
+
+const (
+	nodeTypeNormal     = 0
+	nodeTypeException  = 1
+	nodeTypeParentOnly = 2
+	numNodeType        = 3
+)
+
+func nodeTypeStr(n int) string {
+	switch n {
+	case nodeTypeNormal:
+		return "+"
+	case nodeTypeException:
+		return "!"
+	case nodeTypeParentOnly:
+		return "o"
+	}
+	panic("unreachable")
+}
+
+const (
+	defaultURL   = "https://publicsuffix.org/list/effective_tld_names.dat"
+	gitCommitURL = "https://api.github.com/repos/publicsuffix/list/commits?path=public_suffix_list.dat"
+)
+
+var (
+	labelEncoding = map[string]uint32{}
+	labelsList    = []string{}
+	labelsMap     = map[string]bool{}
+	rules         = []string{}
+
+	// validSuffixRE is used to check that the entries in the public suffix
+	// list are in canonical form (after Punycode encoding). Specifically,
+	// capital letters are not allowed.
+	validSuffixRE = regexp.MustCompile(`^[a-z0-9_\!\*\-\.]+$`)
+
+	shaRE  = regexp.MustCompile(`"sha":"([^"]+)"`)
+	dateRE = regexp.MustCompile(`"committer":{[^{]+"date":"([^"]+)"`)
+
+	comments = flag.Bool("comments", false, "generate table.go comments, for debugging")
+	subset   = flag.Bool("subset", false, "generate only a subset of the full table, for debugging")
+	url      = flag.String("url", defaultURL, "URL of the publicsuffix.org list. If empty, stdin is read instead")
+	v        = flag.Bool("v", false, "verbose output (to stderr)")
+	version  = flag.String("version", "", "the effective_tld_names.dat version")
+)
+
+func main() {
+	if err := main1(); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+func main1() error {
+	flag.Parse()
+	if nodesBitsTextLength+nodesBitsTextOffset+nodesBitsICANN+nodesBitsChildren > 32 {
+		return fmt.Errorf("not enough bits to encode the nodes table")
+	}
+	if childrenBitsLo+childrenBitsHi+childrenBitsNodeType+childrenBitsWildcard > 32 {
+		return fmt.Errorf("not enough bits to encode the children table")
+	}
+	if *version == "" {
+		if *url != defaultURL {
+			return fmt.Errorf("-version was not specified, and the -url is not the default one")
+		}
+		sha, date, err := gitCommit()
+		if err != nil {
+			return err
+		}
+		*version = fmt.Sprintf("publicsuffix.org's public_suffix_list.dat, git revision %s (%s)", sha, date)
+	}
+	var r io.Reader = os.Stdin
+	if *url != "" {
+		res, err := http.Get(*url)
+		if err != nil {
+			return err
+		}
+		if res.StatusCode != http.StatusOK {
+			return fmt.Errorf("bad GET status for %s: %d", *url, res.Status)
+		}
+		r = res.Body
+		defer res.Body.Close()
+	}
+
+	var root node
+	icann := false
+	br := bufio.NewReader(r)
+	for {
+		s, err := br.ReadString('\n')
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+		s = strings.TrimSpace(s)
+		if strings.Contains(s, "BEGIN ICANN DOMAINS") {
+			icann = true
+			continue
+		}
+		if strings.Contains(s, "END ICANN DOMAINS") {
+			icann = false
+			continue
+		}
+		if s == "" || strings.HasPrefix(s, "//") {
+			continue
+		}
+		s, err = idna.ToASCII(s)
+		if err != nil {
+			return err
+		}
+		if !validSuffixRE.MatchString(s) {
+			return fmt.Errorf("bad publicsuffix.org list data: %q", s)
+		}
+
+		if *subset {
+			switch {
+			case s == "ac.jp" || strings.HasSuffix(s, ".ac.jp"):
+			case s == "ak.us" || strings.HasSuffix(s, ".ak.us"):
+			case s == "ao" || strings.HasSuffix(s, ".ao"):
+			case s == "ar" || strings.HasSuffix(s, ".ar"):
+			case s == "arpa" || strings.HasSuffix(s, ".arpa"):
+			case s == "cy" || strings.HasSuffix(s, ".cy"):
+			case s == "dyndns.org" || strings.HasSuffix(s, ".dyndns.org"):
+			case s == "jp":
+			case s == "kobe.jp" || strings.HasSuffix(s, ".kobe.jp"):
+			case s == "kyoto.jp" || strings.HasSuffix(s, ".kyoto.jp"):
+			case s == "om" || strings.HasSuffix(s, ".om"):
+			case s == "uk" || strings.HasSuffix(s, ".uk"):
+			case s == "uk.com" || strings.HasSuffix(s, ".uk.com"):
+			case s == "tw" || strings.HasSuffix(s, ".tw"):
+			case s == "zw" || strings.HasSuffix(s, ".zw"):
+			case s == "xn--p1ai" || strings.HasSuffix(s, ".xn--p1ai"):
+				// xn--p1ai is Russian-Cyrillic "рф".
+			default:
+				continue
+			}
+		}
+
+		rules = append(rules, s)
+
+		nt, wildcard := nodeTypeNormal, false
+		switch {
+		case strings.HasPrefix(s, "*."):
+			s, nt = s[2:], nodeTypeParentOnly
+			wildcard = true
+		case strings.HasPrefix(s, "!"):
+			s, nt = s[1:], nodeTypeException
+		}
+		labels := strings.Split(s, ".")
+		for n, i := &root, len(labels)-1; i >= 0; i-- {
+			label := labels[i]
+			n = n.child(label)
+			if i == 0 {
+				if nt != nodeTypeParentOnly && n.nodeType == nodeTypeParentOnly {
+					n.nodeType = nt
+				}
+				n.icann = n.icann && icann
+				n.wildcard = n.wildcard || wildcard
+			}
+			labelsMap[label] = true
+		}
+	}
+	labelsList = make([]string, 0, len(labelsMap))
+	for label := range labelsMap {
+		labelsList = append(labelsList, label)
+	}
+	sort.Strings(labelsList)
+
+	if err := generate(printReal, &root, "table.go"); err != nil {
+		return err
+	}
+	if err := generate(printTest, &root, "table_test.go"); err != nil {
+		return err
+	}
+	return nil
+}
+
+func generate(p func(io.Writer, *node) error, root *node, filename string) error {
+	buf := new(bytes.Buffer)
+	if err := p(buf, root); err != nil {
+		return err
+	}
+	b, err := format.Source(buf.Bytes())
+	if err != nil {
+		return err
+	}
+	return ioutil.WriteFile(filename, b, 0644)
+}
+
+func gitCommit() (sha, date string, retErr error) {
+	res, err := http.Get(gitCommitURL)
+	if err != nil {
+		return "", "", err
+	}
+	if res.StatusCode != http.StatusOK {
+		return "", "", fmt.Errorf("bad GET status for %s: %d", gitCommitURL, res.Status)
+	}
+	defer res.Body.Close()
+	b, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return "", "", err
+	}
+	if m := shaRE.FindSubmatch(b); m != nil {
+		sha = string(m[1])
+	}
+	if m := dateRE.FindSubmatch(b); m != nil {
+		date = string(m[1])
+	}
+	if sha == "" || date == "" {
+		retErr = fmt.Errorf("could not find commit SHA and date in %s", gitCommitURL)
+	}
+	return sha, date, retErr
+}
+
+func printTest(w io.Writer, n *node) error {
+	fmt.Fprintf(w, "// generated by go run gen.go; DO NOT EDIT\n\n")
+	fmt.Fprintf(w, "package publicsuffix\n\nvar rules = [...]string{\n")
+	for _, rule := range rules {
+		fmt.Fprintf(w, "%q,\n", rule)
+	}
+	fmt.Fprintf(w, "}\n\nvar nodeLabels = [...]string{\n")
+	if err := n.walk(w, printNodeLabel); err != nil {
+		return err
+	}
+	fmt.Fprintf(w, "}\n")
+	return nil
+}
+
+func printReal(w io.Writer, n *node) error {
+	const header = `// generated by go run gen.go; DO NOT EDIT
+
+package publicsuffix
+
+const version = %q
+
+const (
+	nodesBitsChildren   = %d
+	nodesBitsICANN      = %d
+	nodesBitsTextOffset = %d
+	nodesBitsTextLength = %d
+
+	childrenBitsWildcard = %d
+	childrenBitsNodeType = %d
+	childrenBitsHi       = %d
+	childrenBitsLo       = %d
+)
+
+const (
+	nodeTypeNormal     = %d
+	nodeTypeException  = %d
+	nodeTypeParentOnly = %d
+)
+
+// numTLD is the number of top level domains.
+const numTLD = %d
+
+`
+	fmt.Fprintf(w, header, *version,
+		nodesBitsChildren, nodesBitsICANN, nodesBitsTextOffset, nodesBitsTextLength,
+		childrenBitsWildcard, childrenBitsNodeType, childrenBitsHi, childrenBitsLo,
+		nodeTypeNormal, nodeTypeException, nodeTypeParentOnly, len(n.children))
+
+	text := combineText(labelsList)
+	if text == "" {
+		return fmt.Errorf("internal error: makeText returned no text")
+	}
+	for _, label := range labelsList {
+		offset, length := strings.Index(text, label), len(label)
+		if offset < 0 {
+			return fmt.Errorf("internal error: could not find %q in text %q", label, text)
+		}
+		maxTextOffset, maxTextLength = max(maxTextOffset, offset), max(maxTextLength, length)
+		if offset >= 1<<nodesBitsTextOffset {
+			return fmt.Errorf("text offset %d is too large, or nodeBitsTextOffset is too small", offset)
+		}
+		if length >= 1<<nodesBitsTextLength {
+			return fmt.Errorf("text length %d is too large, or nodeBitsTextLength is too small", length)
+		}
+		labelEncoding[label] = uint32(offset)<<nodesBitsTextLength | uint32(length)
+	}
+	fmt.Fprintf(w, "// Text is the combined text of all labels.\nconst text = ")
+	for len(text) > 0 {
+		n, plus := len(text), ""
+		if n > 64 {
+			n, plus = 64, " +"
+		}
+		fmt.Fprintf(w, "%q%s\n", text[:n], plus)
+		text = text[n:]
+	}
+
+	if err := n.walk(w, assignIndexes); err != nil {
+		return err
+	}
+
+	fmt.Fprintf(w, `
+
+// nodes is the list of nodes. Each node is represented as a uint32, which
+// encodes the node's children, wildcard bit and node type (as an index into
+// the children array), ICANN bit and text.
+//
+// If the table was generated with the -comments flag, there is a //-comment
+// after each node's data. In it is the nodes-array indexes of the children,
+// formatted as (n0x1234-n0x1256), with * denoting the wildcard bit. The
+// nodeType is printed as + for normal, ! for exception, and o for parent-only
+// nodes that have children but don't match a domain label in their own right.
+// An I denotes an ICANN domain.
+//
+// The layout within the uint32, from MSB to LSB, is:
+//	[%2d bits] unused
+//	[%2d bits] children index
+//	[%2d bits] ICANN bit
+//	[%2d bits] text index
+//	[%2d bits] text length
+var nodes = [...]uint32{
+`,
+		32-nodesBitsChildren-nodesBitsICANN-nodesBitsTextOffset-nodesBitsTextLength,
+		nodesBitsChildren, nodesBitsICANN, nodesBitsTextOffset, nodesBitsTextLength)
+	if err := n.walk(w, printNode); err != nil {
+		return err
+	}
+	fmt.Fprintf(w, `}
+
+// children is the list of nodes' children, the parent's wildcard bit and the
+// parent's node type. If a node has no children then their children index
+// will be in the range [0, 6), depending on the wildcard bit and node type.
+//
+// The layout within the uint32, from MSB to LSB, is:
+//	[%2d bits] unused
+//	[%2d bits] wildcard bit
+//	[%2d bits] node type
+//	[%2d bits] high nodes index (exclusive) of children
+//	[%2d bits] low nodes index (inclusive) of children
+var children=[...]uint32{
+`,
+		32-childrenBitsWildcard-childrenBitsNodeType-childrenBitsHi-childrenBitsLo,
+		childrenBitsWildcard, childrenBitsNodeType, childrenBitsHi, childrenBitsLo)
+	for i, c := range childrenEncoding {
+		s := "---------------"
+		lo := c & (1<<childrenBitsLo - 1)
+		hi := (c >> childrenBitsLo) & (1<<childrenBitsHi - 1)
+		if lo != hi {
+			s = fmt.Sprintf("n0x%04x-n0x%04x", lo, hi)
+		}
+		nodeType := int(c>>(childrenBitsLo+childrenBitsHi)) & (1<<childrenBitsNodeType - 1)
+		wildcard := c>>(childrenBitsLo+childrenBitsHi+childrenBitsNodeType) != 0
+		if *comments {
+			fmt.Fprintf(w, "0x%08x, // c0x%04x (%s)%s %s\n",
+				c, i, s, wildcardStr(wildcard), nodeTypeStr(nodeType))
+		} else {
+			fmt.Fprintf(w, "0x%x,\n", c)
+		}
+	}
+	fmt.Fprintf(w, "}\n\n")
+	fmt.Fprintf(w, "// max children %d (capacity %d)\n", maxChildren, 1<<nodesBitsChildren-1)
+	fmt.Fprintf(w, "// max text offset %d (capacity %d)\n", maxTextOffset, 1<<nodesBitsTextOffset-1)
+	fmt.Fprintf(w, "// max text length %d (capacity %d)\n", maxTextLength, 1<<nodesBitsTextLength-1)
+	fmt.Fprintf(w, "// max hi %d (capacity %d)\n", maxHi, 1<<childrenBitsHi-1)
+	fmt.Fprintf(w, "// max lo %d (capacity %d)\n", maxLo, 1<<childrenBitsLo-1)
+	return nil
+}
+
+type node struct {
+	label    string
+	nodeType int
+	icann    bool
+	wildcard bool
+	// nodesIndex and childrenIndex are the index of this node in the nodes
+	// and the index of its children offset/length in the children arrays.
+	nodesIndex, childrenIndex int
+	// firstChild is the index of this node's first child, or zero if this
+	// node has no children.
+	firstChild int
+	// children are the node's children, in strictly increasing node label order.
+	children []*node
+}
+
+func (n *node) walk(w io.Writer, f func(w1 io.Writer, n1 *node) error) error {
+	if err := f(w, n); err != nil {
+		return err
+	}
+	for _, c := range n.children {
+		if err := c.walk(w, f); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// child returns the child of n with the given label. The child is created if
+// it did not exist beforehand.
+func (n *node) child(label string) *node {
+	for _, c := range n.children {
+		if c.label == label {
+			return c
+		}
+	}
+	c := &node{
+		label:    label,
+		nodeType: nodeTypeParentOnly,
+		icann:    true,
+	}
+	n.children = append(n.children, c)
+	sort.Sort(byLabel(n.children))
+	return c
+}
+
+type byLabel []*node
+
+func (b byLabel) Len() int           { return len(b) }
+func (b byLabel) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
+func (b byLabel) Less(i, j int) bool { return b[i].label < b[j].label }
+
+var nextNodesIndex int
+
+// childrenEncoding are the encoded entries in the generated children array.
+// All these pre-defined entries have no children.
+var childrenEncoding = []uint32{
+	0 << (childrenBitsLo + childrenBitsHi), // Without wildcard bit, nodeTypeNormal.
+	1 << (childrenBitsLo + childrenBitsHi), // Without wildcard bit, nodeTypeException.
+	2 << (childrenBitsLo + childrenBitsHi), // Without wildcard bit, nodeTypeParentOnly.
+	4 << (childrenBitsLo + childrenBitsHi), // With wildcard bit, nodeTypeNormal.
+	5 << (childrenBitsLo + childrenBitsHi), // With wildcard bit, nodeTypeException.
+	6 << (childrenBitsLo + childrenBitsHi), // With wildcard bit, nodeTypeParentOnly.
+}
+
+var firstCallToAssignIndexes = true
+
+func assignIndexes(w io.Writer, n *node) error {
+	if len(n.children) != 0 {
+		// Assign nodesIndex.
+		n.firstChild = nextNodesIndex
+		for _, c := range n.children {
+			c.nodesIndex = nextNodesIndex
+			nextNodesIndex++
+		}
+
+		// The root node's children is implicit.
+		if firstCallToAssignIndexes {
+			firstCallToAssignIndexes = false
+			return nil
+		}
+
+		// Assign childrenIndex.
+		maxChildren = max(maxChildren, len(childrenEncoding))
+		if len(childrenEncoding) >= 1<<nodesBitsChildren {
+			return fmt.Errorf("children table size %d is too large, or nodeBitsChildren is too small", len(childrenEncoding))
+		}
+		n.childrenIndex = len(childrenEncoding)
+		lo := uint32(n.firstChild)
+		hi := lo + uint32(len(n.children))
+		maxLo, maxHi = u32max(maxLo, lo), u32max(maxHi, hi)
+		if lo >= 1<<childrenBitsLo {
+			return fmt.Errorf("children lo %d is too large, or childrenBitsLo is too small", lo)
+		}
+		if hi >= 1<<childrenBitsHi {
+			return fmt.Errorf("children hi %d is too large, or childrenBitsHi is too small", hi)
+		}
+		enc := hi<<childrenBitsLo | lo
+		enc |= uint32(n.nodeType) << (childrenBitsLo + childrenBitsHi)
+		if n.wildcard {
+			enc |= 1 << (childrenBitsLo + childrenBitsHi + childrenBitsNodeType)
+		}
+		childrenEncoding = append(childrenEncoding, enc)
+	} else {
+		n.childrenIndex = n.nodeType
+		if n.wildcard {
+			n.childrenIndex += numNodeType
+		}
+	}
+	return nil
+}
+
+func printNode(w io.Writer, n *node) error {
+	for _, c := range n.children {
+		s := "---------------"
+		if len(c.children) != 0 {
+			s = fmt.Sprintf("n0x%04x-n0x%04x", c.firstChild, c.firstChild+len(c.children))
+		}
+		encoding := labelEncoding[c.label]
+		if c.icann {
+			encoding |= 1 << (nodesBitsTextLength + nodesBitsTextOffset)
+		}
+		encoding |= uint32(c.childrenIndex) << (nodesBitsTextLength + nodesBitsTextOffset + nodesBitsICANN)
+		if *comments {
+			fmt.Fprintf(w, "0x%08x, // n0x%04x c0x%04x (%s)%s %s %s %s\n",
+				encoding, c.nodesIndex, c.childrenIndex, s, wildcardStr(c.wildcard),
+				nodeTypeStr(c.nodeType), icannStr(c.icann), c.label,
+			)
+		} else {
+			fmt.Fprintf(w, "0x%x,\n", encoding)
+		}
+	}
+	return nil
+}
+
+func printNodeLabel(w io.Writer, n *node) error {
+	for _, c := range n.children {
+		fmt.Fprintf(w, "%q,\n", c.label)
+	}
+	return nil
+}
+
+func icannStr(icann bool) string {
+	if icann {
+		return "I"
+	}
+	return " "
+}
+
+func wildcardStr(wildcard bool) string {
+	if wildcard {
+		return "*"
+	}
+	return " "
+}
+
+// combineText combines all the strings in labelsList to form one giant string.
+// Overlapping strings will be merged: "arpa" and "parliament" could yield
+// "arparliament".
+func combineText(labelsList []string) string {
+	beforeLength := 0
+	for _, s := range labelsList {
+		beforeLength += len(s)
+	}
+
+	text := crush(removeSubstrings(labelsList))
+	if *v {
+		fmt.Fprintf(os.Stderr, "crushed %d bytes to become %d bytes\n", beforeLength, len(text))
+	}
+	return text
+}
+
+type byLength []string
+
+func (s byLength) Len() int           { return len(s) }
+func (s byLength) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+func (s byLength) Less(i, j int) bool { return len(s[i]) < len(s[j]) }
+
+// removeSubstrings returns a copy of its input with any strings removed
+// that are substrings of other provided strings.
+func removeSubstrings(input []string) []string {
+	// Make a copy of input.
+	ss := append(make([]string, 0, len(input)), input...)
+	sort.Sort(byLength(ss))
+
+	for i, shortString := range ss {
+		// For each string, only consider strings higher than it in sort order, i.e.
+		// of equal length or greater.
+		for _, longString := range ss[i+1:] {
+			if strings.Contains(longString, shortString) {
+				ss[i] = ""
+				break
+			}
+		}
+	}
+
+	// Remove the empty strings.
+	sort.Strings(ss)
+	for len(ss) > 0 && ss[0] == "" {
+		ss = ss[1:]
+	}
+	return ss
+}
+
+// crush combines a list of strings, taking advantage of overlaps. It returns a
+// single string that contains each input string as a substring.
+func crush(ss []string) string {
+	maxLabelLen := 0
+	for _, s := range ss {
+		if maxLabelLen < len(s) {
+			maxLabelLen = len(s)
+		}
+	}
+
+	for prefixLen := maxLabelLen; prefixLen > 0; prefixLen-- {
+		prefixes := makePrefixMap(ss, prefixLen)
+		for i, s := range ss {
+			if len(s) <= prefixLen {
+				continue
+			}
+			mergeLabel(ss, i, prefixLen, prefixes)
+		}
+	}
+
+	return strings.Join(ss, "")
+}
+
+// mergeLabel merges the label at ss[i] with the first available matching label
+// in prefixMap, where the last "prefixLen" characters in ss[i] match the first
+// "prefixLen" characters in the matching label.
+// It will merge ss[i] repeatedly until no more matches are available.
+// All matching labels merged into ss[i] are replaced by "".
+func mergeLabel(ss []string, i, prefixLen int, prefixes prefixMap) {
+	s := ss[i]
+	suffix := s[len(s)-prefixLen:]
+	for _, j := range prefixes[suffix] {
+		// Empty strings mean "already used." Also avoid merging with self.
+		if ss[j] == "" || i == j {
+			continue
+		}
+		if *v {
+			fmt.Fprintf(os.Stderr, "%d-length overlap at (%4d,%4d): %q and %q share %q\n",
+				prefixLen, i, j, ss[i], ss[j], suffix)
+		}
+		ss[i] += ss[j][prefixLen:]
+		ss[j] = ""
+		// ss[i] has a new suffix, so merge again if possible.
+		// Note: we only have to merge again at the same prefix length. Shorter
+		// prefix lengths will be handled in the next iteration of crush's for loop.
+		// Can there be matches for longer prefix lengths, introduced by the merge?
+		// I believe that any such matches would by necessity have been eliminated
+		// during substring removal or merged at a higher prefix length. For
+		// instance, in crush("abc", "cde", "bcdef"), combining "abc" and "cde"
+		// would yield "abcde", which could be merged with "bcdef." However, in
+		// practice "cde" would already have been elimintated by removeSubstrings.
+		mergeLabel(ss, i, prefixLen, prefixes)
+		return
+	}
+}
+
+// prefixMap maps from a prefix to a list of strings containing that prefix. The
+// list of strings is represented as indexes into a slice of strings stored
+// elsewhere.
+type prefixMap map[string][]int
+
+// makePrefixMap constructs a prefixMap from a slice of strings.
+func makePrefixMap(ss []string, prefixLen int) prefixMap {
+	prefixes := make(prefixMap)
+	for i, s := range ss {
+		// We use < rather than <= because if a label matches on a prefix equal to
+		// its full length, that's actually a substring match handled by
+		// removeSubstrings.
+		if prefixLen < len(s) {
+			prefix := s[:prefixLen]
+			prefixes[prefix] = append(prefixes[prefix], i)
+		}
+	}
+
+	return prefixes
+}

vendor/golang.org/x/net/publicsuffix/list.go

@@ -0,0 +1,170 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:generate go run gen.go
+
+// Package publicsuffix provides a public suffix list based on data from
+// https://publicsuffix.org/
+//
+// A public suffix is one under which Internet users can directly register
+// names. It is related to, but different from, a TLD (top level domain).
+//
+// "com" is a TLD (top level domain). Top level means it has no dots.
+//
+// "com" is also a public suffix. Amazon and Google have registered different
+// siblings under that domain: "amazon.com" and "google.com".
+//
+// "au" is another TLD, again because it has no dots. But it's not "amazon.au".
+// Instead, it's "amazon.com.au".
+//
+// "com.au" isn't an actual TLD, because it's not at the top level (it has
+// dots). But it is an eTLD (effective TLD), because that's the branching point
+// for domain name registrars.
+//
+// Another name for "an eTLD" is "a public suffix". Often, what's more of
+// interest is the eTLD+1, or one more label than the public suffix. For
+// example, browsers partition read/write access to HTTP cookies according to
+// the eTLD+1. Web pages served from "amazon.com.au" can't read cookies from
+// "google.com.au", but web pages served from "maps.google.com" can share
+// cookies from "www.google.com", so you don't have to sign into Google Maps
+// separately from signing into Google Web Search. Note that all four of those
+// domains have 3 labels and 2 dots. The first two domains are each an eTLD+1,
+// the last two are not (but share the same eTLD+1: "google.com").
+//
+// All of these domains have the same eTLD+1:
+//  - "www.books.amazon.co.uk"
+//  - "books.amazon.co.uk"
+//  - "amazon.co.uk"
+// Specifically, the eTLD+1 is "amazon.co.uk", because the eTLD is "co.uk".
+//
+// There is no closed form algorithm to calculate the eTLD of a domain.
+// Instead, the calculation is data driven. This package provides a
+// pre-compiled snapshot of Mozilla's PSL (Public Suffix List) data at
+// https://publicsuffix.org/
+package publicsuffix // import "golang.org/x/net/publicsuffix"
+
+// TODO: specify case sensitivity and leading/trailing dot behavior for
+// func PublicSuffix and func EffectiveTLDPlusOne.
+
+import (
+	"fmt"
+	"net/http/cookiejar"
+	"strings"
+)
+
+// List implements the cookiejar.PublicSuffixList interface by calling the
+// PublicSuffix function.
+var List cookiejar.PublicSuffixList = list{}
+
+type list struct{}
+
+func (list) PublicSuffix(domain string) string {
+	ps, _ := PublicSuffix(domain)
+	return ps
+}
+
+func (list) String() string {
+	return version
+}
+
+// PublicSuffix returns the public suffix of the domain using a copy of the
+// publicsuffix.org database compiled into the library.
+//
+// icann is whether the public suffix is managed by the Internet Corporation
+// for Assigned Names and Numbers. If not, the public suffix is privately
+// managed. For example, foo.org and foo.co.uk are ICANN domains,
+// foo.dyndns.org and foo.blogspot.co.uk are private domains.
+//
+// Use cases for distinguishing ICANN domains like foo.com from private
+// domains like foo.appspot.com can be found at
+// https://wiki.mozilla.org/Public_Suffix_List/Use_Cases
+func PublicSuffix(domain string) (publicSuffix string, icann bool) {
+	lo, hi := uint32(0), uint32(numTLD)
+	s, suffix, wildcard := domain, len(domain), false
+loop:
+	for {
+		dot := strings.LastIndex(s, ".")
+		if wildcard {
+			suffix = 1 + dot
+		}
+		if lo == hi {
+			break
+		}
+		f := find(s[1+dot:], lo, hi)
+		if f == notFound {
+			break
+		}
+
+		u := nodes[f] >> (nodesBitsTextOffset + nodesBitsTextLength)
+		icann = u&(1<<nodesBitsICANN-1) != 0
+		u >>= nodesBitsICANN
+		u = children[u&(1<<nodesBitsChildren-1)]
+		lo = u & (1<<childrenBitsLo - 1)
+		u >>= childrenBitsLo
+		hi = u & (1<<childrenBitsHi - 1)
+		u >>= childrenBitsHi
+		switch u & (1<<childrenBitsNodeType - 1) {
+		case nodeTypeNormal:
+			suffix = 1 + dot
+		case nodeTypeException:
+			suffix = 1 + len(s)
+			break loop
+		}
+		u >>= childrenBitsNodeType
+		wildcard = u&(1<<childrenBitsWildcard-1) != 0
+
+		if dot == -1 {
+			break
+		}
+		s = s[:dot]
+	}
+	if suffix == len(domain) {
+		// If no rules match, the prevailing rule is "*".
+		return domain[1+strings.LastIndex(domain, "."):], icann
+	}
+	return domain[suffix:], icann
+}
+
+const notFound uint32 = 1<<32 - 1
+
+// find returns the index of the node in the range [lo, hi) whose label equals
+// label, or notFound if there is no such node. The range is assumed to be in
+// strictly increasing node label order.
+func find(label string, lo, hi uint32) uint32 {
+	for lo < hi {
+		mid := lo + (hi-lo)/2
+		s := nodeLabel(mid)
+		if s < label {
+			lo = mid + 1
+		} else if s == label {
+			return mid
+		} else {
+			hi = mid
+		}
+	}
+	return notFound
+}
+
+// nodeLabel returns the label for the i'th node.
+func nodeLabel(i uint32) string {
+	x := nodes[i]
+	length := x & (1<<nodesBitsTextLength - 1)
+	x >>= nodesBitsTextLength
+	offset := x & (1<<nodesBitsTextOffset - 1)
+	return text[offset : offset+length]
+}
+
+// EffectiveTLDPlusOne returns the effective top level domain plus one more
+// label. For example, the eTLD+1 for "foo.bar.golang.org" is "golang.org".
+func EffectiveTLDPlusOne(domain string) (string, error) {
+	suffix, _ := PublicSuffix(domain)
+	if len(domain) <= len(suffix) {
+		return "", fmt.Errorf("publicsuffix: cannot derive eTLD+1 for domain %q", domain)
+	}
+	i := len(domain) - len(suffix) - 1
+	if domain[i] != '.' {
+		return "", fmt.Errorf("publicsuffix: invalid public suffix %q for domain %q", suffix, domain)
+	}
+	return domain[1+strings.LastIndex(domain[:i], "."):], nil
+}

vendor/golang.org/x/text/AUTHORS

@@ -0,0 +1,3 @@
+# This source code refers to The Go Authors for copyright purposes.
+# The master list of authors is in the main Go distribution,
+# visible at http://tip.golang.org/AUTHORS.

vendor/golang.org/x/text/CONTRIBUTORS

@@ -0,0 +1,3 @@
+# This source code was written by the Go contributors.
+# The master list of contributors is in the main Go distribution,
+# visible at http://tip.golang.org/CONTRIBUTORS.

vendor/golang.org/x/text/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2009 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/golang.org/x/text/PATENTS

@@ -0,0 +1,22 @@
+Additional IP Rights Grant (Patents)
+
+"This implementation" means the copyrightable works distributed by
+Google as part of the Go project.
+
+Google hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section)
+patent license to make, have made, use, offer to sell, sell, import,
+transfer and otherwise run, modify and propagate the contents of this
+implementation of Go, where such license applies only to those patent
+claims, both currently owned or controlled by Google and acquired in
+the future, licensable by Google that are necessarily infringed by this
+implementation of Go.  This grant does not include claims that would be
+infringed only as a consequence of further modification of this
+implementation.  If you or your agent or exclusive licensee institute or
+order or agree to the institution of patent litigation against any
+entity (including a cross-claim or counterclaim in a lawsuit) alleging
+that this implementation of Go or any code incorporated within this
+implementation of Go constitutes direct or contributory patent
+infringement, or inducement of patent infringement, then any patent
+rights granted to you under this License for this implementation of Go
+shall terminate as of the date such litigation is filed.

vendor/golang.org/x/text/collate/build/builder.go

@@ -0,0 +1,702 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package build // import "golang.org/x/text/collate/build"
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"sort"
+	"strings"
+	"unicode/utf8"
+
+	"golang.org/x/text/internal/colltab"
+	"golang.org/x/text/language"
+	"golang.org/x/text/unicode/norm"
+)
+
+// TODO: optimizations:
+// - expandElem is currently 20K. By putting unique colElems in a separate
+//   table and having a byte array of indexes into this table, we can reduce
+//   the total size to about 7K. By also factoring out the length bytes, we
+//   can reduce this to about 6K.
+// - trie valueBlocks are currently 100K. There are a lot of sparse blocks
+//   and many consecutive values with the same stride. This can be further
+//   compacted.
+// - Compress secondary weights into 8 bits.
+// - Some LDML specs specify a context element. Currently we simply concatenate
+//   those.  Context can be implemented using the contraction trie. If Builder
+//   could analyze and detect when using a context makes sense, there is no
+//   need to expose this construct in the API.
+
+// A Builder builds a root collation table.  The user must specify the
+// collation elements for each entry.  A common use will be to base the weights
+// on those specified in the allkeys* file as provided by the UCA or CLDR.
+type Builder struct {
+	index  *trieBuilder
+	root   ordering
+	locale []*Tailoring
+	t      *table
+	err    error
+	built  bool
+
+	minNonVar int // lowest primary recorded for a variable
+	varTop    int // highest primary recorded for a non-variable
+
+	// indexes used for reusing expansions and contractions
+	expIndex map[string]int      // positions of expansions keyed by their string representation
+	ctHandle map[string]ctHandle // contraction handles keyed by a concatenation of the suffixes
+	ctElem   map[string]int      // contraction elements keyed by their string representation
+}
+
+// A Tailoring builds a collation table based on another collation table.
+// The table is defined by specifying tailorings to the underlying table.
+// See http://unicode.org/reports/tr35/ for an overview of tailoring
+// collation tables.  The CLDR contains pre-defined tailorings for a variety
+// of languages (See http://www.unicode.org/Public/cldr/<version>/core.zip.)
+type Tailoring struct {
+	id      string
+	builder *Builder
+	index   *ordering
+
+	anchor *entry
+	before bool
+}
+
+// NewBuilder returns a new Builder.
+func NewBuilder() *Builder {
+	return &Builder{
+		index:    newTrieBuilder(),
+		root:     makeRootOrdering(),
+		expIndex: make(map[string]int),
+		ctHandle: make(map[string]ctHandle),
+		ctElem:   make(map[string]int),
+	}
+}
+
+// Tailoring returns a Tailoring for the given locale.  One should
+// have completed all calls to Add before calling Tailoring.
+func (b *Builder) Tailoring(loc language.Tag) *Tailoring {
+	t := &Tailoring{
+		id:      loc.String(),
+		builder: b,
+		index:   b.root.clone(),
+	}
+	t.index.id = t.id
+	b.locale = append(b.locale, t)
+	return t
+}
+
+// Add adds an entry to the collation element table, mapping
+// a slice of runes to a sequence of collation elements.
+// A collation element is specified as list of weights: []int{primary, secondary, ...}.
+// The entries are typically obtained from a collation element table
+// as defined in http://www.unicode.org/reports/tr10/#Data_Table_Format.
+// Note that the collation elements specified by colelems are only used
+// as a guide.  The actual weights generated by Builder may differ.
+// The argument variables is a list of indices into colelems that should contain
+// a value for each colelem that is a variable. (See the reference above.)
+func (b *Builder) Add(runes []rune, colelems [][]int, variables []int) error {
+	str := string(runes)
+	elems := make([]rawCE, len(colelems))
+	for i, ce := range colelems {
+		if len(ce) == 0 {
+			break
+		}
+		elems[i] = makeRawCE(ce, 0)
+		if len(ce) == 1 {
+			elems[i].w[1] = defaultSecondary
+		}
+		if len(ce) <= 2 {
+			elems[i].w[2] = defaultTertiary
+		}
+		if len(ce) <= 3 {
+			elems[i].w[3] = ce[0]
+		}
+	}
+	for i, ce := range elems {
+		p := ce.w[0]
+		isvar := false
+		for _, j := range variables {
+			if i == j {
+				isvar = true
+			}
+		}
+		if isvar {
+			if p >= b.minNonVar && b.minNonVar > 0 {
+				return fmt.Errorf("primary value %X of variable is larger than the smallest non-variable %X", p, b.minNonVar)
+			}
+			if p > b.varTop {
+				b.varTop = p
+			}
+		} else if p > 1 { // 1 is a special primary value reserved for FFFE
+			if p <= b.varTop {
+				return fmt.Errorf("primary value %X of non-variable is smaller than the highest variable %X", p, b.varTop)
+			}
+			if b.minNonVar == 0 || p < b.minNonVar {
+				b.minNonVar = p
+			}
+		}
+	}
+	elems, err := convertLargeWeights(elems)
+	if err != nil {
+		return err
+	}
+	cccs := []uint8{}
+	nfd := norm.NFD.String(str)
+	for i := range nfd {
+		cccs = append(cccs, norm.NFD.PropertiesString(nfd[i:]).CCC())
+	}
+	if len(cccs) < len(elems) {
+		if len(cccs) > 2 {
+			return fmt.Errorf("number of decomposed characters should be greater or equal to the number of collation elements for len(colelems) > 3 (%d < %d)", len(cccs), len(elems))
+		}
+		p := len(elems) - 1
+		for ; p > 0 && elems[p].w[0] == 0; p-- {
+			elems[p].ccc = cccs[len(cccs)-1]
+		}
+		for ; p >= 0; p-- {
+			elems[p].ccc = cccs[0]
+		}
+	} else {
+		for i := range elems {
+			elems[i].ccc = cccs[i]
+		}
+	}
+	// doNorm in collate.go assumes that the following conditions hold.
+	if len(elems) > 1 && len(cccs) > 1 && cccs[0] != 0 && cccs[0] != cccs[len(cccs)-1] {
+		return fmt.Errorf("incompatible CCC values for expansion %X (%d)", runes, cccs)
+	}
+	b.root.newEntry(str, elems)
+	return nil
+}
+
+func (t *Tailoring) setAnchor(anchor string) error {
+	anchor = norm.NFC.String(anchor)
+	a := t.index.find(anchor)
+	if a == nil {
+		a = t.index.newEntry(anchor, nil)
+		a.implicit = true
+		a.modified = true
+		for _, r := range []rune(anchor) {
+			e := t.index.find(string(r))
+			e.lock = true
+		}
+	}
+	t.anchor = a
+	return nil
+}
+
+// SetAnchor sets the point after which elements passed in subsequent calls to
+// Insert will be inserted.  It is equivalent to the reset directive in an LDML
+// specification.  See Insert for an example.
+// SetAnchor supports the following logical reset positions:
+// <first_tertiary_ignorable/>, <last_teriary_ignorable/>, <first_primary_ignorable/>,
+// and <last_non_ignorable/>.
+func (t *Tailoring) SetAnchor(anchor string) error {
+	if err := t.setAnchor(anchor); err != nil {
+		return err
+	}
+	t.before = false
+	return nil
+}
+
+// SetAnchorBefore is similar to SetAnchor, except that subsequent calls to
+// Insert will insert entries before the anchor.
+func (t *Tailoring) SetAnchorBefore(anchor string) error {
+	if err := t.setAnchor(anchor); err != nil {
+		return err
+	}
+	t.before = true
+	return nil
+}
+
+// Insert sets the ordering of str relative to the entry set by the previous
+// call to SetAnchor or Insert.  The argument extend corresponds
+// to the extend elements as defined in LDML.  A non-empty value for extend
+// will cause the collation elements corresponding to extend to be appended
+// to the collation elements generated for the entry added by Insert.
+// This has the same net effect as sorting str after the string anchor+extend.
+// See http://www.unicode.org/reports/tr10/#Tailoring_Example for details
+// on parametric tailoring and http://unicode.org/reports/tr35/#Collation_Elements
+// for full details on LDML.
+//
+// Examples: create a tailoring for Swedish, where "ä" is ordered after "z"
+// at the primary sorting level:
+//      t := b.Tailoring("se")
+// 		t.SetAnchor("z")
+// 		t.Insert(colltab.Primary, "ä", "")
+// Order "ü" after "ue" at the secondary sorting level:
+//		t.SetAnchor("ue")
+//		t.Insert(colltab.Secondary, "ü","")
+// or
+//		t.SetAnchor("u")
+//		t.Insert(colltab.Secondary, "ü", "e")
+// Order "q" afer "ab" at the secondary level and "Q" after "q"
+// at the tertiary level:
+// 		t.SetAnchor("ab")
+// 		t.Insert(colltab.Secondary, "q", "")
+// 		t.Insert(colltab.Tertiary, "Q", "")
+// Order "b" before "a":
+//      t.SetAnchorBefore("a")
+//      t.Insert(colltab.Primary, "b", "")
+// Order "0" after the last primary ignorable:
+//      t.SetAnchor("<last_primary_ignorable/>")
+//      t.Insert(colltab.Primary, "0", "")
+func (t *Tailoring) Insert(level colltab.Level, str, extend string) error {
+	if t.anchor == nil {
+		return fmt.Errorf("%s:Insert: no anchor point set for tailoring of %s", t.id, str)
+	}
+	str = norm.NFC.String(str)
+	e := t.index.find(str)
+	if e == nil {
+		e = t.index.newEntry(str, nil)
+	} else if e.logical != noAnchor {
+		return fmt.Errorf("%s:Insert: cannot reinsert logical reset position %q", t.id, e.str)
+	}
+	if e.lock {
+		return fmt.Errorf("%s:Insert: cannot reinsert element %q", t.id, e.str)
+	}
+	a := t.anchor
+	// Find the first element after the anchor which differs at a level smaller or
+	// equal to the given level.  Then insert at this position.
+	// See http://unicode.org/reports/tr35/#Collation_Elements, Section 5.14.5 for details.
+	e.before = t.before
+	if t.before {
+		t.before = false
+		if a.prev == nil {
+			a.insertBefore(e)
+		} else {
+			for a = a.prev; a.level > level; a = a.prev {
+			}
+			a.insertAfter(e)
+		}
+		e.level = level
+	} else {
+		for ; a.level > level; a = a.next {
+		}
+		e.level = a.level
+		if a != e {
+			a.insertAfter(e)
+			a.level = level
+		} else {
+			// We don't set a to prev itself. This has the effect of the entry
+			// getting new collation elements that are an increment of itself.
+			// This is intentional.
+			a.prev.level = level
+		}
+	}
+	e.extend = norm.NFD.String(extend)
+	e.exclude = false
+	e.modified = true
+	e.elems = nil
+	t.anchor = e
+	return nil
+}
+
+func (o *ordering) getWeight(e *entry) []rawCE {
+	if len(e.elems) == 0 && e.logical == noAnchor {
+		if e.implicit {
+			for _, r := range e.runes {
+				e.elems = append(e.elems, o.getWeight(o.find(string(r)))...)
+			}
+		} else if e.before {
+			count := [colltab.Identity + 1]int{}
+			a := e
+			for ; a.elems == nil && !a.implicit; a = a.next {
+				count[a.level]++
+			}
+			e.elems = []rawCE{makeRawCE(a.elems[0].w, a.elems[0].ccc)}
+			for i := colltab.Primary; i < colltab.Quaternary; i++ {
+				if count[i] != 0 {
+					e.elems[0].w[i] -= count[i]
+					break
+				}
+			}
+			if e.prev != nil {
+				o.verifyWeights(e.prev, e, e.prev.level)
+			}
+		} else {
+			prev := e.prev
+			e.elems = nextWeight(prev.level, o.getWeight(prev))
+			o.verifyWeights(e, e.next, e.level)
+		}
+	}
+	return e.elems
+}
+
+func (o *ordering) addExtension(e *entry) {
+	if ex := o.find(e.extend); ex != nil {
+		e.elems = append(e.elems, ex.elems...)
+	} else {
+		for _, r := range []rune(e.extend) {
+			e.elems = append(e.elems, o.find(string(r)).elems...)
+		}
+	}
+	e.extend = ""
+}
+
+func (o *ordering) verifyWeights(a, b *entry, level colltab.Level) error {
+	if level == colltab.Identity || b == nil || b.elems == nil || a.elems == nil {
+		return nil
+	}
+	for i := colltab.Primary; i < level; i++ {
+		if a.elems[0].w[i] < b.elems[0].w[i] {
+			return nil
+		}
+	}
+	if a.elems[0].w[level] >= b.elems[0].w[level] {
+		err := fmt.Errorf("%s:overflow: collation elements of %q (%X) overflows those of %q (%X) at level %d (%X >= %X)", o.id, a.str, a.runes, b.str, b.runes, level, a.elems, b.elems)
+		log.Println(err)
+		// TODO: return the error instead, or better, fix the conflicting entry by making room.
+	}
+	return nil
+}
+
+func (b *Builder) error(e error) {
+	if e != nil {
+		b.err = e
+	}
+}
+
+func (b *Builder) errorID(locale string, e error) {
+	if e != nil {
+		b.err = fmt.Errorf("%s:%v", locale, e)
+	}
+}
+
+// patchNorm ensures that NFC and NFD counterparts are consistent.
+func (o *ordering) patchNorm() {
+	// Insert the NFD counterparts, if necessary.
+	for _, e := range o.ordered {
+		nfd := norm.NFD.String(e.str)
+		if nfd != e.str {
+			if e0 := o.find(nfd); e0 != nil && !e0.modified {
+				e0.elems = e.elems
+			} else if e.modified && !equalCEArrays(o.genColElems(nfd), e.elems) {
+				e := o.newEntry(nfd, e.elems)
+				e.modified = true
+			}
+		}
+	}
+	// Update unchanged composed forms if one of their parts changed.
+	for _, e := range o.ordered {
+		nfd := norm.NFD.String(e.str)
+		if e.modified || nfd == e.str {
+			continue
+		}
+		if e0 := o.find(nfd); e0 != nil {
+			e.elems = e0.elems
+		} else {
+			e.elems = o.genColElems(nfd)
+			if norm.NFD.LastBoundary([]byte(nfd)) == 0 {
+				r := []rune(nfd)
+				head := string(r[0])
+				tail := ""
+				for i := 1; i < len(r); i++ {
+					s := norm.NFC.String(head + string(r[i]))
+					if e0 := o.find(s); e0 != nil && e0.modified {
+						head = s
+					} else {
+						tail += string(r[i])
+					}
+				}
+				e.elems = append(o.genColElems(head), o.genColElems(tail)...)
+			}
+		}
+	}
+	// Exclude entries for which the individual runes generate the same collation elements.
+	for _, e := range o.ordered {
+		if len(e.runes) > 1 && equalCEArrays(o.genColElems(e.str), e.elems) {
+			e.exclude = true
+		}
+	}
+}
+
+func (b *Builder) buildOrdering(o *ordering) {
+	for _, e := range o.ordered {
+		o.getWeight(e)
+	}
+	for _, e := range o.ordered {
+		o.addExtension(e)
+	}
+	o.patchNorm()
+	o.sort()
+	simplify(o)
+	b.processExpansions(o)   // requires simplify
+	b.processContractions(o) // requires simplify
+
+	t := newNode()
+	for e := o.front(); e != nil; e, _ = e.nextIndexed() {
+		if !e.skip() {
+			ce, err := e.encode()
+			b.errorID(o.id, err)
+			t.insert(e.runes[0], ce)
+		}
+	}
+	o.handle = b.index.addTrie(t)
+}
+
+func (b *Builder) build() (*table, error) {
+	if b.built {
+		return b.t, b.err
+	}
+	b.built = true
+	b.t = &table{
+		Table: colltab.Table{
+			MaxContractLen: utf8.UTFMax,
+			VariableTop:    uint32(b.varTop),
+		},
+	}
+
+	b.buildOrdering(&b.root)
+	b.t.root = b.root.handle
+	for _, t := range b.locale {
+		b.buildOrdering(t.index)
+		if b.err != nil {
+			break
+		}
+	}
+	i, err := b.index.generate()
+	b.t.trie = *i
+	b.t.Index = colltab.Trie{
+		Index:   i.index,
+		Values:  i.values,
+		Index0:  i.index[blockSize*b.t.root.lookupStart:],
+		Values0: i.values[blockSize*b.t.root.valueStart:],
+	}
+	b.error(err)
+	return b.t, b.err
+}
+
+// Build builds the root Collator.
+func (b *Builder) Build() (colltab.Weighter, error) {
+	table, err := b.build()
+	if err != nil {
+		return nil, err
+	}
+	return table, nil
+}
+
+// Build builds a Collator for Tailoring t.
+func (t *Tailoring) Build() (colltab.Weighter, error) {
+	// TODO: implement.
+	return nil, nil
+}
+
+// Print prints the tables for b and all its Tailorings as a Go file
+// that can be included in the Collate package.
+func (b *Builder) Print(w io.Writer) (n int, err error) {
+	p := func(nn int, e error) {
+		n += nn
+		if err == nil {
+			err = e
+		}
+	}
+	t, err := b.build()
+	if err != nil {
+		return 0, err
+	}
+	p(fmt.Fprintf(w, `var availableLocales = "und`))
+	for _, loc := range b.locale {
+		if loc.id != "und" {
+			p(fmt.Fprintf(w, ",%s", loc.id))
+		}
+	}
+	p(fmt.Fprint(w, "\"\n\n"))
+	p(fmt.Fprintf(w, "const varTop = 0x%x\n\n", b.varTop))
+	p(fmt.Fprintln(w, "var locales = [...]tableIndex{"))
+	for _, loc := range b.locale {
+		if loc.id == "und" {
+			p(t.fprintIndex(w, loc.index.handle, loc.id))
+		}
+	}
+	for _, loc := range b.locale {
+		if loc.id != "und" {
+			p(t.fprintIndex(w, loc.index.handle, loc.id))
+		}
+	}
+	p(fmt.Fprint(w, "}\n\n"))
+	n, _, err = t.fprint(w, "main")
+	return
+}
+
+// reproducibleFromNFKD checks whether the given expansion could be generated
+// from an NFKD expansion.
+func reproducibleFromNFKD(e *entry, exp, nfkd []rawCE) bool {
+	// Length must be equal.
+	if len(exp) != len(nfkd) {
+		return false
+	}
+	for i, ce := range exp {
+		// Primary and secondary values should be equal.
+		if ce.w[0] != nfkd[i].w[0] || ce.w[1] != nfkd[i].w[1] {
+			return false
+		}
+		// Tertiary values should be equal to maxTertiary for third element onwards.
+		// TODO: there seem to be a lot of cases in CLDR (e.g. ㏭ in zh.xml) that can
+		// simply be dropped.  Try this out by dropping the following code.
+		if i >= 2 && ce.w[2] != maxTertiary {
+			return false
+		}
+		if _, err := makeCE(ce); err != nil {
+			// Simply return false. The error will be caught elsewhere.
+			return false
+		}
+	}
+	return true
+}
+
+func simplify(o *ordering) {
+	// Runes that are a starter of a contraction should not be removed.
+	// (To date, there is only Kannada character 0CCA.)
+	keep := make(map[rune]bool)
+	for e := o.front(); e != nil; e, _ = e.nextIndexed() {
+		if len(e.runes) > 1 {
+			keep[e.runes[0]] = true
+		}
+	}
+	// Tag entries for which the runes NFKD decompose to identical values.
+	for e := o.front(); e != nil; e, _ = e.nextIndexed() {
+		s := e.str
+		nfkd := norm.NFKD.String(s)
+		nfd := norm.NFD.String(s)
+		if e.decompose || len(e.runes) > 1 || len(e.elems) == 1 || keep[e.runes[0]] || nfkd == nfd {
+			continue
+		}
+		if reproducibleFromNFKD(e, e.elems, o.genColElems(nfkd)) {
+			e.decompose = true
+		}
+	}
+}
+
+// appendExpansion converts the given collation sequence to
+// collation elements and adds them to the expansion table.
+// It returns an index to the expansion table.
+func (b *Builder) appendExpansion(e *entry) int {
+	t := b.t
+	i := len(t.ExpandElem)
+	ce := uint32(len(e.elems))
+	t.ExpandElem = append(t.ExpandElem, ce)
+	for _, w := range e.elems {
+		ce, err := makeCE(w)
+		if err != nil {
+			b.error(err)
+			return -1
+		}
+		t.ExpandElem = append(t.ExpandElem, ce)
+	}
+	return i
+}
+
+// processExpansions extracts data necessary to generate
+// the extraction tables.
+func (b *Builder) processExpansions(o *ordering) {
+	for e := o.front(); e != nil; e, _ = e.nextIndexed() {
+		if !e.expansion() {
+			continue
+		}
+		key := fmt.Sprintf("%v", e.elems)
+		i, ok := b.expIndex[key]
+		if !ok {
+			i = b.appendExpansion(e)
+			b.expIndex[key] = i
+		}
+		e.expansionIndex = i
+	}
+}
+
+func (b *Builder) processContractions(o *ordering) {
+	// Collate contractions per starter rune.
+	starters := []rune{}
+	cm := make(map[rune][]*entry)
+	for e := o.front(); e != nil; e, _ = e.nextIndexed() {
+		if e.contraction() {
+			if len(e.str) > b.t.MaxContractLen {
+				b.t.MaxContractLen = len(e.str)
+			}
+			r := e.runes[0]
+			if _, ok := cm[r]; !ok {
+				starters = append(starters, r)
+			}
+			cm[r] = append(cm[r], e)
+		}
+	}
+	// Add entries of single runes that are at a start of a contraction.
+	for e := o.front(); e != nil; e, _ = e.nextIndexed() {
+		if !e.contraction() {
+			r := e.runes[0]
+			if _, ok := cm[r]; ok {
+				cm[r] = append(cm[r], e)
+			}
+		}
+	}
+	// Build the tries for the contractions.
+	t := b.t
+	for _, r := range starters {
+		l := cm[r]
+		// Compute suffix strings. There are 31 different contraction suffix
+		// sets for 715 contractions and 82 contraction starter runes as of
+		// version 6.0.0.
+		sufx := []string{}
+		hasSingle := false
+		for _, e := range l {
+			if len(e.runes) > 1 {
+				sufx = append(sufx, string(e.runes[1:]))
+			} else {
+				hasSingle = true
+			}
+		}
+		if !hasSingle {
+			b.error(fmt.Errorf("no single entry for starter rune %U found", r))
+			continue
+		}
+		// Unique the suffix set.
+		sort.Strings(sufx)
+		key := strings.Join(sufx, "\n")
+		handle, ok := b.ctHandle[key]
+		if !ok {
+			var err error
+			handle, err = appendTrie(&t.ContractTries, sufx)
+			if err != nil {
+				b.error(err)
+			}
+			b.ctHandle[key] = handle
+		}
+		// Bucket sort entries in index order.
+		es := make([]*entry, len(l))
+		for _, e := range l {
+			var p, sn int
+			if len(e.runes) > 1 {
+				str := []byte(string(e.runes[1:]))
+				p, sn = lookup(&t.ContractTries, handle, str)
+				if sn != len(str) {
+					log.Fatalf("%s: processContractions: unexpected length for '%X'; len=%d; want %d", o.id, e.runes, sn, len(str))
+				}
+			}
+			if es[p] != nil {
+				log.Fatalf("%s: multiple contractions for position %d for rune %U", o.id, p, e.runes[0])
+			}
+			es[p] = e
+		}
+		// Create collation elements for contractions.
+		elems := []uint32{}
+		for _, e := range es {
+			ce, err := e.encodeBase()
+			b.errorID(o.id, err)
+			elems = append(elems, ce)
+		}
+		key = fmt.Sprintf("%v", elems)
+		i, ok := b.ctElem[key]
+		if !ok {
+			i = len(t.ContractElem)
+			b.ctElem[key] = i
+			t.ContractElem = append(t.ContractElem, elems...)
+		}
+		// Store info in entry for starter rune.
+		es[0].contractionIndex = i
+		es[0].contractionHandle = handle
+	}
+}

vendor/golang.org/x/text/collate/build/colelem.go

@@ -0,0 +1,294 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package build
+
+import (
+	"fmt"
+	"unicode"
+
+	"golang.org/x/text/internal/colltab"
+)
+
+const (
+	defaultSecondary = 0x20
+	defaultTertiary  = 0x2
+	maxTertiary      = 0x1F
+)
+
+type rawCE struct {
+	w   []int
+	ccc uint8
+}
+
+func makeRawCE(w []int, ccc uint8) rawCE {
+	ce := rawCE{w: make([]int, 4), ccc: ccc}
+	copy(ce.w, w)
+	return ce
+}
+
+// A collation element is represented as an uint32.
+// In the typical case, a rune maps to a single collation element. If a rune
+// can be the start of a contraction or expands into multiple collation elements,
+// then the collation element that is associated with a rune will have a special
+// form to represent such m to n mappings.  Such special collation elements
+// have a value >= 0x80000000.
+
+const (
+	maxPrimaryBits   = 21
+	maxSecondaryBits = 12
+	maxTertiaryBits  = 8
+)
+
+func makeCE(ce rawCE) (uint32, error) {
+	v, e := colltab.MakeElem(ce.w[0], ce.w[1], ce.w[2], ce.ccc)
+	return uint32(v), e
+}
+
+// For contractions, collation elements are of the form
+// 110bbbbb bbbbbbbb iiiiiiii iiiinnnn, where
+//   - n* is the size of the first node in the contraction trie.
+//   - i* is the index of the first node in the contraction trie.
+//   - b* is the offset into the contraction collation element table.
+// See contract.go for details on the contraction trie.
+const (
+	contractID            = 0xC0000000
+	maxNBits              = 4
+	maxTrieIndexBits      = 12
+	maxContractOffsetBits = 13
+)
+
+func makeContractIndex(h ctHandle, offset int) (uint32, error) {
+	if h.n >= 1<<maxNBits {
+		return 0, fmt.Errorf("size of contraction trie node too large: %d >= %d", h.n, 1<<maxNBits)
+	}
+	if h.index >= 1<<maxTrieIndexBits {
+		return 0, fmt.Errorf("size of contraction trie offset too large: %d >= %d", h.index, 1<<maxTrieIndexBits)
+	}
+	if offset >= 1<<maxContractOffsetBits {
+		return 0, fmt.Errorf("contraction offset out of bounds: %x >= %x", offset, 1<<maxContractOffsetBits)
+	}
+	ce := uint32(contractID)
+	ce += uint32(offset << (maxNBits + maxTrieIndexBits))
+	ce += uint32(h.index << maxNBits)
+	ce += uint32(h.n)
+	return ce, nil
+}
+
+// For expansions, collation elements are of the form
+// 11100000 00000000 bbbbbbbb bbbbbbbb,
+// where b* is the index into the expansion sequence table.
+const (
+	expandID           = 0xE0000000
+	maxExpandIndexBits = 16
+)
+
+func makeExpandIndex(index int) (uint32, error) {
+	if index >= 1<<maxExpandIndexBits {
+		return 0, fmt.Errorf("expansion index out of bounds: %x >= %x", index, 1<<maxExpandIndexBits)
+	}
+	return expandID + uint32(index), nil
+}
+
+// Each list of collation elements corresponding to an expansion starts with
+// a header indicating the length of the sequence.
+func makeExpansionHeader(n int) (uint32, error) {
+	return uint32(n), nil
+}
+
+// Some runes can be expanded using NFKD decomposition. Instead of storing the full
+// sequence of collation elements, we decompose the rune and lookup the collation
+// elements for each rune in the decomposition and modify the tertiary weights.
+// The collation element, in this case, is of the form
+// 11110000 00000000 wwwwwwww vvvvvvvv, where
+//   - v* is the replacement tertiary weight for the first rune,
+//   - w* is the replacement tertiary weight for the second rune,
+// Tertiary weights of subsequent runes should be replaced with maxTertiary.
+// See http://www.unicode.org/reports/tr10/#Compatibility_Decompositions for more details.
+const (
+	decompID = 0xF0000000
+)
+
+func makeDecompose(t1, t2 int) (uint32, error) {
+	if t1 >= 256 || t1 < 0 {
+		return 0, fmt.Errorf("first tertiary weight out of bounds: %d >= 256", t1)
+	}
+	if t2 >= 256 || t2 < 0 {
+		return 0, fmt.Errorf("second tertiary weight out of bounds: %d >= 256", t2)
+	}
+	return uint32(t2<<8+t1) + decompID, nil
+}
+
+const (
+	// These constants were taken from http://www.unicode.org/versions/Unicode6.0.0/ch12.pdf.
+	minUnified       rune = 0x4E00
+	maxUnified            = 0x9FFF
+	minCompatibility      = 0xF900
+	maxCompatibility      = 0xFAFF
+	minRare               = 0x3400
+	maxRare               = 0x4DBF
+)
+const (
+	commonUnifiedOffset = 0x10000
+	rareUnifiedOffset   = 0x20000 // largest rune in common is U+FAFF
+	otherOffset         = 0x50000 // largest rune in rare is U+2FA1D
+	illegalOffset       = otherOffset + int(unicode.MaxRune)
+	maxPrimary          = illegalOffset + 1
+)
+
+// implicitPrimary returns the primary weight for the a rune
+// for which there is no entry for the rune in the collation table.
+// We take a different approach from the one specified in
+// http://unicode.org/reports/tr10/#Implicit_Weights,
+// but preserve the resulting relative ordering of the runes.
+func implicitPrimary(r rune) int {
+	if unicode.Is(unicode.Ideographic, r) {
+		if r >= minUnified && r <= maxUnified {
+			// The most common case for CJK.
+			return int(r) + commonUnifiedOffset
+		}
+		if r >= minCompatibility && r <= maxCompatibility {
+			// This will typically not hit. The DUCET explicitly specifies mappings
+			// for all characters that do not decompose.
+			return int(r) + commonUnifiedOffset
+		}
+		return int(r) + rareUnifiedOffset
+	}
+	return int(r) + otherOffset
+}
+
+// convertLargeWeights converts collation elements with large
+// primaries (either double primaries or for illegal runes)
+// to our own representation.
+// A CJK character C is represented in the DUCET as
+//   [.FBxx.0020.0002.C][.BBBB.0000.0000.C]
+// We will rewrite these characters to a single CE.
+// We assume the CJK values start at 0x8000.
+// See http://unicode.org/reports/tr10/#Implicit_Weights
+func convertLargeWeights(elems []rawCE) (res []rawCE, err error) {
+	const (
+		cjkPrimaryStart   = 0xFB40
+		rarePrimaryStart  = 0xFB80
+		otherPrimaryStart = 0xFBC0
+		illegalPrimary    = 0xFFFE
+		highBitsMask      = 0x3F
+		lowBitsMask       = 0x7FFF
+		lowBitsFlag       = 0x8000
+		shiftBits         = 15
+	)
+	for i := 0; i < len(elems); i++ {
+		ce := elems[i].w
+		p := ce[0]
+		if p < cjkPrimaryStart {
+			continue
+		}
+		if p > 0xFFFF {
+			return elems, fmt.Errorf("found primary weight %X; should be <= 0xFFFF", p)
+		}
+		if p >= illegalPrimary {
+			ce[0] = illegalOffset + p - illegalPrimary
+		} else {
+			if i+1 >= len(elems) {
+				return elems, fmt.Errorf("second part of double primary weight missing: %v", elems)
+			}
+			if elems[i+1].w[0]&lowBitsFlag == 0 {
+				return elems, fmt.Errorf("malformed second part of double primary weight: %v", elems)
+			}
+			np := ((p & highBitsMask) << shiftBits) + elems[i+1].w[0]&lowBitsMask
+			switch {
+			case p < rarePrimaryStart:
+				np += commonUnifiedOffset
+			case p < otherPrimaryStart:
+				np += rareUnifiedOffset
+			default:
+				p += otherOffset
+			}
+			ce[0] = np
+			for j := i + 1; j+1 < len(elems); j++ {
+				elems[j] = elems[j+1]
+			}
+			elems = elems[:len(elems)-1]
+		}
+	}
+	return elems, nil
+}
+
+// nextWeight computes the first possible collation weights following elems
+// for the given level.
+func nextWeight(level colltab.Level, elems []rawCE) []rawCE {
+	if level == colltab.Identity {
+		next := make([]rawCE, len(elems))
+		copy(next, elems)
+		return next
+	}
+	next := []rawCE{makeRawCE(elems[0].w, elems[0].ccc)}
+	next[0].w[level]++
+	if level < colltab.Secondary {
+		next[0].w[colltab.Secondary] = defaultSecondary
+	}
+	if level < colltab.Tertiary {
+		next[0].w[colltab.Tertiary] = defaultTertiary
+	}
+	// Filter entries that cannot influence ordering.
+	for _, ce := range elems[1:] {
+		skip := true
+		for i := colltab.Primary; i < level; i++ {
+			skip = skip && ce.w[i] == 0
+		}
+		if !skip {
+			next = append(next, ce)
+		}
+	}
+	return next
+}
+
+func nextVal(elems []rawCE, i int, level colltab.Level) (index, value int) {
+	for ; i < len(elems) && elems[i].w[level] == 0; i++ {
+	}
+	if i < len(elems) {
+		return i, elems[i].w[level]
+	}
+	return i, 0
+}
+
+// compareWeights returns -1 if a < b, 1 if a > b, or 0 otherwise.
+// It also returns the collation level at which the difference is found.
+func compareWeights(a, b []rawCE) (result int, level colltab.Level) {
+	for level := colltab.Primary; level < colltab.Identity; level++ {
+		var va, vb int
+		for ia, ib := 0, 0; ia < len(a) || ib < len(b); ia, ib = ia+1, ib+1 {
+			ia, va = nextVal(a, ia, level)
+			ib, vb = nextVal(b, ib, level)
+			if va != vb {
+				if va < vb {
+					return -1, level
+				} else {
+					return 1, level
+				}
+			}
+		}
+	}
+	return 0, colltab.Identity
+}
+
+func equalCE(a, b rawCE) bool {
+	for i := 0; i < 3; i++ {
+		if b.w[i] != a.w[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func equalCEArrays(a, b []rawCE) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if !equalCE(a[i], b[i]) {
+			return false
+		}
+	}
+	return true
+}

vendor/golang.org/x/text/collate/build/contract.go

@@ -0,0 +1,309 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package build
+
+import (
+	"fmt"
+	"io"
+	"reflect"
+	"sort"
+	"strings"
+
+	"golang.org/x/text/internal/colltab"
+)
+
+// This file contains code for detecting contractions and generating
+// the necessary tables.
+// Any Unicode Collation Algorithm (UCA) table entry that has more than
+// one rune one the left-hand side is called a contraction.
+// See http://www.unicode.org/reports/tr10/#Contractions for more details.
+//
+// We define the following terms:
+//   initial:     a rune that appears as the first rune in a contraction.
+//   suffix:      a sequence of runes succeeding the initial rune
+//                in a given contraction.
+//   non-initial: a rune that appears in a suffix.
+//
+// A rune may be both an initial and a non-initial and may be so in
+// many contractions.  An initial may typically also appear by itself.
+// In case of ambiguities, the UCA requires we match the longest
+// contraction.
+//
+// Many contraction rules share the same set of possible suffixes.
+// We store sets of suffixes in a trie that associates an index with
+// each suffix in the set.  This index can be used to look up a
+// collation element associated with the (starter rune, suffix) pair.
+//
+// The trie is defined on a UTF-8 byte sequence.
+// The overall trie is represented as an array of ctEntries.  Each node of the trie
+// is represented as a subsequence of ctEntries, where each entry corresponds to
+// a possible match of a next character in the search string.  An entry
+// also includes the length and offset to the next sequence of entries
+// to check in case of a match.
+
+const (
+	final   = 0
+	noIndex = 0xFF
+)
+
+// ctEntry associates to a matching byte an offset and/or next sequence of
+// bytes to check. A ctEntry c is called final if a match means that the
+// longest suffix has been found.  An entry c is final if c.N == 0.
+// A single final entry can match a range of characters to an offset.
+// A non-final entry always matches a single byte. Note that a non-final
+// entry might still resemble a completed suffix.
+// Examples:
+// The suffix strings "ab" and "ac" can be represented as:
+// []ctEntry{
+//     {'a', 1, 1, noIndex},  // 'a' by itself does not match, so i is 0xFF.
+//     {'b', 'c', 0, 1},   // "ab" -> 1, "ac" -> 2
+// }
+//
+// The suffix strings "ab", "abc", "abd", and "abcd" can be represented as:
+// []ctEntry{
+//     {'a', 1, 1, noIndex}, // 'a' must be followed by 'b'.
+//     {'b', 1, 2, 1},    // "ab" -> 1, may be followed by 'c' or 'd'.
+//     {'d', 'd', final, 3},  // "abd" -> 3
+//     {'c', 4, 1, 2},    // "abc" -> 2, may be followed by 'd'.
+//     {'d', 'd', final, 4},  // "abcd" -> 4
+// }
+// See genStateTests in contract_test.go for more examples.
+type ctEntry struct {
+	L uint8 // non-final: byte value to match; final: lowest match in range.
+	H uint8 // non-final: relative index to next block; final: highest match in range.
+	N uint8 // non-final: length of next block; final: final
+	I uint8 // result offset. Will be noIndex if more bytes are needed to complete.
+}
+
+// contractTrieSet holds a set of contraction tries. The tries are stored
+// consecutively in the entry field.
+type contractTrieSet []struct{ l, h, n, i uint8 }
+
+// ctHandle is used to identify a trie in the trie set, consisting in an offset
+// in the array and the size of the first node.
+type ctHandle struct {
+	index, n int
+}
+
+// appendTrie adds a new trie for the given suffixes to the trie set and returns
+// a handle to it.  The handle will be invalid on error.
+func appendTrie(ct *colltab.ContractTrieSet, suffixes []string) (ctHandle, error) {
+	es := make([]stridx, len(suffixes))
+	for i, s := range suffixes {
+		es[i].str = s
+	}
+	sort.Sort(offsetSort(es))
+	for i := range es {
+		es[i].index = i + 1
+	}
+	sort.Sort(genidxSort(es))
+	i := len(*ct)
+	n, err := genStates(ct, es)
+	if err != nil {
+		*ct = (*ct)[:i]
+		return ctHandle{}, err
+	}
+	return ctHandle{i, n}, nil
+}
+
+// genStates generates ctEntries for a given suffix set and returns
+// the number of entries for the first node.
+func genStates(ct *colltab.ContractTrieSet, sis []stridx) (int, error) {
+	if len(sis) == 0 {
+		return 0, fmt.Errorf("genStates: list of suffices must be non-empty")
+	}
+	start := len(*ct)
+	// create entries for differing first bytes.
+	for _, si := range sis {
+		s := si.str
+		if len(s) == 0 {
+			continue
+		}
+		added := false
+		c := s[0]
+		if len(s) > 1 {
+			for j := len(*ct) - 1; j >= start; j-- {
+				if (*ct)[j].L == c {
+					added = true
+					break
+				}
+			}
+			if !added {
+				*ct = append(*ct, ctEntry{L: c, I: noIndex})
+			}
+		} else {
+			for j := len(*ct) - 1; j >= start; j-- {
+				// Update the offset for longer suffixes with the same byte.
+				if (*ct)[j].L == c {
+					(*ct)[j].I = uint8(si.index)
+					added = true
+				}
+				// Extend range of final ctEntry, if possible.
+				if (*ct)[j].H+1 == c {
+					(*ct)[j].H = c
+					added = true
+				}
+			}
+			if !added {
+				*ct = append(*ct, ctEntry{L: c, H: c, N: final, I: uint8(si.index)})
+			}
+		}
+	}
+	n := len(*ct) - start
+	// Append nodes for the remainder of the suffixes for each ctEntry.
+	sp := 0
+	for i, end := start, len(*ct); i < end; i++ {
+		fe := (*ct)[i]
+		if fe.H == 0 { // uninitialized non-final
+			ln := len(*ct) - start - n
+			if ln > 0xFF {
+				return 0, fmt.Errorf("genStates: relative block offset too large: %d > 255", ln)
+			}
+			fe.H = uint8(ln)
+			// Find first non-final strings with same byte as current entry.
+			for ; sis[sp].str[0] != fe.L; sp++ {
+			}
+			se := sp + 1
+			for ; se < len(sis) && len(sis[se].str) > 1 && sis[se].str[0] == fe.L; se++ {
+			}
+			sl := sis[sp:se]
+			sp = se
+			for i, si := range sl {
+				sl[i].str = si.str[1:]
+			}
+			nn, err := genStates(ct, sl)
+			if err != nil {
+				return 0, err
+			}
+			fe.N = uint8(nn)
+			(*ct)[i] = fe
+		}
+	}
+	sort.Sort(entrySort((*ct)[start : start+n]))
+	return n, nil
+}
+
+// There may be both a final and non-final entry for a byte if the byte
+// is implied in a range of matches in the final entry.
+// We need to ensure that the non-final entry comes first in that case.
+type entrySort colltab.ContractTrieSet
+
+func (fe entrySort) Len() int      { return len(fe) }
+func (fe entrySort) Swap(i, j int) { fe[i], fe[j] = fe[j], fe[i] }
+func (fe entrySort) Less(i, j int) bool {
+	return fe[i].L > fe[j].L
+}
+
+// stridx is used for sorting suffixes and their associated offsets.
+type stridx struct {
+	str   string
+	index int
+}
+
+// For computing the offsets, we first sort by size, and then by string.
+// This ensures that strings that only differ in the last byte by 1
+// are sorted consecutively in increasing order such that they can
+// be packed as a range in a final ctEntry.
+type offsetSort []stridx
+
+func (si offsetSort) Len() int      { return len(si) }
+func (si offsetSort) Swap(i, j int) { si[i], si[j] = si[j], si[i] }
+func (si offsetSort) Less(i, j int) bool {
+	if len(si[i].str) != len(si[j].str) {
+		return len(si[i].str) > len(si[j].str)
+	}
+	return si[i].str < si[j].str
+}
+
+// For indexing, we want to ensure that strings are sorted in string order, where
+// for strings with the same prefix, we put longer strings before shorter ones.
+type genidxSort []stridx
+
+func (si genidxSort) Len() int      { return len(si) }
+func (si genidxSort) Swap(i, j int) { si[i], si[j] = si[j], si[i] }
+func (si genidxSort) Less(i, j int) bool {
+	if strings.HasPrefix(si[j].str, si[i].str) {
+		return false
+	}
+	if strings.HasPrefix(si[i].str, si[j].str) {
+		return true
+	}
+	return si[i].str < si[j].str
+}
+
+// lookup matches the longest suffix in str and returns the associated offset
+// and the number of bytes consumed.
+func lookup(ct *colltab.ContractTrieSet, h ctHandle, str []byte) (index, ns int) {
+	states := (*ct)[h.index:]
+	p := 0
+	n := h.n
+	for i := 0; i < n && p < len(str); {
+		e := states[i]
+		c := str[p]
+		if c >= e.L {
+			if e.L == c {
+				p++
+				if e.I != noIndex {
+					index, ns = int(e.I), p
+				}
+				if e.N != final {
+					// set to new state
+					i, states, n = 0, states[int(e.H)+n:], int(e.N)
+				} else {
+					return
+				}
+				continue
+			} else if e.N == final && c <= e.H {
+				p++
+				return int(c-e.L) + int(e.I), p
+			}
+		}
+		i++
+	}
+	return
+}
+
+// print writes the contractTrieSet t as compilable Go code to w. It returns
+// the total number of bytes written and the size of the resulting data structure in bytes.
+func print(t *colltab.ContractTrieSet, w io.Writer, name string) (n, size int, err error) {
+	update3 := func(nn, sz int, e error) {
+		n += nn
+		if err == nil {
+			err = e
+		}
+		size += sz
+	}
+	update2 := func(nn int, e error) { update3(nn, 0, e) }
+
+	update3(printArray(*t, w, name))
+	update2(fmt.Fprintf(w, "var %sContractTrieSet = ", name))
+	update3(printStruct(*t, w, name))
+	update2(fmt.Fprintln(w))
+	return
+}
+
+func printArray(ct colltab.ContractTrieSet, w io.Writer, name string) (n, size int, err error) {
+	p := func(f string, a ...interface{}) {
+		nn, e := fmt.Fprintf(w, f, a...)
+		n += nn
+		if err == nil {
+			err = e
+		}
+	}
+	size = len(ct) * 4
+	p("// %sCTEntries: %d entries, %d bytes\n", name, len(ct), size)
+	p("var %sCTEntries = [%d]struct{L,H,N,I uint8}{\n", name, len(ct))
+	for _, fe := range ct {
+		p("\t{0x%X, 0x%X, %d, %d},\n", fe.L, fe.H, fe.N, fe.I)
+	}
+	p("}\n")
+	return
+}
+
+func printStruct(ct colltab.ContractTrieSet, w io.Writer, name string) (n, size int, err error) {
+	n, err = fmt.Fprintf(w, "colltab.ContractTrieSet( %sCTEntries[:] )", name)
+	size = int(reflect.TypeOf(ct).Size())
+	return
+}

vendor/golang.org/x/text/collate/build/order.go

@@ -0,0 +1,393 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package build
+
+import (
+	"fmt"
+	"log"
+	"sort"
+	"strings"
+	"unicode"
+
+	"golang.org/x/text/internal/colltab"
+	"golang.org/x/text/unicode/norm"
+)
+
+type logicalAnchor int
+
+const (
+	firstAnchor logicalAnchor = -1
+	noAnchor                  = 0
+	lastAnchor                = 1
+)
+
+// entry is used to keep track of a single entry in the collation element table
+// during building. Examples of entries can be found in the Default Unicode
+// Collation Element Table.
+// See http://www.unicode.org/Public/UCA/6.0.0/allkeys.txt.
+type entry struct {
+	str    string // same as string(runes)
+	runes  []rune
+	elems  []rawCE // the collation elements
+	extend string  // weights of extend to be appended to elems
+	before bool    // weights relative to next instead of previous.
+	lock   bool    // entry is used in extension and can no longer be moved.
+
+	// prev, next, and level are used to keep track of tailorings.
+	prev, next *entry
+	level      colltab.Level // next differs at this level
+	skipRemove bool          // do not unlink when removed
+
+	decompose bool // can use NFKD decomposition to generate elems
+	exclude   bool // do not include in table
+	implicit  bool // derived, is not included in the list
+	modified  bool // entry was modified in tailoring
+	logical   logicalAnchor
+
+	expansionIndex    int // used to store index into expansion table
+	contractionHandle ctHandle
+	contractionIndex  int // index into contraction elements
+}
+
+func (e *entry) String() string {
+	return fmt.Sprintf("%X (%q) -> %X (ch:%x; ci:%d, ei:%d)",
+		e.runes, e.str, e.elems, e.contractionHandle, e.contractionIndex, e.expansionIndex)
+}
+
+func (e *entry) skip() bool {
+	return e.contraction()
+}
+
+func (e *entry) expansion() bool {
+	return !e.decompose && len(e.elems) > 1
+}
+
+func (e *entry) contraction() bool {
+	return len(e.runes) > 1
+}
+
+func (e *entry) contractionStarter() bool {
+	return e.contractionHandle.n != 0
+}
+
+// nextIndexed gets the next entry that needs to be stored in the table.
+// It returns the entry and the collation level at which the next entry differs
+// from the current entry.
+// Entries that can be explicitly derived and logical reset positions are
+// examples of entries that will not be indexed.
+func (e *entry) nextIndexed() (*entry, colltab.Level) {
+	level := e.level
+	for e = e.next; e != nil && (e.exclude || len(e.elems) == 0); e = e.next {
+		if e.level < level {
+			level = e.level
+		}
+	}
+	return e, level
+}
+
+// remove unlinks entry e from the sorted chain and clears the collation
+// elements. e may not be at the front or end of the list. This should always
+// be the case, as the front and end of the list are always logical anchors,
+// which may not be removed.
+func (e *entry) remove() {
+	if e.logical != noAnchor {
+		log.Fatalf("may not remove anchor %q", e.str)
+	}
+	// TODO: need to set e.prev.level to e.level if e.level is smaller?
+	e.elems = nil
+	if !e.skipRemove {
+		if e.prev != nil {
+			e.prev.next = e.next
+		}
+		if e.next != nil {
+			e.next.prev = e.prev
+		}
+	}
+	e.skipRemove = false
+}
+
+// insertAfter inserts n after e.
+func (e *entry) insertAfter(n *entry) {
+	if e == n {
+		panic("e == anchor")
+	}
+	if e == nil {
+		panic("unexpected nil anchor")
+	}
+	n.remove()
+	n.decompose = false // redo decomposition test
+
+	n.next = e.next
+	n.prev = e
+	if e.next != nil {
+		e.next.prev = n
+	}
+	e.next = n
+}
+
+// insertBefore inserts n before e.
+func (e *entry) insertBefore(n *entry) {
+	if e == n {
+		panic("e == anchor")
+	}
+	if e == nil {
+		panic("unexpected nil anchor")
+	}
+	n.remove()
+	n.decompose = false // redo decomposition test
+
+	n.prev = e.prev
+	n.next = e
+	if e.prev != nil {
+		e.prev.next = n
+	}
+	e.prev = n
+}
+
+func (e *entry) encodeBase() (ce uint32, err error) {
+	switch {
+	case e.expansion():
+		ce, err = makeExpandIndex(e.expansionIndex)
+	default:
+		if e.decompose {
+			log.Fatal("decompose should be handled elsewhere")
+		}
+		ce, err = makeCE(e.elems[0])
+	}
+	return
+}
+
+func (e *entry) encode() (ce uint32, err error) {
+	if e.skip() {
+		log.Fatal("cannot build colElem for entry that should be skipped")
+	}
+	switch {
+	case e.decompose:
+		t1 := e.elems[0].w[2]
+		t2 := 0
+		if len(e.elems) > 1 {
+			t2 = e.elems[1].w[2]
+		}
+		ce, err = makeDecompose(t1, t2)
+	case e.contractionStarter():
+		ce, err = makeContractIndex(e.contractionHandle, e.contractionIndex)
+	default:
+		if len(e.runes) > 1 {
+			log.Fatal("colElem: contractions are handled in contraction trie")
+		}
+		ce, err = e.encodeBase()
+	}
+	return
+}
+
+// entryLess returns true if a sorts before b and false otherwise.
+func entryLess(a, b *entry) bool {
+	if res, _ := compareWeights(a.elems, b.elems); res != 0 {
+		return res == -1
+	}
+	if a.logical != noAnchor {
+		return a.logical == firstAnchor
+	}
+	if b.logical != noAnchor {
+		return b.logical == lastAnchor
+	}
+	return a.str < b.str
+}
+
+type sortedEntries []*entry
+
+func (s sortedEntries) Len() int {
+	return len(s)
+}
+
+func (s sortedEntries) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+
+func (s sortedEntries) Less(i, j int) bool {
+	return entryLess(s[i], s[j])
+}
+
+type ordering struct {
+	id       string
+	entryMap map[string]*entry
+	ordered  []*entry
+	handle   *trieHandle
+}
+
+// insert inserts e into both entryMap and ordered.
+// Note that insert simply appends e to ordered.  To reattain a sorted
+// order, o.sort() should be called.
+func (o *ordering) insert(e *entry) {
+	if e.logical == noAnchor {
+		o.entryMap[e.str] = e
+	} else {
+		// Use key format as used in UCA rules.
+		o.entryMap[fmt.Sprintf("[%s]", e.str)] = e
+		// Also add index entry for XML format.
+		o.entryMap[fmt.Sprintf("<%s/>", strings.Replace(e.str, " ", "_", -1))] = e
+	}
+	o.ordered = append(o.ordered, e)
+}
+
+// newEntry creates a new entry for the given info and inserts it into
+// the index.
+func (o *ordering) newEntry(s string, ces []rawCE) *entry {
+	e := &entry{
+		runes: []rune(s),
+		elems: ces,
+		str:   s,
+	}
+	o.insert(e)
+	return e
+}
+
+// find looks up and returns the entry for the given string.
+// It returns nil if str is not in the index and if an implicit value
+// cannot be derived, that is, if str represents more than one rune.
+func (o *ordering) find(str string) *entry {
+	e := o.entryMap[str]
+	if e == nil {
+		r := []rune(str)
+		if len(r) == 1 {
+			const (
+				firstHangul = 0xAC00
+				lastHangul  = 0xD7A3
+			)
+			if r[0] >= firstHangul && r[0] <= lastHangul {
+				ce := []rawCE{}
+				nfd := norm.NFD.String(str)
+				for _, r := range nfd {
+					ce = append(ce, o.find(string(r)).elems...)
+				}
+				e = o.newEntry(nfd, ce)
+			} else {
+				e = o.newEntry(string(r[0]), []rawCE{
+					{w: []int{
+						implicitPrimary(r[0]),
+						defaultSecondary,
+						defaultTertiary,
+						int(r[0]),
+					},
+					},
+				})
+				e.modified = true
+			}
+			e.exclude = true // do not index implicits
+		}
+	}
+	return e
+}
+
+// makeRootOrdering returns a newly initialized ordering value and populates
+// it with a set of logical reset points that can be used as anchors.
+// The anchors first_tertiary_ignorable and __END__ will always sort at
+// the beginning and end, respectively. This means that prev and next are non-nil
+// for any indexed entry.
+func makeRootOrdering() ordering {
+	const max = unicode.MaxRune
+	o := ordering{
+		entryMap: make(map[string]*entry),
+	}
+	insert := func(typ logicalAnchor, s string, ce []int) {
+		e := &entry{
+			elems:   []rawCE{{w: ce}},
+			str:     s,
+			exclude: true,
+			logical: typ,
+		}
+		o.insert(e)
+	}
+	insert(firstAnchor, "first tertiary ignorable", []int{0, 0, 0, 0})
+	insert(lastAnchor, "last tertiary ignorable", []int{0, 0, 0, max})
+	insert(lastAnchor, "last primary ignorable", []int{0, defaultSecondary, defaultTertiary, max})
+	insert(lastAnchor, "last non ignorable", []int{maxPrimary, defaultSecondary, defaultTertiary, max})
+	insert(lastAnchor, "__END__", []int{1 << maxPrimaryBits, defaultSecondary, defaultTertiary, max})
+	return o
+}
+
+// patchForInsert eleminates entries from the list with more than one collation element.
+// The next and prev fields of the eliminated entries still point to appropriate
+// values in the newly created list.
+// It requires that sort has been called.
+func (o *ordering) patchForInsert() {
+	for i := 0; i < len(o.ordered)-1; {
+		e := o.ordered[i]
+		lev := e.level
+		n := e.next
+		for ; n != nil && len(n.elems) > 1; n = n.next {
+			if n.level < lev {
+				lev = n.level
+			}
+			n.skipRemove = true
+		}
+		for ; o.ordered[i] != n; i++ {
+			o.ordered[i].level = lev
+			o.ordered[i].next = n
+			o.ordered[i+1].prev = e
+		}
+	}
+}
+
+// clone copies all ordering of es into a new ordering value.
+func (o *ordering) clone() *ordering {
+	o.sort()
+	oo := ordering{
+		entryMap: make(map[string]*entry),
+	}
+	for _, e := range o.ordered {
+		ne := &entry{
+			runes:     e.runes,
+			elems:     e.elems,
+			str:       e.str,
+			decompose: e.decompose,
+			exclude:   e.exclude,
+			logical:   e.logical,
+		}
+		oo.insert(ne)
+	}
+	oo.sort() // link all ordering.
+	oo.patchForInsert()
+	return &oo
+}
+
+// front returns the first entry to be indexed.
+// It assumes that sort() has been called.
+func (o *ordering) front() *entry {
+	e := o.ordered[0]
+	if e.prev != nil {
+		log.Panicf("unexpected first entry: %v", e)
+	}
+	// The first entry is always a logical position, which should not be indexed.
+	e, _ = e.nextIndexed()
+	return e
+}
+
+// sort sorts all ordering based on their collation elements and initializes
+// the prev, next, and level fields accordingly.
+func (o *ordering) sort() {
+	sort.Sort(sortedEntries(o.ordered))
+	l := o.ordered
+	for i := 1; i < len(l); i++ {
+		k := i - 1
+		l[k].next = l[i]
+		_, l[k].level = compareWeights(l[k].elems, l[i].elems)
+		l[i].prev = l[k]
+	}
+}
+
+// genColElems generates a collation element array from the runes in str. This
+// assumes that all collation elements have already been added to the Builder.
+func (o *ordering) genColElems(str string) []rawCE {
+	elems := []rawCE{}
+	for _, r := range []rune(str) {
+		for _, ce := range o.find(string(r)).elems {
+			if ce.w[0] != 0 || ce.w[1] != 0 || ce.w[2] != 0 {
+				elems = append(elems, ce)
+			}
+		}
+	}
+	return elems
+}

vendor/golang.org/x/text/collate/build/table.go

@@ -0,0 +1,81 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package build
+
+import (
+	"fmt"
+	"io"
+	"reflect"
+
+	"golang.org/x/text/internal/colltab"
+)
+
+// table is an intermediate structure that roughly resembles the table in collate.
+type table struct {
+	colltab.Table
+	trie trie
+	root *trieHandle
+}
+
+// print writes the table as Go compilable code to w. It prefixes the
+// variable names with name. It returns the number of bytes written
+// and the size of the resulting table.
+func (t *table) fprint(w io.Writer, name string) (n, size int, err error) {
+	update := func(nn, sz int, e error) {
+		n += nn
+		if err == nil {
+			err = e
+		}
+		size += sz
+	}
+	// Write arrays needed for the structure.
+	update(printColElems(w, t.ExpandElem, name+"ExpandElem"))
+	update(printColElems(w, t.ContractElem, name+"ContractElem"))
+	update(t.trie.printArrays(w, name))
+	update(printArray(t.ContractTries, w, name))
+
+	nn, e := fmt.Fprintf(w, "// Total size of %sTable is %d bytes\n", name, size)
+	update(nn, 0, e)
+	return
+}
+
+func (t *table) fprintIndex(w io.Writer, h *trieHandle, id string) (n int, err error) {
+	p := func(f string, a ...interface{}) {
+		nn, e := fmt.Fprintf(w, f, a...)
+		n += nn
+		if err == nil {
+			err = e
+		}
+	}
+	p("\t{ // %s\n", id)
+	p("\t\tlookupOffset: 0x%x,\n", h.lookupStart)
+	p("\t\tvaluesOffset: 0x%x,\n", h.valueStart)
+	p("\t},\n")
+	return
+}
+
+func printColElems(w io.Writer, a []uint32, name string) (n, sz int, err error) {
+	p := func(f string, a ...interface{}) {
+		nn, e := fmt.Fprintf(w, f, a...)
+		n += nn
+		if err == nil {
+			err = e
+		}
+	}
+	sz = len(a) * int(reflect.TypeOf(uint32(0)).Size())
+	p("// %s: %d entries, %d bytes\n", name, len(a), sz)
+	p("var %s = [%d]uint32 {", name, len(a))
+	for i, c := range a {
+		switch {
+		case i%64 == 0:
+			p("\n\t// Block %d, offset 0x%x\n", i/64, i)
+		case (i%64)%6 == 0:
+			p("\n\t")
+		}
+		p("0x%.8X, ", c)
+	}
+	p("\n}\n\n")
+	return
+}

vendor/golang.org/x/text/collate/build/trie.go

@@ -0,0 +1,290 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// The trie in this file is used to associate the first full character
+// in a UTF-8 string to a collation element.
+// All but the last byte in a UTF-8 byte sequence are
+// used to look up offsets in the index table to be used for the next byte.
+// The last byte is used to index into a table of collation elements.
+// This file contains the code for the generation of the trie.
+
+package build
+
+import (
+	"fmt"
+	"hash/fnv"
+	"io"
+	"reflect"
+)
+
+const (
+	blockSize   = 64
+	blockOffset = 2 // Subtract 2 blocks to compensate for the 0x80 added to continuation bytes.
+)
+
+type trieHandle struct {
+	lookupStart uint16 // offset in table for first byte
+	valueStart  uint16 // offset in table for first byte
+}
+
+type trie struct {
+	index  []uint16
+	values []uint32
+}
+
+// trieNode is the intermediate trie structure used for generating a trie.
+type trieNode struct {
+	index    []*trieNode
+	value    []uint32
+	b        byte
+	refValue uint16
+	refIndex uint16
+}
+
+func newNode() *trieNode {
+	return &trieNode{
+		index: make([]*trieNode, 64),
+		value: make([]uint32, 128), // root node size is 128 instead of 64
+	}
+}
+
+func (n *trieNode) isInternal() bool {
+	return n.value != nil
+}
+
+func (n *trieNode) insert(r rune, value uint32) {
+	const maskx = 0x3F // mask out two most-significant bits
+	str := string(r)
+	if len(str) == 1 {
+		n.value[str[0]] = value
+		return
+	}
+	for i := 0; i < len(str)-1; i++ {
+		b := str[i] & maskx
+		if n.index == nil {
+			n.index = make([]*trieNode, blockSize)
+		}
+		nn := n.index[b]
+		if nn == nil {
+			nn = &trieNode{}
+			nn.b = b
+			n.index[b] = nn
+		}
+		n = nn
+	}
+	if n.value == nil {
+		n.value = make([]uint32, blockSize)
+	}
+	b := str[len(str)-1] & maskx
+	n.value[b] = value
+}
+
+type trieBuilder struct {
+	t *trie
+
+	roots []*trieHandle
+
+	lookupBlocks []*trieNode
+	valueBlocks  []*trieNode
+
+	lookupBlockIdx map[uint32]*trieNode
+	valueBlockIdx  map[uint32]*trieNode
+}
+
+func newTrieBuilder() *trieBuilder {
+	index := &trieBuilder{}
+	index.lookupBlocks = make([]*trieNode, 0)
+	index.valueBlocks = make([]*trieNode, 0)
+	index.lookupBlockIdx = make(map[uint32]*trieNode)
+	index.valueBlockIdx = make(map[uint32]*trieNode)
+	// The third nil is the default null block.  The other two blocks
+	// are used to guarantee an offset of at least 3 for each block.
+	index.lookupBlocks = append(index.lookupBlocks, nil, nil, nil)
+	index.t = &trie{}
+	return index
+}
+
+func (b *trieBuilder) computeOffsets(n *trieNode) *trieNode {
+	hasher := fnv.New32()
+	if n.index != nil {
+		for i, nn := range n.index {
+			var vi, vv uint16
+			if nn != nil {
+				nn = b.computeOffsets(nn)
+				n.index[i] = nn
+				vi = nn.refIndex
+				vv = nn.refValue
+			}
+			hasher.Write([]byte{byte(vi >> 8), byte(vi)})
+			hasher.Write([]byte{byte(vv >> 8), byte(vv)})
+		}
+		h := hasher.Sum32()
+		nn, ok := b.lookupBlockIdx[h]
+		if !ok {
+			n.refIndex = uint16(len(b.lookupBlocks)) - blockOffset
+			b.lookupBlocks = append(b.lookupBlocks, n)
+			b.lookupBlockIdx[h] = n
+		} else {
+			n = nn
+		}
+	} else {
+		for _, v := range n.value {
+			hasher.Write([]byte{byte(v >> 24), byte(v >> 16), byte(v >> 8), byte(v)})
+		}
+		h := hasher.Sum32()
+		nn, ok := b.valueBlockIdx[h]
+		if !ok {
+			n.refValue = uint16(len(b.valueBlocks)) - blockOffset
+			n.refIndex = n.refValue
+			b.valueBlocks = append(b.valueBlocks, n)
+			b.valueBlockIdx[h] = n
+		} else {
+			n = nn
+		}
+	}
+	return n
+}
+
+func (b *trieBuilder) addStartValueBlock(n *trieNode) uint16 {
+	hasher := fnv.New32()
+	for _, v := range n.value[:2*blockSize] {
+		hasher.Write([]byte{byte(v >> 24), byte(v >> 16), byte(v >> 8), byte(v)})
+	}
+	h := hasher.Sum32()
+	nn, ok := b.valueBlockIdx[h]
+	if !ok {
+		n.refValue = uint16(len(b.valueBlocks))
+		n.refIndex = n.refValue
+		b.valueBlocks = append(b.valueBlocks, n)
+		// Add a dummy block to accommodate the double block size.
+		b.valueBlocks = append(b.valueBlocks, nil)
+		b.valueBlockIdx[h] = n
+	} else {
+		n = nn
+	}
+	return n.refValue
+}
+
+func genValueBlock(t *trie, n *trieNode) {
+	if n != nil {
+		for _, v := range n.value {
+			t.values = append(t.values, v)
+		}
+	}
+}
+
+func genLookupBlock(t *trie, n *trieNode) {
+	for _, nn := range n.index {
+		v := uint16(0)
+		if nn != nil {
+			if n.index != nil {
+				v = nn.refIndex
+			} else {
+				v = nn.refValue
+			}
+		}
+		t.index = append(t.index, v)
+	}
+}
+
+func (b *trieBuilder) addTrie(n *trieNode) *trieHandle {
+	h := &trieHandle{}
+	b.roots = append(b.roots, h)
+	h.valueStart = b.addStartValueBlock(n)
+	if len(b.roots) == 1 {
+		// We insert a null block after the first start value block.
+		// This ensures that continuation bytes UTF-8 sequences of length
+		// greater than 2 will automatically hit a null block if there
+		// was an undefined entry.
+		b.valueBlocks = append(b.valueBlocks, nil)
+	}
+	n = b.computeOffsets(n)
+	// Offset by one extra block as the first byte starts at 0xC0 instead of 0x80.
+	h.lookupStart = n.refIndex - 1
+	return h
+}
+
+// generate generates and returns the trie for n.
+func (b *trieBuilder) generate() (t *trie, err error) {
+	t = b.t
+	if len(b.valueBlocks) >= 1<<16 {
+		return nil, fmt.Errorf("maximum number of value blocks exceeded (%d > %d)", len(b.valueBlocks), 1<<16)
+	}
+	if len(b.lookupBlocks) >= 1<<16 {
+		return nil, fmt.Errorf("maximum number of lookup blocks exceeded (%d > %d)", len(b.lookupBlocks), 1<<16)
+	}
+	genValueBlock(t, b.valueBlocks[0])
+	genValueBlock(t, &trieNode{value: make([]uint32, 64)})
+	for i := 2; i < len(b.valueBlocks); i++ {
+		genValueBlock(t, b.valueBlocks[i])
+	}
+	n := &trieNode{index: make([]*trieNode, 64)}
+	genLookupBlock(t, n)
+	genLookupBlock(t, n)
+	genLookupBlock(t, n)
+	for i := 3; i < len(b.lookupBlocks); i++ {
+		genLookupBlock(t, b.lookupBlocks[i])
+	}
+	return b.t, nil
+}
+
+func (t *trie) printArrays(w io.Writer, name string) (n, size int, err error) {
+	p := func(f string, a ...interface{}) {
+		nn, e := fmt.Fprintf(w, f, a...)
+		n += nn
+		if err == nil {
+			err = e
+		}
+	}
+	nv := len(t.values)
+	p("// %sValues: %d entries, %d bytes\n", name, nv, nv*4)
+	p("// Block 2 is the null block.\n")
+	p("var %sValues = [%d]uint32 {", name, nv)
+	var printnewline bool
+	for i, v := range t.values {
+		if i%blockSize == 0 {
+			p("\n\t// Block %#x, offset %#x", i/blockSize, i)
+		}
+		if i%4 == 0 {
+			printnewline = true
+		}
+		if v != 0 {
+			if printnewline {
+				p("\n\t")
+				printnewline = false
+			}
+			p("%#04x:%#08x, ", i, v)
+		}
+	}
+	p("\n}\n\n")
+	ni := len(t.index)
+	p("// %sLookup: %d entries, %d bytes\n", name, ni, ni*2)
+	p("// Block 0 is the null block.\n")
+	p("var %sLookup = [%d]uint16 {", name, ni)
+	printnewline = false
+	for i, v := range t.index {
+		if i%blockSize == 0 {
+			p("\n\t// Block %#x, offset %#x", i/blockSize, i)
+		}
+		if i%8 == 0 {
+			printnewline = true
+		}
+		if v != 0 {
+			if printnewline {
+				p("\n\t")
+				printnewline = false
+			}
+			p("%#03x:%#02x, ", i, v)
+		}
+	}
+	p("\n}\n\n")
+	return n, nv*4 + ni*2, err
+}
+
+func (t *trie) printStruct(w io.Writer, handle *trieHandle, name string) (n, sz int, err error) {
+	const msg = "trie{ %sLookup[%d:], %sValues[%d:], %sLookup[:], %sValues[:]}"
+	n, err = fmt.Fprintf(w, msg, name, handle.lookupStart*blockSize, name, handle.valueStart*blockSize, name, name)
+	sz += int(reflect.TypeOf(trie{}).Size())
+	return
+}

vendor/golang.org/x/text/collate/collate.go

@@ -0,0 +1,403 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// TODO: remove hard-coded versions when we have implemented fractional weights.
+// The current implementation is incompatible with later CLDR versions.
+//go:generate go run maketables.go -cldr=23 -unicode=6.2.0
+
+// Package collate contains types for comparing and sorting Unicode strings
+// according to a given collation order.
+package collate // import "golang.org/x/text/collate"
+
+import (
+	"bytes"
+	"strings"
+
+	"golang.org/x/text/internal/colltab"
+	"golang.org/x/text/language"
+)
+
+// Collator provides functionality for comparing strings for a given
+// collation order.
+type Collator struct {
+	options
+
+	sorter sorter
+
+	_iter [2]iter
+}
+
+func (c *Collator) iter(i int) *iter {
+	// TODO: evaluate performance for making the second iterator optional.
+	return &c._iter[i]
+}
+
+// Supported returns the list of languages for which collating differs from its parent.
+func Supported() []language.Tag {
+	// TODO: use language.Coverage instead.
+
+	t := make([]language.Tag, len(tags))
+	copy(t, tags)
+	return t
+}
+
+func init() {
+	ids := strings.Split(availableLocales, ",")
+	tags = make([]language.Tag, len(ids))
+	for i, s := range ids {
+		tags[i] = language.Raw.MustParse(s)
+	}
+}
+
+var tags []language.Tag
+
+// New returns a new Collator initialized for the given locale.
+func New(t language.Tag, o ...Option) *Collator {
+	index := colltab.MatchLang(t, tags)
+	c := newCollator(getTable(locales[index]))
+
+	// Set options from the user-supplied tag.
+	c.setFromTag(t)
+
+	// Set the user-supplied options.
+	c.setOptions(o)
+
+	c.init()
+	return c
+}
+
+// NewFromTable returns a new Collator for the given Weighter.
+func NewFromTable(w colltab.Weighter, o ...Option) *Collator {
+	c := newCollator(w)
+	c.setOptions(o)
+	c.init()
+	return c
+}
+
+func (c *Collator) init() {
+	if c.numeric {
+		c.t = colltab.NewNumericWeighter(c.t)
+	}
+	c._iter[0].init(c)
+	c._iter[1].init(c)
+}
+
+// Buffer holds keys generated by Key and KeyString.
+type Buffer struct {
+	buf [4096]byte
+	key []byte
+}
+
+func (b *Buffer) init() {
+	if b.key == nil {
+		b.key = b.buf[:0]
+	}
+}
+
+// Reset clears the buffer from previous results generated by Key and KeyString.
+func (b *Buffer) Reset() {
+	b.key = b.key[:0]
+}
+
+// Compare returns an integer comparing the two byte slices.
+// The result will be 0 if a==b, -1 if a < b, and +1 if a > b.
+func (c *Collator) Compare(a, b []byte) int {
+	// TODO: skip identical prefixes once we have a fast way to detect if a rune is
+	// part of a contraction. This would lead to roughly a 10% speedup for the colcmp regtest.
+	c.iter(0).SetInput(a)
+	c.iter(1).SetInput(b)
+	if res := c.compare(); res != 0 {
+		return res
+	}
+	if !c.ignore[colltab.Identity] {
+		return bytes.Compare(a, b)
+	}
+	return 0
+}
+
+// CompareString returns an integer comparing the two strings.
+// The result will be 0 if a==b, -1 if a < b, and +1 if a > b.
+func (c *Collator) CompareString(a, b string) int {
+	// TODO: skip identical prefixes once we have a fast way to detect if a rune is
+	// part of a contraction. This would lead to roughly a 10% speedup for the colcmp regtest.
+	c.iter(0).SetInputString(a)
+	c.iter(1).SetInputString(b)
+	if res := c.compare(); res != 0 {
+		return res
+	}
+	if !c.ignore[colltab.Identity] {
+		if a < b {
+			return -1
+		} else if a > b {
+			return 1
+		}
+	}
+	return 0
+}
+
+func compareLevel(f func(i *iter) int, a, b *iter) int {
+	a.pce = 0
+	b.pce = 0
+	for {
+		va := f(a)
+		vb := f(b)
+		if va != vb {
+			if va < vb {
+				return -1
+			}
+			return 1
+		} else if va == 0 {
+			break
+		}
+	}
+	return 0
+}
+
+func (c *Collator) compare() int {
+	ia, ib := c.iter(0), c.iter(1)
+	// Process primary level
+	if c.alternate != altShifted {
+		// TODO: implement script reordering
+		if res := compareLevel((*iter).nextPrimary, ia, ib); res != 0 {
+			return res
+		}
+	} else {
+		// TODO: handle shifted
+	}
+	if !c.ignore[colltab.Secondary] {
+		f := (*iter).nextSecondary
+		if c.backwards {
+			f = (*iter).prevSecondary
+		}
+		if res := compareLevel(f, ia, ib); res != 0 {
+			return res
+		}
+	}
+	// TODO: special case handling (Danish?)
+	if !c.ignore[colltab.Tertiary] || c.caseLevel {
+		if res := compareLevel((*iter).nextTertiary, ia, ib); res != 0 {
+			return res
+		}
+		if !c.ignore[colltab.Quaternary] {
+			if res := compareLevel((*iter).nextQuaternary, ia, ib); res != 0 {
+				return res
+			}
+		}
+	}
+	return 0
+}
+
+// Key returns the collation key for str.
+// Passing the buffer buf may avoid memory allocations.
+// The returned slice will point to an allocation in Buffer and will remain
+// valid until the next call to buf.Reset().
+func (c *Collator) Key(buf *Buffer, str []byte) []byte {
+	// See http://www.unicode.org/reports/tr10/#Main_Algorithm for more details.
+	buf.init()
+	return c.key(buf, c.getColElems(str))
+}
+
+// KeyFromString returns the collation key for str.
+// Passing the buffer buf may avoid memory allocations.
+// The returned slice will point to an allocation in Buffer and will retain
+// valid until the next call to buf.ResetKeys().
+func (c *Collator) KeyFromString(buf *Buffer, str string) []byte {
+	// See http://www.unicode.org/reports/tr10/#Main_Algorithm for more details.
+	buf.init()
+	return c.key(buf, c.getColElemsString(str))
+}
+
+func (c *Collator) key(buf *Buffer, w []colltab.Elem) []byte {
+	processWeights(c.alternate, c.t.Top(), w)
+	kn := len(buf.key)
+	c.keyFromElems(buf, w)
+	return buf.key[kn:]
+}
+
+func (c *Collator) getColElems(str []byte) []colltab.Elem {
+	i := c.iter(0)
+	i.SetInput(str)
+	for i.Next() {
+	}
+	return i.Elems
+}
+
+func (c *Collator) getColElemsString(str string) []colltab.Elem {
+	i := c.iter(0)
+	i.SetInputString(str)
+	for i.Next() {
+	}
+	return i.Elems
+}
+
+type iter struct {
+	wa [512]colltab.Elem
+
+	colltab.Iter
+	pce int
+}
+
+func (i *iter) init(c *Collator) {
+	i.Weighter = c.t
+	i.Elems = i.wa[:0]
+}
+
+func (i *iter) nextPrimary() int {
+	for {
+		for ; i.pce < i.N; i.pce++ {
+			if v := i.Elems[i.pce].Primary(); v != 0 {
+				i.pce++
+				return v
+			}
+		}
+		if !i.Next() {
+			return 0
+		}
+	}
+	panic("should not reach here")
+}
+
+func (i *iter) nextSecondary() int {
+	for ; i.pce < len(i.Elems); i.pce++ {
+		if v := i.Elems[i.pce].Secondary(); v != 0 {
+			i.pce++
+			return v
+		}
+	}
+	return 0
+}
+
+func (i *iter) prevSecondary() int {
+	for ; i.pce < len(i.Elems); i.pce++ {
+		if v := i.Elems[len(i.Elems)-i.pce-1].Secondary(); v != 0 {
+			i.pce++
+			return v
+		}
+	}
+	return 0
+}
+
+func (i *iter) nextTertiary() int {
+	for ; i.pce < len(i.Elems); i.pce++ {
+		if v := i.Elems[i.pce].Tertiary(); v != 0 {
+			i.pce++
+			return int(v)
+		}
+	}
+	return 0
+}
+
+func (i *iter) nextQuaternary() int {
+	for ; i.pce < len(i.Elems); i.pce++ {
+		if v := i.Elems[i.pce].Quaternary(); v != 0 {
+			i.pce++
+			return v
+		}
+	}
+	return 0
+}
+
+func appendPrimary(key []byte, p int) []byte {
+	// Convert to variable length encoding; supports up to 23 bits.
+	if p <= 0x7FFF {
+		key = append(key, uint8(p>>8), uint8(p))
+	} else {
+		key = append(key, uint8(p>>16)|0x80, uint8(p>>8), uint8(p))
+	}
+	return key
+}
+
+// keyFromElems converts the weights ws to a compact sequence of bytes.
+// The result will be appended to the byte buffer in buf.
+func (c *Collator) keyFromElems(buf *Buffer, ws []colltab.Elem) {
+	for _, v := range ws {
+		if w := v.Primary(); w > 0 {
+			buf.key = appendPrimary(buf.key, w)
+		}
+	}
+	if !c.ignore[colltab.Secondary] {
+		buf.key = append(buf.key, 0, 0)
+		// TODO: we can use one 0 if we can guarantee that all non-zero weights are > 0xFF.
+		if !c.backwards {
+			for _, v := range ws {
+				if w := v.Secondary(); w > 0 {
+					buf.key = append(buf.key, uint8(w>>8), uint8(w))
+				}
+			}
+		} else {
+			for i := len(ws) - 1; i >= 0; i-- {
+				if w := ws[i].Secondary(); w > 0 {
+					buf.key = append(buf.key, uint8(w>>8), uint8(w))
+				}
+			}
+		}
+	} else if c.caseLevel {
+		buf.key = append(buf.key, 0, 0)
+	}
+	if !c.ignore[colltab.Tertiary] || c.caseLevel {
+		buf.key = append(buf.key, 0, 0)
+		for _, v := range ws {
+			if w := v.Tertiary(); w > 0 {
+				buf.key = append(buf.key, uint8(w))
+			}
+		}
+		// Derive the quaternary weights from the options and other levels.
+		// Note that we represent MaxQuaternary as 0xFF. The first byte of the
+		// representation of a primary weight is always smaller than 0xFF,
+		// so using this single byte value will compare correctly.
+		if !c.ignore[colltab.Quaternary] && c.alternate >= altShifted {
+			if c.alternate == altShiftTrimmed {
+				lastNonFFFF := len(buf.key)
+				buf.key = append(buf.key, 0)
+				for _, v := range ws {
+					if w := v.Quaternary(); w == colltab.MaxQuaternary {
+						buf.key = append(buf.key, 0xFF)
+					} else if w > 0 {
+						buf.key = appendPrimary(buf.key, w)
+						lastNonFFFF = len(buf.key)
+					}
+				}
+				buf.key = buf.key[:lastNonFFFF]
+			} else {
+				buf.key = append(buf.key, 0)
+				for _, v := range ws {
+					if w := v.Quaternary(); w == colltab.MaxQuaternary {
+						buf.key = append(buf.key, 0xFF)
+					} else if w > 0 {
+						buf.key = appendPrimary(buf.key, w)
+					}
+				}
+			}
+		}
+	}
+}
+
+func processWeights(vw alternateHandling, top uint32, wa []colltab.Elem) {
+	ignore := false
+	vtop := int(top)
+	switch vw {
+	case altShifted, altShiftTrimmed:
+		for i := range wa {
+			if p := wa[i].Primary(); p <= vtop && p != 0 {
+				wa[i] = colltab.MakeQuaternary(p)
+				ignore = true
+			} else if p == 0 {
+				if ignore {
+					wa[i] = colltab.Ignore
+				}
+			} else {
+				ignore = false
+			}
+		}
+	case altBlanked:
+		for i := range wa {
+			if p := wa[i].Primary(); p <= vtop && (ignore || p != 0) {
+				wa[i] = colltab.Ignore
+				ignore = true
+			} else {
+				ignore = false
+			}
+		}
+	}
+}

vendor/golang.org/x/text/collate/index.go

@@ -0,0 +1,32 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package collate
+
+import "golang.org/x/text/internal/colltab"
+
+const blockSize = 64
+
+func getTable(t tableIndex) *colltab.Table {
+	return &colltab.Table{
+		Index: colltab.Trie{
+			Index0:  mainLookup[:][blockSize*t.lookupOffset:],
+			Values0: mainValues[:][blockSize*t.valuesOffset:],
+			Index:   mainLookup[:],
+			Values:  mainValues[:],
+		},
+		ExpandElem:     mainExpandElem[:],
+		ContractTries:  colltab.ContractTrieSet(mainCTEntries[:]),
+		ContractElem:   mainContractElem[:],
+		MaxContractLen: 18,
+		VariableTop:    varTop,
+	}
+}
+
+// tableIndex holds information for constructing a table
+// for a certain locale based on the main table.
+type tableIndex struct {
+	lookupOffset uint32
+	valuesOffset uint32
+}

vendor/golang.org/x/text/collate/maketables.go

@@ -0,0 +1,553 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+// Collation table generator.
+// Data read from the web.
+
+package main
+
+import (
+	"archive/zip"
+	"bufio"
+	"bytes"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+
+	"golang.org/x/text/collate"
+	"golang.org/x/text/collate/build"
+	"golang.org/x/text/internal/colltab"
+	"golang.org/x/text/internal/gen"
+	"golang.org/x/text/language"
+	"golang.org/x/text/unicode/cldr"
+)
+
+var (
+	test = flag.Bool("test", false,
+		"test existing tables; can be used to compare web data with package data.")
+	short = flag.Bool("short", false, `Use "short" alternatives, when available.`)
+	draft = flag.Bool("draft", false, `Use draft versions, when available.`)
+	tags  = flag.String("tags", "", "build tags to be included after +build directive")
+	pkg   = flag.String("package", "collate",
+		"the name of the package in which the generated file is to be included")
+
+	tables = flagStringSetAllowAll("tables", "collate", "collate,chars",
+		"comma-spearated list of tables to generate.")
+	exclude = flagStringSet("exclude", "zh2", "",
+		"comma-separated list of languages to exclude.")
+	include = flagStringSet("include", "", "",
+		"comma-separated list of languages to include. Include trumps exclude.")
+	// TODO: Not included: unihan gb2312han zhuyin big5han (for size reasons)
+	// TODO: Not included: traditional (buggy for Bengali)
+	types = flagStringSetAllowAll("types", "standard,phonebook,phonetic,reformed,pinyin,stroke", "",
+		"comma-separated list of types that should be included.")
+)
+
+// stringSet implements an ordered set based on a list.  It implements flag.Value
+// to allow a set to be specified as a comma-separated list.
+type stringSet struct {
+	s        []string
+	allowed  *stringSet
+	dirty    bool // needs compaction if true
+	all      bool
+	allowAll bool
+}
+
+func flagStringSet(name, def, allowed, usage string) *stringSet {
+	ss := &stringSet{}
+	if allowed != "" {
+		usage += fmt.Sprintf(" (allowed values: any of %s)", allowed)
+		ss.allowed = &stringSet{}
+		failOnError(ss.allowed.Set(allowed))
+	}
+	ss.Set(def)
+	flag.Var(ss, name, usage)
+	return ss
+}
+
+func flagStringSetAllowAll(name, def, allowed, usage string) *stringSet {
+	ss := &stringSet{allowAll: true}
+	if allowed == "" {
+		flag.Var(ss, name, usage+fmt.Sprintf(` Use "all" to select all.`))
+	} else {
+		ss.allowed = &stringSet{}
+		failOnError(ss.allowed.Set(allowed))
+		flag.Var(ss, name, usage+fmt.Sprintf(` (allowed values: "all" or any of %s)`, allowed))
+	}
+	ss.Set(def)
+	return ss
+}
+
+func (ss stringSet) Len() int {
+	return len(ss.s)
+}
+
+func (ss stringSet) String() string {
+	return strings.Join(ss.s, ",")
+}
+
+func (ss *stringSet) Set(s string) error {
+	if ss.allowAll && s == "all" {
+		ss.s = nil
+		ss.all = true
+		return nil
+	}
+	ss.s = ss.s[:0]
+	for _, s := range strings.Split(s, ",") {
+		if s := strings.TrimSpace(s); s != "" {
+			if ss.allowed != nil && !ss.allowed.contains(s) {
+				return fmt.Errorf("unsupported value %q; must be one of %s", s, ss.allowed)
+			}
+			ss.add(s)
+		}
+	}
+	ss.compact()
+	return nil
+}
+
+func (ss *stringSet) add(s string) {
+	ss.s = append(ss.s, s)
+	ss.dirty = true
+}
+
+func (ss *stringSet) values() []string {
+	ss.compact()
+	return ss.s
+}
+
+func (ss *stringSet) contains(s string) bool {
+	if ss.all {
+		return true
+	}
+	for _, v := range ss.s {
+		if v == s {
+			return true
+		}
+	}
+	return false
+}
+
+func (ss *stringSet) compact() {
+	if !ss.dirty {
+		return
+	}
+	a := ss.s
+	sort.Strings(a)
+	k := 0
+	for i := 1; i < len(a); i++ {
+		if a[k] != a[i] {
+			a[k+1] = a[i]
+			k++
+		}
+	}
+	ss.s = a[:k+1]
+	ss.dirty = false
+}
+
+func skipLang(l string) bool {
+	if include.Len() > 0 {
+		return !include.contains(l)
+	}
+	return exclude.contains(l)
+}
+
+// altInclude returns a list of alternatives (for the LDML alt attribute)
+// in order of preference.  An empty string in this list indicates the
+// default entry.
+func altInclude() []string {
+	l := []string{}
+	if *short {
+		l = append(l, "short")
+	}
+	l = append(l, "")
+	// TODO: handle draft using cldr.SetDraftLevel
+	if *draft {
+		l = append(l, "proposed")
+	}
+	return l
+}
+
+func failOnError(e error) {
+	if e != nil {
+		log.Panic(e)
+	}
+}
+
+func openArchive() *zip.Reader {
+	f := gen.OpenCLDRCoreZip()
+	buffer, err := ioutil.ReadAll(f)
+	f.Close()
+	failOnError(err)
+	archive, err := zip.NewReader(bytes.NewReader(buffer), int64(len(buffer)))
+	failOnError(err)
+	return archive
+}
+
+// parseUCA parses a Default Unicode Collation Element Table of the format
+// specified in http://www.unicode.org/reports/tr10/#File_Format.
+// It returns the variable top.
+func parseUCA(builder *build.Builder) {
+	var r io.ReadCloser
+	var err error
+	for _, f := range openArchive().File {
+		if strings.HasSuffix(f.Name, "allkeys_CLDR.txt") {
+			r, err = f.Open()
+		}
+	}
+	if r == nil {
+		log.Fatal("File allkeys_CLDR.txt not found in archive.")
+	}
+	failOnError(err)
+	defer r.Close()
+	scanner := bufio.NewScanner(r)
+	colelem := regexp.MustCompile(`\[([.*])([0-9A-F.]+)\]`)
+	for i := 1; scanner.Scan(); i++ {
+		line := scanner.Text()
+		if len(line) == 0 || line[0] == '#' {
+			continue
+		}
+		if line[0] == '@' {
+			// parse properties
+			switch {
+			case strings.HasPrefix(line[1:], "version "):
+				a := strings.Split(line[1:], " ")
+				if a[1] != gen.UnicodeVersion() {
+					log.Fatalf("incompatible version %s; want %s", a[1], gen.UnicodeVersion())
+				}
+			case strings.HasPrefix(line[1:], "backwards "):
+				log.Fatalf("%d: unsupported option backwards", i)
+			default:
+				log.Printf("%d: unknown option %s", i, line[1:])
+			}
+		} else {
+			// parse entries
+			part := strings.Split(line, " ; ")
+			if len(part) != 2 {
+				log.Fatalf("%d: production rule without ';': %v", i, line)
+			}
+			lhs := []rune{}
+			for _, v := range strings.Split(part[0], " ") {
+				if v == "" {
+					continue
+				}
+				lhs = append(lhs, rune(convHex(i, v)))
+			}
+			var n int
+			var vars []int
+			rhs := [][]int{}
+			for i, m := range colelem.FindAllStringSubmatch(part[1], -1) {
+				n += len(m[0])
+				elem := []int{}
+				for _, h := range strings.Split(m[2], ".") {
+					elem = append(elem, convHex(i, h))
+				}
+				if m[1] == "*" {
+					vars = append(vars, i)
+				}
+				rhs = append(rhs, elem)
+			}
+			if len(part[1]) < n+3 || part[1][n+1] != '#' {
+				log.Fatalf("%d: expected comment; found %s", i, part[1][n:])
+			}
+			if *test {
+				testInput.add(string(lhs))
+			}
+			failOnError(builder.Add(lhs, rhs, vars))
+		}
+	}
+	if scanner.Err() != nil {
+		log.Fatal(scanner.Err())
+	}
+}
+
+func convHex(line int, s string) int {
+	r, e := strconv.ParseInt(s, 16, 32)
+	if e != nil {
+		log.Fatalf("%d: %v", line, e)
+	}
+	return int(r)
+}
+
+var testInput = stringSet{}
+
+var charRe = regexp.MustCompile(`&#x([0-9A-F]*);`)
+var tagRe = regexp.MustCompile(`<([a-z_]*)  */>`)
+
+var mainLocales = []string{}
+
+// charsets holds a list of exemplar characters per category.
+type charSets map[string][]string
+
+func (p charSets) fprint(w io.Writer) {
+	fmt.Fprintln(w, "[exN]string{")
+	for i, k := range []string{"", "contractions", "punctuation", "auxiliary", "currencySymbol", "index"} {
+		if set := p[k]; len(set) != 0 {
+			fmt.Fprintf(w, "\t\t%d: %q,\n", i, strings.Join(set, " "))
+		}
+	}
+	fmt.Fprintln(w, "\t},")
+}
+
+var localeChars = make(map[string]charSets)
+
+const exemplarHeader = `
+type exemplarType int
+const (
+	exCharacters exemplarType = iota
+	exContractions
+	exPunctuation
+	exAuxiliary
+	exCurrency
+	exIndex
+	exN
+)
+`
+
+func printExemplarCharacters(w io.Writer) {
+	fmt.Fprintln(w, exemplarHeader)
+	fmt.Fprintln(w, "var exemplarCharacters = map[string][exN]string{")
+	for _, loc := range mainLocales {
+		fmt.Fprintf(w, "\t%q: ", loc)
+		localeChars[loc].fprint(w)
+	}
+	fmt.Fprintln(w, "}")
+}
+
+func decodeCLDR(d *cldr.Decoder) *cldr.CLDR {
+	r := gen.OpenCLDRCoreZip()
+	data, err := d.DecodeZip(r)
+	failOnError(err)
+	return data
+}
+
+// parseMain parses XML files in the main directory of the CLDR core.zip file.
+func parseMain() {
+	d := &cldr.Decoder{}
+	d.SetDirFilter("main")
+	d.SetSectionFilter("characters")
+	data := decodeCLDR(d)
+	for _, loc := range data.Locales() {
+		x := data.RawLDML(loc)
+		if skipLang(x.Identity.Language.Type) {
+			continue
+		}
+		if x.Characters != nil {
+			x, _ = data.LDML(loc)
+			loc = language.Make(loc).String()
+			for _, ec := range x.Characters.ExemplarCharacters {
+				if ec.Draft != "" {
+					continue
+				}
+				if _, ok := localeChars[loc]; !ok {
+					mainLocales = append(mainLocales, loc)
+					localeChars[loc] = make(charSets)
+				}
+				localeChars[loc][ec.Type] = parseCharacters(ec.Data())
+			}
+		}
+	}
+}
+
+func parseCharacters(chars string) []string {
+	parseSingle := func(s string) (r rune, tail string, escaped bool) {
+		if s[0] == '\\' {
+			return rune(s[1]), s[2:], true
+		}
+		r, sz := utf8.DecodeRuneInString(s)
+		return r, s[sz:], false
+	}
+	chars = strings.TrimSpace(chars)
+	if n := len(chars) - 1; chars[n] == ']' && chars[0] == '[' {
+		chars = chars[1:n]
+	}
+	list := []string{}
+	var r, last, end rune
+	for len(chars) > 0 {
+		if chars[0] == '{' { // character sequence
+			buf := []rune{}
+			for chars = chars[1:]; len(chars) > 0; {
+				r, chars, _ = parseSingle(chars)
+				if r == '}' {
+					break
+				}
+				if r == ' ' {
+					log.Fatalf("space not supported in sequence %q", chars)
+				}
+				buf = append(buf, r)
+			}
+			list = append(list, string(buf))
+			last = 0
+		} else { // single character
+			escaped := false
+			r, chars, escaped = parseSingle(chars)
+			if r != ' ' {
+				if r == '-' && !escaped {
+					if last == 0 {
+						log.Fatal("'-' should be preceded by a character")
+					}
+					end, chars, _ = parseSingle(chars)
+					for ; last <= end; last++ {
+						list = append(list, string(last))
+					}
+					last = 0
+				} else {
+					list = append(list, string(r))
+					last = r
+				}
+			}
+		}
+	}
+	return list
+}
+
+var fileRe = regexp.MustCompile(`.*/collation/(.*)\.xml`)
+
+// typeMap translates legacy type keys to their BCP47 equivalent.
+var typeMap = map[string]string{
+	"phonebook":   "phonebk",
+	"traditional": "trad",
+}
+
+// parseCollation parses XML files in the collation directory of the CLDR core.zip file.
+func parseCollation(b *build.Builder) {
+	d := &cldr.Decoder{}
+	d.SetDirFilter("collation")
+	data := decodeCLDR(d)
+	for _, loc := range data.Locales() {
+		x, err := data.LDML(loc)
+		failOnError(err)
+		if skipLang(x.Identity.Language.Type) {
+			continue
+		}
+		cs := x.Collations.Collation
+		sl := cldr.MakeSlice(&cs)
+		if len(types.s) == 0 {
+			sl.SelectAnyOf("type", x.Collations.Default())
+		} else if !types.all {
+			sl.SelectAnyOf("type", types.s...)
+		}
+		sl.SelectOnePerGroup("alt", altInclude())
+
+		for _, c := range cs {
+			id, err := language.Parse(loc)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "invalid locale: %q", err)
+				continue
+			}
+			// Support both old- and new-style defaults.
+			d := c.Type
+			if x.Collations.DefaultCollation == nil {
+				d = x.Collations.Default()
+			} else {
+				d = x.Collations.DefaultCollation.Data()
+			}
+			// We assume tables are being built either for search or collation,
+			// but not both. For search the default is always "search".
+			if d != c.Type && c.Type != "search" {
+				typ := c.Type
+				if len(c.Type) > 8 {
+					typ = typeMap[c.Type]
+				}
+				id, err = id.SetTypeForKey("co", typ)
+				failOnError(err)
+			}
+			t := b.Tailoring(id)
+			c.Process(processor{t})
+		}
+	}
+}
+
+type processor struct {
+	t *build.Tailoring
+}
+
+func (p processor) Reset(anchor string, before int) (err error) {
+	if before != 0 {
+		err = p.t.SetAnchorBefore(anchor)
+	} else {
+		err = p.t.SetAnchor(anchor)
+	}
+	failOnError(err)
+	return nil
+}
+
+func (p processor) Insert(level int, str, context, extend string) error {
+	str = context + str
+	if *test {
+		testInput.add(str)
+	}
+	// TODO: mimic bug in old maketables: remove.
+	err := p.t.Insert(colltab.Level(level-1), str, context+extend)
+	failOnError(err)
+	return nil
+}
+
+func (p processor) Index(id string) {
+}
+
+func testCollator(c *collate.Collator) {
+	c0 := collate.New(language.Und)
+
+	// iterator over all characters for all locales and check
+	// whether Key is equal.
+	buf := collate.Buffer{}
+
+	// Add all common and not too uncommon runes to the test set.
+	for i := rune(0); i < 0x30000; i++ {
+		testInput.add(string(i))
+	}
+	for i := rune(0xE0000); i < 0xF0000; i++ {
+		testInput.add(string(i))
+	}
+	for _, str := range testInput.values() {
+		k0 := c0.KeyFromString(&buf, str)
+		k := c.KeyFromString(&buf, str)
+		if !bytes.Equal(k0, k) {
+			failOnError(fmt.Errorf("test:%U: keys differ (%x vs %x)", []rune(str), k0, k))
+		}
+		buf.Reset()
+	}
+	fmt.Println("PASS")
+}
+
+func main() {
+	gen.Init()
+	b := build.NewBuilder()
+	parseUCA(b)
+	if tables.contains("chars") {
+		parseMain()
+	}
+	parseCollation(b)
+
+	c, err := b.Build()
+	failOnError(err)
+
+	if *test {
+		testCollator(collate.NewFromTable(c))
+	} else {
+		w := &bytes.Buffer{}
+
+		gen.WriteUnicodeVersion(w)
+		gen.WriteCLDRVersion(w)
+
+		if tables.contains("collate") {
+			_, err = b.Print(w)
+			failOnError(err)
+		}
+		if tables.contains("chars") {
+			printExemplarCharacters(w)
+		}
+		gen.WriteGoFile("tables.go", *pkg, w.Bytes())
+	}
+}

vendor/golang.org/x/text/collate/option.go

@@ -0,0 +1,239 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package collate
+
+import (
+	"sort"
+
+	"golang.org/x/text/internal/colltab"
+	"golang.org/x/text/language"
+	"golang.org/x/text/unicode/norm"
+)
+
+// newCollator creates a new collator with default options configured.
+func newCollator(t colltab.Weighter) *Collator {
+	// Initialize a collator with default options.
+	c := &Collator{
+		options: options{
+			ignore: [colltab.NumLevels]bool{
+				colltab.Quaternary: true,
+				colltab.Identity:   true,
+			},
+			f: norm.NFD,
+			t: t,
+		},
+	}
+
+	// TODO: store vt in tags or remove.
+	c.variableTop = t.Top()
+
+	return c
+}
+
+// An Option is used to change the behavior of a Collator. Options override the
+// settings passed through the locale identifier.
+type Option struct {
+	priority int
+	f        func(o *options)
+}
+
+type prioritizedOptions []Option
+
+func (p prioritizedOptions) Len() int {
+	return len(p)
+}
+
+func (p prioritizedOptions) Swap(i, j int) {
+	p[i], p[j] = p[j], p[i]
+}
+
+func (p prioritizedOptions) Less(i, j int) bool {
+	return p[i].priority < p[j].priority
+}
+
+type options struct {
+	// ignore specifies which levels to ignore.
+	ignore [colltab.NumLevels]bool
+
+	// caseLevel is true if there is an additional level of case matching
+	// between the secondary and tertiary levels.
+	caseLevel bool
+
+	// backwards specifies the order of sorting at the secondary level.
+	// This option exists predominantly to support reverse sorting of accents in French.
+	backwards bool
+
+	// numeric specifies whether any sequence of decimal digits (category is Nd)
+	// is sorted at a primary level with its numeric value.
+	// For example, "A-21" < "A-123".
+	// This option is set by wrapping the main Weighter with NewNumericWeighter.
+	numeric bool
+
+	// alternate specifies an alternative handling of variables.
+	alternate alternateHandling
+
+	// variableTop is the largest primary value that is considered to be
+	// variable.
+	variableTop uint32
+
+	t colltab.Weighter
+
+	f norm.Form
+}
+
+func (o *options) setOptions(opts []Option) {
+	sort.Sort(prioritizedOptions(opts))
+	for _, x := range opts {
+		x.f(o)
+	}
+}
+
+// OptionsFromTag extracts the BCP47 collation options from the tag and
+// configures a collator accordingly. These options are set before any other
+// option.
+func OptionsFromTag(t language.Tag) Option {
+	return Option{0, func(o *options) {
+		o.setFromTag(t)
+	}}
+}
+
+func (o *options) setFromTag(t language.Tag) {
+	o.caseLevel = ldmlBool(t, o.caseLevel, "kc")
+	o.backwards = ldmlBool(t, o.backwards, "kb")
+	o.numeric = ldmlBool(t, o.numeric, "kn")
+
+	// Extract settings from the BCP47 u extension.
+	switch t.TypeForKey("ks") { // strength
+	case "level1":
+		o.ignore[colltab.Secondary] = true
+		o.ignore[colltab.Tertiary] = true
+	case "level2":
+		o.ignore[colltab.Tertiary] = true
+	case "level3", "":
+		// The default.
+	case "level4":
+		o.ignore[colltab.Quaternary] = false
+	case "identic":
+		o.ignore[colltab.Quaternary] = false
+		o.ignore[colltab.Identity] = false
+	}
+
+	switch t.TypeForKey("ka") {
+	case "shifted":
+		o.alternate = altShifted
+	// The following two types are not official BCP47, but we support them to
+	// give access to this otherwise hidden functionality. The name blanked is
+	// derived from the LDML name blanked and posix reflects the main use of
+	// the shift-trimmed option.
+	case "blanked":
+		o.alternate = altBlanked
+	case "posix":
+		o.alternate = altShiftTrimmed
+	}
+
+	// TODO: caseFirst ("kf"), reorder ("kr"), and maybe variableTop ("vt").
+
+	// Not used:
+	// - normalization ("kk", not necessary for this implementation)
+	// - hiraganaQuatenary ("kh", obsolete)
+}
+
+func ldmlBool(t language.Tag, old bool, key string) bool {
+	switch t.TypeForKey(key) {
+	case "true":
+		return true
+	case "false":
+		return false
+	default:
+		return old
+	}
+}
+
+var (
+	// IgnoreCase sets case-insensitive comparison.
+	IgnoreCase Option = ignoreCase
+	ignoreCase        = Option{3, ignoreCaseF}
+
+	// IgnoreDiacritics causes diacritical marks to be ignored. ("o" == "ö").
+	IgnoreDiacritics Option = ignoreDiacritics
+	ignoreDiacritics        = Option{3, ignoreDiacriticsF}
+
+	// IgnoreWidth causes full-width characters to match their half-width
+	// equivalents.
+	IgnoreWidth Option = ignoreWidth
+	ignoreWidth        = Option{2, ignoreWidthF}
+
+	// Loose sets the collator to ignore diacritics, case and weight.
+	Loose Option = loose
+	loose        = Option{4, looseF}
+
+	// Force ordering if strings are equivalent but not equal.
+	Force Option = force
+	force        = Option{5, forceF}
+
+	// Numeric specifies that numbers should sort numerically ("2" < "12").
+	Numeric Option = numeric
+	numeric        = Option{5, numericF}
+)
+
+func ignoreWidthF(o *options) {
+	o.ignore[colltab.Tertiary] = true
+	o.caseLevel = true
+}
+
+func ignoreDiacriticsF(o *options) {
+	o.ignore[colltab.Secondary] = true
+}
+
+func ignoreCaseF(o *options) {
+	o.ignore[colltab.Tertiary] = true
+	o.caseLevel = false
+}
+
+func looseF(o *options) {
+	ignoreWidthF(o)
+	ignoreDiacriticsF(o)
+	ignoreCaseF(o)
+}
+
+func forceF(o *options) {
+	o.ignore[colltab.Identity] = false
+}
+
+func numericF(o *options) { o.numeric = true }
+
+// Reorder overrides the pre-defined ordering of scripts and character sets.
+func Reorder(s ...string) Option {
+	// TODO: need fractional weights to implement this.
+	panic("TODO: implement")
+}
+
+// TODO: consider making these public again. These options cannot be fully
+// specified in BCP47, so an API interface seems warranted. Still a higher-level
+// interface would be nice (e.g. a POSIX option for enabling altShiftTrimmed)
+
+// alternateHandling identifies the various ways in which variables are handled.
+// A rune with a primary weight lower than the variable top is considered a
+// variable.
+// See http://www.unicode.org/reports/tr10/#Variable_Weighting for details.
+type alternateHandling int
+
+const (
+	// altNonIgnorable turns off special handling of variables.
+	altNonIgnorable alternateHandling = iota
+
+	// altBlanked sets variables and all subsequent primary ignorables to be
+	// ignorable at all levels. This is identical to removing all variables
+	// and subsequent primary ignorables from the input.
+	altBlanked
+
+	// altShifted sets variables to be ignorable for levels one through three and
+	// adds a fourth level based on the values of the ignored levels.
+	altShifted
+
+	// altShiftTrimmed is a slight variant of altShifted that is used to
+	// emulate POSIX.
+	altShiftTrimmed
+)

vendor/golang.org/x/text/collate/sort.go

@@ -0,0 +1,81 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package collate
+
+import (
+	"bytes"
+	"sort"
+)
+
+const (
+	maxSortBuffer  = 40960
+	maxSortEntries = 4096
+)
+
+type swapper interface {
+	Swap(i, j int)
+}
+
+type sorter struct {
+	buf  *Buffer
+	keys [][]byte
+	src  swapper
+}
+
+func (s *sorter) init(n int) {
+	if s.buf == nil {
+		s.buf = &Buffer{}
+		s.buf.init()
+	}
+	if cap(s.keys) < n {
+		s.keys = make([][]byte, n)
+	}
+	s.keys = s.keys[0:n]
+}
+
+func (s *sorter) sort(src swapper) {
+	s.src = src
+	sort.Sort(s)
+}
+
+func (s sorter) Len() int {
+	return len(s.keys)
+}
+
+func (s sorter) Less(i, j int) bool {
+	return bytes.Compare(s.keys[i], s.keys[j]) == -1
+}
+
+func (s sorter) Swap(i, j int) {
+	s.keys[i], s.keys[j] = s.keys[j], s.keys[i]
+	s.src.Swap(i, j)
+}
+
+// A Lister can be sorted by Collator's Sort method.
+type Lister interface {
+	Len() int
+	Swap(i, j int)
+	// Bytes returns the bytes of the text at index i.
+	Bytes(i int) []byte
+}
+
+// Sort uses sort.Sort to sort the strings represented by x using the rules of c.
+func (c *Collator) Sort(x Lister) {
+	n := x.Len()
+	c.sorter.init(n)
+	for i := 0; i < n; i++ {
+		c.sorter.keys[i] = c.Key(c.sorter.buf, x.Bytes(i))
+	}
+	c.sorter.sort(x)
+}
+
+// SortStrings uses sort.Sort to sort the strings in x using the rules of c.
+func (c *Collator) SortStrings(x []string) {
+	c.sorter.init(len(x))
+	for i, s := range x {
+		c.sorter.keys[i] = c.KeyFromString(c.sorter.buf, s)
+	}
+	c.sorter.sort(sort.StringSlice(x))
+}

vendor/golang.org/x/text/internal/colltab/collelem.go

@@ -0,0 +1,371 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package colltab
+
+import (
+	"fmt"
+	"unicode"
+)
+
+// Level identifies the collation comparison level.
+// The primary level corresponds to the basic sorting of text.
+// The secondary level corresponds to accents and related linguistic elements.
+// The tertiary level corresponds to casing and related concepts.
+// The quaternary level is derived from the other levels by the
+// various algorithms for handling variable elements.
+type Level int
+
+const (
+	Primary Level = iota
+	Secondary
+	Tertiary
+	Quaternary
+	Identity
+
+	NumLevels
+)
+
+const (
+	defaultSecondary = 0x20
+	defaultTertiary  = 0x2
+	maxTertiary      = 0x1F
+	MaxQuaternary    = 0x1FFFFF // 21 bits.
+)
+
+// Elem is a representation of a collation element. This API provides ways to encode
+// and decode Elems. Implementations of collation tables may use values greater
+// or equal to PrivateUse for their own purposes.  However, these should never be
+// returned by AppendNext.
+type Elem uint32
+
+const (
+	maxCE       Elem = 0xAFFFFFFF
+	PrivateUse       = minContract
+	minContract      = 0xC0000000
+	maxContract      = 0xDFFFFFFF
+	minExpand        = 0xE0000000
+	maxExpand        = 0xEFFFFFFF
+	minDecomp        = 0xF0000000
+)
+
+type ceType int
+
+const (
+	ceNormal           ceType = iota // ceNormal includes implicits (ce == 0)
+	ceContractionIndex               // rune can be a start of a contraction
+	ceExpansionIndex                 // rune expands into a sequence of collation elements
+	ceDecompose                      // rune expands using NFKC decomposition
+)
+
+func (ce Elem) ctype() ceType {
+	if ce <= maxCE {
+		return ceNormal
+	}
+	if ce <= maxContract {
+		return ceContractionIndex
+	} else {
+		if ce <= maxExpand {
+			return ceExpansionIndex
+		}
+		return ceDecompose
+	}
+	panic("should not reach here")
+	return ceType(-1)
+}
+
+// For normal collation elements, we assume that a collation element either has
+// a primary or non-default secondary value, not both.
+// Collation elements with a primary value are of the form
+// 01pppppp pppppppp ppppppp0 ssssssss
+//   - p* is primary collation value
+//   - s* is the secondary collation value
+// 00pppppp pppppppp ppppppps sssttttt, where
+//   - p* is primary collation value
+//   - s* offset of secondary from default value.
+//   - t* is the tertiary collation value
+// 100ttttt cccccccc pppppppp pppppppp
+//   - t* is the tertiar collation value
+//   - c* is the canonical combining class
+//   - p* is the primary collation value
+// Collation elements with a secondary value are of the form
+// 1010cccc ccccssss ssssssss tttttttt, where
+//   - c* is the canonical combining class
+//   - s* is the secondary collation value
+//   - t* is the tertiary collation value
+// 11qqqqqq qqqqqqqq qqqqqqq0 00000000
+//   - q* quaternary value
+const (
+	ceTypeMask              = 0xC0000000
+	ceTypeMaskExt           = 0xE0000000
+	ceIgnoreMask            = 0xF00FFFFF
+	ceType1                 = 0x40000000
+	ceType2                 = 0x00000000
+	ceType3or4              = 0x80000000
+	ceType4                 = 0xA0000000
+	ceTypeQ                 = 0xC0000000
+	Ignore                  = ceType4
+	firstNonPrimary         = 0x80000000
+	lastSpecialPrimary      = 0xA0000000
+	secondaryMask           = 0x80000000
+	hasTertiaryMask         = 0x40000000
+	primaryValueMask        = 0x3FFFFE00
+	maxPrimaryBits          = 21
+	compactPrimaryBits      = 16
+	maxSecondaryBits        = 12
+	maxTertiaryBits         = 8
+	maxCCCBits              = 8
+	maxSecondaryCompactBits = 8
+	maxSecondaryDiffBits    = 4
+	maxTertiaryCompactBits  = 5
+	primaryShift            = 9
+	compactSecondaryShift   = 5
+	minCompactSecondary     = defaultSecondary - 4
+)
+
+func makeImplicitCE(primary int) Elem {
+	return ceType1 | Elem(primary<<primaryShift) | defaultSecondary
+}
+
+// MakeElem returns an Elem for the given values.  It will return an error
+// if the given combination of values is invalid.
+func MakeElem(primary, secondary, tertiary int, ccc uint8) (Elem, error) {
+	if w := primary; w >= 1<<maxPrimaryBits || w < 0 {
+		return 0, fmt.Errorf("makeCE: primary weight out of bounds: %x >= %x", w, 1<<maxPrimaryBits)
+	}
+	if w := secondary; w >= 1<<maxSecondaryBits || w < 0 {
+		return 0, fmt.Errorf("makeCE: secondary weight out of bounds: %x >= %x", w, 1<<maxSecondaryBits)
+	}
+	if w := tertiary; w >= 1<<maxTertiaryBits || w < 0 {
+		return 0, fmt.Errorf("makeCE: tertiary weight out of bounds: %x >= %x", w, 1<<maxTertiaryBits)
+	}
+	ce := Elem(0)
+	if primary != 0 {
+		if ccc != 0 {
+			if primary >= 1<<compactPrimaryBits {
+				return 0, fmt.Errorf("makeCE: primary weight with non-zero CCC out of bounds: %x >= %x", primary, 1<<compactPrimaryBits)
+			}
+			if secondary != defaultSecondary {
+				return 0, fmt.Errorf("makeCE: cannot combine non-default secondary value (%x) with non-zero CCC (%x)", secondary, ccc)
+			}
+			ce = Elem(tertiary << (compactPrimaryBits + maxCCCBits))
+			ce |= Elem(ccc) << compactPrimaryBits
+			ce |= Elem(primary)
+			ce |= ceType3or4
+		} else if tertiary == defaultTertiary {
+			if secondary >= 1<<maxSecondaryCompactBits {
+				return 0, fmt.Errorf("makeCE: secondary weight with non-zero primary out of bounds: %x >= %x", secondary, 1<<maxSecondaryCompactBits)
+			}
+			ce = Elem(primary<<(maxSecondaryCompactBits+1) + secondary)
+			ce |= ceType1
+		} else {
+			d := secondary - defaultSecondary + maxSecondaryDiffBits
+			if d >= 1<<maxSecondaryDiffBits || d < 0 {
+				return 0, fmt.Errorf("makeCE: secondary weight diff out of bounds: %x < 0 || %x > %x", d, d, 1<<maxSecondaryDiffBits)
+			}
+			if tertiary >= 1<<maxTertiaryCompactBits {
+				return 0, fmt.Errorf("makeCE: tertiary weight with non-zero primary out of bounds: %x > %x", tertiary, 1<<maxTertiaryCompactBits)
+			}
+			ce = Elem(primary<<maxSecondaryDiffBits + d)
+			ce = ce<<maxTertiaryCompactBits + Elem(tertiary)
+		}
+	} else {
+		ce = Elem(secondary<<maxTertiaryBits + tertiary)
+		ce += Elem(ccc) << (maxSecondaryBits + maxTertiaryBits)
+		ce |= ceType4
+	}
+	return ce, nil
+}
+
+// MakeQuaternary returns an Elem with the given quaternary value.
+func MakeQuaternary(v int) Elem {
+	return ceTypeQ | Elem(v<<primaryShift)
+}
+
+// Mask sets weights for any level smaller than l to 0.
+// The resulting Elem can be used to test for equality with
+// other Elems to which the same mask has been applied.
+func (ce Elem) Mask(l Level) uint32 {
+	return 0
+}
+
+// CCC returns the canonical combining class associated with the underlying character,
+// if applicable, or 0 otherwise.
+func (ce Elem) CCC() uint8 {
+	if ce&ceType3or4 != 0 {
+		if ce&ceType4 == ceType3or4 {
+			return uint8(ce >> 16)
+		}
+		return uint8(ce >> 20)
+	}
+	return 0
+}
+
+// Primary returns the primary collation weight for ce.
+func (ce Elem) Primary() int {
+	if ce >= firstNonPrimary {
+		if ce > lastSpecialPrimary {
+			return 0
+		}
+		return int(uint16(ce))
+	}
+	return int(ce&primaryValueMask) >> primaryShift
+}
+
+// Secondary returns the secondary collation weight for ce.
+func (ce Elem) Secondary() int {
+	switch ce & ceTypeMask {
+	case ceType1:
+		return int(uint8(ce))
+	case ceType2:
+		return minCompactSecondary + int((ce>>compactSecondaryShift)&0xF)
+	case ceType3or4:
+		if ce < ceType4 {
+			return defaultSecondary
+		}
+		return int(ce>>8) & 0xFFF
+	case ceTypeQ:
+		return 0
+	}
+	panic("should not reach here")
+}
+
+// Tertiary returns the tertiary collation weight for ce.
+func (ce Elem) Tertiary() uint8 {
+	if ce&hasTertiaryMask == 0 {
+		if ce&ceType3or4 == 0 {
+			return uint8(ce & 0x1F)
+		}
+		if ce&ceType4 == ceType4 {
+			return uint8(ce)
+		}
+		return uint8(ce>>24) & 0x1F // type 2
+	} else if ce&ceTypeMask == ceType1 {
+		return defaultTertiary
+	}
+	// ce is a quaternary value.
+	return 0
+}
+
+func (ce Elem) updateTertiary(t uint8) Elem {
+	if ce&ceTypeMask == ceType1 {
+		// convert to type 4
+		nce := ce & primaryValueMask
+		nce |= Elem(uint8(ce)-minCompactSecondary) << compactSecondaryShift
+		ce = nce
+	} else if ce&ceTypeMaskExt == ceType3or4 {
+		ce &= ^Elem(maxTertiary << 24)
+		return ce | (Elem(t) << 24)
+	} else {
+		// type 2 or 4
+		ce &= ^Elem(maxTertiary)
+	}
+	return ce | Elem(t)
+}
+
+// Quaternary returns the quaternary value if explicitly specified,
+// 0 if ce == Ignore, or MaxQuaternary otherwise.
+// Quaternary values are used only for shifted variants.
+func (ce Elem) Quaternary() int {
+	if ce&ceTypeMask == ceTypeQ {
+		return int(ce&primaryValueMask) >> primaryShift
+	} else if ce&ceIgnoreMask == Ignore {
+		return 0
+	}
+	return MaxQuaternary
+}
+
+// Weight returns the collation weight for the given level.
+func (ce Elem) Weight(l Level) int {
+	switch l {
+	case Primary:
+		return ce.Primary()
+	case Secondary:
+		return ce.Secondary()
+	case Tertiary:
+		return int(ce.Tertiary())
+	case Quaternary:
+		return ce.Quaternary()
+	}
+	return 0 // return 0 (ignore) for undefined levels.
+}
+
+// For contractions, collation elements are of the form
+// 110bbbbb bbbbbbbb iiiiiiii iiiinnnn, where
+//   - n* is the size of the first node in the contraction trie.
+//   - i* is the index of the first node in the contraction trie.
+//   - b* is the offset into the contraction collation element table.
+// See contract.go for details on the contraction trie.
+const (
+	maxNBits              = 4
+	maxTrieIndexBits      = 12
+	maxContractOffsetBits = 13
+)
+
+func splitContractIndex(ce Elem) (index, n, offset int) {
+	n = int(ce & (1<<maxNBits - 1))
+	ce >>= maxNBits
+	index = int(ce & (1<<maxTrieIndexBits - 1))
+	ce >>= maxTrieIndexBits
+	offset = int(ce & (1<<maxContractOffsetBits - 1))
+	return
+}
+
+// For expansions, Elems are of the form 11100000 00000000 bbbbbbbb bbbbbbbb,
+// where b* is the index into the expansion sequence table.
+const maxExpandIndexBits = 16
+
+func splitExpandIndex(ce Elem) (index int) {
+	return int(uint16(ce))
+}
+
+// Some runes can be expanded using NFKD decomposition. Instead of storing the full
+// sequence of collation elements, we decompose the rune and lookup the collation
+// elements for each rune in the decomposition and modify the tertiary weights.
+// The Elem, in this case, is of the form 11110000 00000000 wwwwwwww vvvvvvvv, where
+//   - v* is the replacement tertiary weight for the first rune,
+//   - w* is the replacement tertiary weight for the second rune,
+// Tertiary weights of subsequent runes should be replaced with maxTertiary.
+// See http://www.unicode.org/reports/tr10/#Compatibility_Decompositions for more details.
+func splitDecompose(ce Elem) (t1, t2 uint8) {
+	return uint8(ce), uint8(ce >> 8)
+}
+
+const (
+	// These constants were taken from http://www.unicode.org/versions/Unicode6.0.0/ch12.pdf.
+	minUnified       rune = 0x4E00
+	maxUnified            = 0x9FFF
+	minCompatibility      = 0xF900
+	maxCompatibility      = 0xFAFF
+	minRare               = 0x3400
+	maxRare               = 0x4DBF
+)
+const (
+	commonUnifiedOffset = 0x10000
+	rareUnifiedOffset   = 0x20000 // largest rune in common is U+FAFF
+	otherOffset         = 0x50000 // largest rune in rare is U+2FA1D
+	illegalOffset       = otherOffset + int(unicode.MaxRune)
+	maxPrimary          = illegalOffset + 1
+)
+
+// implicitPrimary returns the primary weight for the a rune
+// for which there is no entry for the rune in the collation table.
+// We take a different approach from the one specified in
+// http://unicode.org/reports/tr10/#Implicit_Weights,
+// but preserve the resulting relative ordering of the runes.
+func implicitPrimary(r rune) int {
+	if unicode.Is(unicode.Ideographic, r) {
+		if r >= minUnified && r <= maxUnified {
+			// The most common case for CJK.
+			return int(r) + commonUnifiedOffset
+		}
+		if r >= minCompatibility && r <= maxCompatibility {
+			// This will typically not hit. The DUCET explicitly specifies mappings
+			// for all characters that do not decompose.
+			return int(r) + commonUnifiedOffset
+		}
+		return int(r) + rareUnifiedOffset
+	}
+	return int(r) + otherOffset
+}

vendor/golang.org/x/text/internal/colltab/colltab.go

@@ -0,0 +1,105 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package colltab contains functionality related to collation tables.
+// It is only to be used by the collate and search packages.
+package colltab // import "golang.org/x/text/internal/colltab"
+
+import (
+	"sort"
+
+	"golang.org/x/text/language"
+)
+
+// MatchLang finds the index of t in tags, using a matching algorithm used for
+// collation and search. tags[0] must be language.Und, the remaining tags should
+// be sorted alphabetically.
+//
+// Language matching for collation and search is different from the matching
+// defined by language.Matcher: the (inferred) base language must be an exact
+// match for the relevant fields. For example, "gsw" should not match "de".
+// Also the parent relation is different, as a parent may have a different
+// script. So usually the parent of zh-Hant is und, whereas for MatchLang it is
+// zh.
+func MatchLang(t language.Tag, tags []language.Tag) int {
+	// Canonicalize the values, including collapsing macro languages.
+	t, _ = language.All.Canonicalize(t)
+
+	base, conf := t.Base()
+	// Estimate the base language, but only use high-confidence values.
+	if conf < language.High {
+		// The root locale supports "search" and "standard". We assume that any
+		// implementation will only use one of both.
+		return 0
+	}
+
+	// Maximize base and script and normalize the tag.
+	if _, s, r := t.Raw(); (r != language.Region{}) {
+		p, _ := language.Raw.Compose(base, s, r)
+		// Taking the parent forces the script to be maximized.
+		p = p.Parent()
+		// Add back region and extensions.
+		t, _ = language.Raw.Compose(p, r, t.Extensions())
+	} else {
+		// Set the maximized base language.
+		t, _ = language.Raw.Compose(base, s, t.Extensions())
+	}
+
+	// Find start index of the language tag.
+	start := 1 + sort.Search(len(tags)-1, func(i int) bool {
+		b, _, _ := tags[i+1].Raw()
+		return base.String() <= b.String()
+	})
+	if start < len(tags) {
+		if b, _, _ := tags[start].Raw(); b != base {
+			return 0
+		}
+	}
+
+	// Besides the base language, script and region, only the collation type and
+	// the custom variant defined in the 'u' extension are used to distinguish a
+	// locale.
+	// Strip all variants and extensions and add back the custom variant.
+	tdef, _ := language.Raw.Compose(t.Raw())
+	tdef, _ = tdef.SetTypeForKey("va", t.TypeForKey("va"))
+
+	// First search for a specialized collation type, if present.
+	try := []language.Tag{tdef}
+	if co := t.TypeForKey("co"); co != "" {
+		tco, _ := tdef.SetTypeForKey("co", co)
+		try = []language.Tag{tco, tdef}
+	}
+
+	for _, tx := range try {
+		for ; tx != language.Und; tx = parent(tx) {
+			for i, t := range tags[start:] {
+				if b, _, _ := t.Raw(); b != base {
+					break
+				}
+				if tx == t {
+					return start + i
+				}
+			}
+		}
+	}
+	return 0
+}
+
+// parent computes the structural parent. This means inheritance may change
+// script. So, unlike the CLDR parent, parent(zh-Hant) == zh.
+func parent(t language.Tag) language.Tag {
+	if t.TypeForKey("va") != "" {
+		t, _ = t.SetTypeForKey("va", "")
+		return t
+	}
+	result := language.Und
+	if b, s, r := t.Raw(); (r != language.Region{}) {
+		result, _ = language.Raw.Compose(b, s, t.Extensions())
+	} else if (s != language.Script{}) {
+		result, _ = language.Raw.Compose(b, t.Extensions())
+	} else if (b != language.Base{}) {
+		result, _ = language.Raw.Compose(t.Extensions())
+	}
+	return result
+}

vendor/golang.org/x/text/internal/colltab/contract.go

@@ -0,0 +1,145 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package colltab
+
+import "unicode/utf8"
+
+// For a description of ContractTrieSet, see text/collate/build/contract.go.
+
+type ContractTrieSet []struct{ L, H, N, I uint8 }
+
+// ctScanner is used to match a trie to an input sequence.
+// A contraction may match a non-contiguous sequence of bytes in an input string.
+// For example, if there is a contraction for <a, combining_ring>, it should match
+// the sequence <a, combining_cedilla, combining_ring>, as combining_cedilla does
+// not block combining_ring.
+// ctScanner does not automatically skip over non-blocking non-starters, but rather
+// retains the state of the last match and leaves it up to the user to continue
+// the match at the appropriate points.
+type ctScanner struct {
+	states ContractTrieSet
+	s      []byte
+	n      int
+	index  int
+	pindex int
+	done   bool
+}
+
+type ctScannerString struct {
+	states ContractTrieSet
+	s      string
+	n      int
+	index  int
+	pindex int
+	done   bool
+}
+
+func (t ContractTrieSet) scanner(index, n int, b []byte) ctScanner {
+	return ctScanner{s: b, states: t[index:], n: n}
+}
+
+func (t ContractTrieSet) scannerString(index, n int, str string) ctScannerString {
+	return ctScannerString{s: str, states: t[index:], n: n}
+}
+
+// result returns the offset i and bytes consumed p so far.  If no suffix
+// matched, i and p will be 0.
+func (s *ctScanner) result() (i, p int) {
+	return s.index, s.pindex
+}
+
+func (s *ctScannerString) result() (i, p int) {
+	return s.index, s.pindex
+}
+
+const (
+	final   = 0
+	noIndex = 0xFF
+)
+
+// scan matches the longest suffix at the current location in the input
+// and returns the number of bytes consumed.
+func (s *ctScanner) scan(p int) int {
+	pr := p // the p at the rune start
+	str := s.s
+	states, n := s.states, s.n
+	for i := 0; i < n && p < len(str); {
+		e := states[i]
+		c := str[p]
+		// TODO: a significant number of contractions are of a form that
+		// cannot match discontiguous UTF-8 in a normalized string. We could let
+		// a negative value of e.n mean that we can set s.done = true and avoid
+		// the need for additional matches.
+		if c >= e.L {
+			if e.L == c {
+				p++
+				if e.I != noIndex {
+					s.index = int(e.I)
+					s.pindex = p
+				}
+				if e.N != final {
+					i, states, n = 0, states[int(e.H)+n:], int(e.N)
+					if p >= len(str) || utf8.RuneStart(str[p]) {
+						s.states, s.n, pr = states, n, p
+					}
+				} else {
+					s.done = true
+					return p
+				}
+				continue
+			} else if e.N == final && c <= e.H {
+				p++
+				s.done = true
+				s.index = int(c-e.L) + int(e.I)
+				s.pindex = p
+				return p
+			}
+		}
+		i++
+	}
+	return pr
+}
+
+// scan is a verbatim copy of ctScanner.scan.
+func (s *ctScannerString) scan(p int) int {
+	pr := p // the p at the rune start
+	str := s.s
+	states, n := s.states, s.n
+	for i := 0; i < n && p < len(str); {
+		e := states[i]
+		c := str[p]
+		// TODO: a significant number of contractions are of a form that
+		// cannot match discontiguous UTF-8 in a normalized string. We could let
+		// a negative value of e.n mean that we can set s.done = true and avoid
+		// the need for additional matches.
+		if c >= e.L {
+			if e.L == c {
+				p++
+				if e.I != noIndex {
+					s.index = int(e.I)
+					s.pindex = p
+				}
+				if e.N != final {
+					i, states, n = 0, states[int(e.H)+n:], int(e.N)
+					if p >= len(str) || utf8.RuneStart(str[p]) {
+						s.states, s.n, pr = states, n, p
+					}
+				} else {
+					s.done = true
+					return p
+				}
+				continue
+			} else if e.N == final && c <= e.H {
+				p++
+				s.done = true
+				s.index = int(c-e.L) + int(e.I)
+				s.pindex = p
+				return p
+			}
+		}
+		i++
+	}
+	return pr
+}

vendor/golang.org/x/text/internal/colltab/iter.go

@@ -0,0 +1,178 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package colltab
+
+// An Iter incrementally converts chunks of the input text to collation
+// elements, while ensuring that the collation elements are in normalized order
+// (that is, they are in the order as if the input text were normalized first).
+type Iter struct {
+	Weighter Weighter
+	Elems    []Elem
+	// N is the number of elements in Elems that will not be reordered on
+	// subsequent iterations, N <= len(Elems).
+	N int
+
+	bytes []byte
+	str   string
+	// Because the Elems buffer may contain collation elements that are needed
+	// for look-ahead, we need two positions in the text (bytes or str): one for
+	// the end position in the text for the current iteration and one for the
+	// start of the next call to appendNext.
+	pEnd  int // end position in text corresponding to N.
+	pNext int // pEnd <= pNext.
+}
+
+// Reset sets the position in the current input text to p and discards any
+// results obtained so far.
+func (i *Iter) Reset(p int) {
+	i.Elems = i.Elems[:0]
+	i.N = 0
+	i.pEnd = p
+	i.pNext = p
+}
+
+// Len returns the length of the input text.
+func (i *Iter) Len() int {
+	if i.bytes != nil {
+		return len(i.bytes)
+	}
+	return len(i.str)
+}
+
+// Discard removes the collation elements up to N.
+func (i *Iter) Discard() {
+	// TODO: change this such that only modifiers following starters will have
+	// to be copied.
+	i.Elems = i.Elems[:copy(i.Elems, i.Elems[i.N:])]
+	i.N = 0
+}
+
+// End returns the end position of the input text for which Next has returned
+// results.
+func (i *Iter) End() int {
+	return i.pEnd
+}
+
+// SetInput resets i to input s.
+func (i *Iter) SetInput(s []byte) {
+	i.bytes = s
+	i.str = ""
+	i.Reset(0)
+}
+
+// SetInputString resets i to input s.
+func (i *Iter) SetInputString(s string) {
+	i.str = s
+	i.bytes = nil
+	i.Reset(0)
+}
+
+func (i *Iter) done() bool {
+	return i.pNext >= len(i.str) && i.pNext >= len(i.bytes)
+}
+
+func (i *Iter) appendNext() bool {
+	if i.done() {
+		return false
+	}
+	var sz int
+	if i.bytes == nil {
+		i.Elems, sz = i.Weighter.AppendNextString(i.Elems, i.str[i.pNext:])
+	} else {
+		i.Elems, sz = i.Weighter.AppendNext(i.Elems, i.bytes[i.pNext:])
+	}
+	if sz == 0 {
+		sz = 1
+	}
+	i.pNext += sz
+	return true
+}
+
+// Next appends Elems to the internal array. On each iteration, it will either
+// add starters or modifiers. In the majority of cases, an Elem with a primary
+// value > 0 will have a CCC of 0. The CCC values of collation elements are also
+// used to detect if the input string was not normalized and to adjust the
+// result accordingly.
+func (i *Iter) Next() bool {
+	if i.N == len(i.Elems) && !i.appendNext() {
+		return false
+	}
+
+	// Check if the current segment starts with a starter.
+	prevCCC := i.Elems[len(i.Elems)-1].CCC()
+	if prevCCC == 0 {
+		i.N = len(i.Elems)
+		i.pEnd = i.pNext
+		return true
+	} else if i.Elems[i.N].CCC() == 0 {
+		// set i.N to only cover part of i.Elems for which prevCCC == 0 and
+		// use rest for the next call to next.
+		for i.N++; i.N < len(i.Elems) && i.Elems[i.N].CCC() == 0; i.N++ {
+		}
+		i.pEnd = i.pNext
+		return true
+	}
+
+	// The current (partial) segment starts with modifiers. We need to collect
+	// all successive modifiers to ensure that they are normalized.
+	for {
+		p := len(i.Elems)
+		i.pEnd = i.pNext
+		if !i.appendNext() {
+			break
+		}
+
+		if ccc := i.Elems[p].CCC(); ccc == 0 || len(i.Elems)-i.N > maxCombiningCharacters {
+			// Leave the starter for the next iteration. This ensures that we
+			// do not return sequences of collation elements that cross two
+			// segments.
+			//
+			// TODO: handle large number of combining characters by fully
+			// normalizing the input segment before iteration. This ensures
+			// results are consistent across the text repo.
+			i.N = p
+			return true
+		} else if ccc < prevCCC {
+			i.doNorm(p, ccc) // should be rare, never occurs for NFD and FCC.
+		} else {
+			prevCCC = ccc
+		}
+	}
+
+	done := len(i.Elems) != i.N
+	i.N = len(i.Elems)
+	return done
+}
+
+// nextNoNorm is the same as next, but does not "normalize" the collation
+// elements.
+func (i *Iter) nextNoNorm() bool {
+	// TODO: remove this function. Using this instead of next does not seem
+	// to improve performance in any significant way. We retain this until
+	// later for evaluation purposes.
+	if i.done() {
+		return false
+	}
+	i.appendNext()
+	i.N = len(i.Elems)
+	return true
+}
+
+const maxCombiningCharacters = 30
+
+// doNorm reorders the collation elements in i.Elems.
+// It assumes that blocks of collation elements added with appendNext
+// either start and end with the same CCC or start with CCC == 0.
+// This allows for a single insertion point for the entire block.
+// The correctness of this assumption is verified in builder.go.
+func (i *Iter) doNorm(p int, ccc uint8) {
+	n := len(i.Elems)
+	k := p
+	for p--; p > i.N && ccc < i.Elems[p-1].CCC(); p-- {
+	}
+	i.Elems = append(i.Elems, i.Elems[p:k]...)
+	copy(i.Elems[p:], i.Elems[k:])
+	i.Elems = i.Elems[:n]
+}

vendor/golang.org/x/text/internal/colltab/numeric.go

@@ -0,0 +1,236 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package colltab
+
+import (
+	"unicode"
+	"unicode/utf8"
+)
+
+// NewNumericWeighter wraps w to replace individual digits to sort based on their
+// numeric value.
+//
+// Weighter w must have a free primary weight after the primary weight for 9.
+// If this is not the case, numeric value will sort at the same primary level
+// as the first primary sorting after 9.
+func NewNumericWeighter(w Weighter) Weighter {
+	getElem := func(s string) Elem {
+		elems, _ := w.AppendNextString(nil, s)
+		return elems[0]
+	}
+	nine := getElem("9")
+
+	// Numbers should order before zero, but the DUCET has no room for this.
+	// TODO: move before zero once we use fractional collation elements.
+	ns, _ := MakeElem(nine.Primary()+1, nine.Secondary(), int(nine.Tertiary()), 0)
+
+	return &numericWeighter{
+		Weighter: w,
+
+		// We assume that w sorts digits of different kinds in order of numeric
+		// value and that the tertiary weight order is preserved.
+		//
+		// TODO: evaluate whether it is worth basing the ranges on the Elem
+		// encoding itself once the move to fractional weights is complete.
+		zero:          getElem("0"),
+		zeroSpecialLo: getElem("０"), // U+FF10 FULLWIDTH DIGIT ZERO
+		zeroSpecialHi: getElem("₀"), // U+2080 SUBSCRIPT ZERO
+		nine:          nine,
+		nineSpecialHi: getElem("₉"), // U+2089 SUBSCRIPT NINE
+		numberStart:   ns,
+	}
+}
+
+// A numericWeighter translates a stream of digits into a stream of weights
+// representing the numeric value.
+type numericWeighter struct {
+	Weighter
+
+	// The Elems below all demarcate boundaries of specific ranges. With the
+	// current element encoding digits are in two ranges: normal (default
+	// tertiary value) and special. For most languages, digits have collation
+	// elements in the normal range.
+	//
+	// Note: the range tests are very specific for the element encoding used by
+	// this implementation. The tests in collate_test.go are designed to fail
+	// if this code is not updated when an encoding has changed.
+
+	zero          Elem // normal digit zero
+	zeroSpecialLo Elem // special digit zero, low tertiary value
+	zeroSpecialHi Elem // special digit zero, high tertiary value
+	nine          Elem // normal digit nine
+	nineSpecialHi Elem // special digit nine
+	numberStart   Elem
+}
+
+// AppendNext calls the namesake of the underlying weigher, but replaces single
+// digits with weights representing their value.
+func (nw *numericWeighter) AppendNext(buf []Elem, s []byte) (ce []Elem, n int) {
+	ce, n = nw.Weighter.AppendNext(buf, s)
+	nc := numberConverter{
+		elems: buf,
+		w:     nw,
+		b:     s,
+	}
+	isZero, ok := nc.checkNextDigit(ce)
+	if !ok {
+		return ce, n
+	}
+	// ce might have been grown already, so take it instead of buf.
+	nc.init(ce, len(buf), isZero)
+	for n < len(s) {
+		ce, sz := nw.Weighter.AppendNext(nc.elems, s[n:])
+		nc.b = s
+		n += sz
+		if !nc.update(ce) {
+			break
+		}
+	}
+	return nc.result(), n
+}
+
+// AppendNextString calls the namesake of the underlying weigher, but replaces
+// single digits with weights representing their value.
+func (nw *numericWeighter) AppendNextString(buf []Elem, s string) (ce []Elem, n int) {
+	ce, n = nw.Weighter.AppendNextString(buf, s)
+	nc := numberConverter{
+		elems: buf,
+		w:     nw,
+		s:     s,
+	}
+	isZero, ok := nc.checkNextDigit(ce)
+	if !ok {
+		return ce, n
+	}
+	nc.init(ce, len(buf), isZero)
+	for n < len(s) {
+		ce, sz := nw.Weighter.AppendNextString(nc.elems, s[n:])
+		nc.s = s
+		n += sz
+		if !nc.update(ce) {
+			break
+		}
+	}
+	return nc.result(), n
+}
+
+type numberConverter struct {
+	w *numericWeighter
+
+	elems    []Elem
+	nDigits  int
+	lenIndex int
+
+	s string // set if the input was of type string
+	b []byte // set if the input was of type []byte
+}
+
+// init completes initialization of a numberConverter and prepares it for adding
+// more digits. elems is assumed to have a digit starting at oldLen.
+func (nc *numberConverter) init(elems []Elem, oldLen int, isZero bool) {
+	// Insert a marker indicating the start of a number and and a placeholder
+	// for the number of digits.
+	if isZero {
+		elems = append(elems[:oldLen], nc.w.numberStart, 0)
+	} else {
+		elems = append(elems, 0, 0)
+		copy(elems[oldLen+2:], elems[oldLen:])
+		elems[oldLen] = nc.w.numberStart
+		elems[oldLen+1] = 0
+
+		nc.nDigits = 1
+	}
+	nc.elems = elems
+	nc.lenIndex = oldLen + 1
+}
+
+// checkNextDigit reports whether bufNew adds a single digit relative to the old
+// buffer. If it does, it also reports whether this digit is zero.
+func (nc *numberConverter) checkNextDigit(bufNew []Elem) (isZero, ok bool) {
+	if len(nc.elems) >= len(bufNew) {
+		return false, false
+	}
+	e := bufNew[len(nc.elems)]
+	if e < nc.w.zeroSpecialLo || nc.w.nine < e {
+		// Not a number.
+		return false, false
+	}
+	if e < nc.w.zero {
+		if e > nc.w.nineSpecialHi {
+			// Not a number.
+			return false, false
+		}
+		if !nc.isDigit() {
+			return false, false
+		}
+		isZero = e <= nc.w.zeroSpecialHi
+	} else {
+		// This is the common case if we encounter a digit.
+		isZero = e == nc.w.zero
+	}
+	// Test the remaining added collation elements have a zero primary value.
+	if n := len(bufNew) - len(nc.elems); n > 1 {
+		for i := len(nc.elems) + 1; i < len(bufNew); i++ {
+			if bufNew[i].Primary() != 0 {
+				return false, false
+			}
+		}
+		// In some rare cases, collation elements will encode runes in
+		// unicode.No as a digit. For example Ethiopic digits (U+1369 - U+1371)
+		// are not in Nd. Also some digits that clearly belong in unicode.No,
+		// like U+0C78 TELUGU FRACTION DIGIT ZERO FOR ODD POWERS OF FOUR, have
+		// collation elements indistinguishable from normal digits.
+		// Unfortunately, this means we need to make this check for nearly all
+		// non-Latin digits.
+		//
+		// TODO: check the performance impact and find something better if it is
+		// an issue.
+		if !nc.isDigit() {
+			return false, false
+		}
+	}
+	return isZero, true
+}
+
+func (nc *numberConverter) isDigit() bool {
+	if nc.b != nil {
+		r, _ := utf8.DecodeRune(nc.b)
+		return unicode.In(r, unicode.Nd)
+	}
+	r, _ := utf8.DecodeRuneInString(nc.s)
+	return unicode.In(r, unicode.Nd)
+}
+
+// We currently support a maximum of about 2M digits (the number of primary
+// values). Such numbers will compare correctly against small numbers, but their
+// comparison against other large numbers is undefined.
+//
+// TODO: define a proper fallback, such as comparing large numbers textually or
+// actually allowing numbers of unlimited length.
+//
+// TODO: cap this to a lower number (like 100) and maybe allow a larger number
+// in an option?
+const maxDigits = 1<<maxPrimaryBits - 1
+
+func (nc *numberConverter) update(elems []Elem) bool {
+	isZero, ok := nc.checkNextDigit(elems)
+	if nc.nDigits == 0 && isZero {
+		return true
+	}
+	nc.elems = elems
+	if !ok {
+		return false
+	}
+	nc.nDigits++
+	return nc.nDigits < maxDigits
+}
+
+// result fills in the length element for the digit sequence and returns the
+// completed collation elements.
+func (nc *numberConverter) result() []Elem {
+	e, _ := MakeElem(nc.nDigits, defaultSecondary, defaultTertiary, 0)
+	nc.elems[nc.lenIndex] = e
+	return nc.elems
+}

vendor/golang.org/x/text/internal/colltab/table.go

@@ -0,0 +1,275 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package colltab
+
+import (
+	"unicode/utf8"
+
+	"golang.org/x/text/unicode/norm"
+)
+
+// Table holds all collation data for a given collation ordering.
+type Table struct {
+	Index Trie // main trie
+
+	// expansion info
+	ExpandElem []uint32
+
+	// contraction info
+	ContractTries  ContractTrieSet
+	ContractElem   []uint32
+	MaxContractLen int
+	VariableTop    uint32
+}
+
+func (t *Table) AppendNext(w []Elem, b []byte) (res []Elem, n int) {
+	return t.appendNext(w, source{bytes: b})
+}
+
+func (t *Table) AppendNextString(w []Elem, s string) (res []Elem, n int) {
+	return t.appendNext(w, source{str: s})
+}
+
+func (t *Table) Start(p int, b []byte) int {
+	// TODO: implement
+	panic("not implemented")
+}
+
+func (t *Table) StartString(p int, s string) int {
+	// TODO: implement
+	panic("not implemented")
+}
+
+func (t *Table) Domain() []string {
+	// TODO: implement
+	panic("not implemented")
+}
+
+func (t *Table) Top() uint32 {
+	return t.VariableTop
+}
+
+type source struct {
+	str   string
+	bytes []byte
+}
+
+func (src *source) lookup(t *Table) (ce Elem, sz int) {
+	if src.bytes == nil {
+		return t.Index.lookupString(src.str)
+	}
+	return t.Index.lookup(src.bytes)
+}
+
+func (src *source) tail(sz int) {
+	if src.bytes == nil {
+		src.str = src.str[sz:]
+	} else {
+		src.bytes = src.bytes[sz:]
+	}
+}
+
+func (src *source) nfd(buf []byte, end int) []byte {
+	if src.bytes == nil {
+		return norm.NFD.AppendString(buf[:0], src.str[:end])
+	}
+	return norm.NFD.Append(buf[:0], src.bytes[:end]...)
+}
+
+func (src *source) rune() (r rune, sz int) {
+	if src.bytes == nil {
+		return utf8.DecodeRuneInString(src.str)
+	}
+	return utf8.DecodeRune(src.bytes)
+}
+
+func (src *source) properties(f norm.Form) norm.Properties {
+	if src.bytes == nil {
+		return f.PropertiesString(src.str)
+	}
+	return f.Properties(src.bytes)
+}
+
+// appendNext appends the weights corresponding to the next rune or
+// contraction in s.  If a contraction is matched to a discontinuous
+// sequence of runes, the weights for the interstitial runes are
+// appended as well.  It returns a new slice that includes the appended
+// weights and the number of bytes consumed from s.
+func (t *Table) appendNext(w []Elem, src source) (res []Elem, n int) {
+	ce, sz := src.lookup(t)
+	tp := ce.ctype()
+	if tp == ceNormal {
+		if ce == 0 {
+			r, _ := src.rune()
+			const (
+				hangulSize  = 3
+				firstHangul = 0xAC00
+				lastHangul  = 0xD7A3
+			)
+			if r >= firstHangul && r <= lastHangul {
+				// TODO: performance can be considerably improved here.
+				n = sz
+				var buf [16]byte // Used for decomposing Hangul.
+				for b := src.nfd(buf[:0], hangulSize); len(b) > 0; b = b[sz:] {
+					ce, sz = t.Index.lookup(b)
+					w = append(w, ce)
+				}
+				return w, n
+			}
+			ce = makeImplicitCE(implicitPrimary(r))
+		}
+		w = append(w, ce)
+	} else if tp == ceExpansionIndex {
+		w = t.appendExpansion(w, ce)
+	} else if tp == ceContractionIndex {
+		n := 0
+		src.tail(sz)
+		if src.bytes == nil {
+			w, n = t.matchContractionString(w, ce, src.str)
+		} else {
+			w, n = t.matchContraction(w, ce, src.bytes)
+		}
+		sz += n
+	} else if tp == ceDecompose {
+		// Decompose using NFKD and replace tertiary weights.
+		t1, t2 := splitDecompose(ce)
+		i := len(w)
+		nfkd := src.properties(norm.NFKD).Decomposition()
+		for p := 0; len(nfkd) > 0; nfkd = nfkd[p:] {
+			w, p = t.appendNext(w, source{bytes: nfkd})
+		}
+		w[i] = w[i].updateTertiary(t1)
+		if i++; i < len(w) {
+			w[i] = w[i].updateTertiary(t2)
+			for i++; i < len(w); i++ {
+				w[i] = w[i].updateTertiary(maxTertiary)
+			}
+		}
+	}
+	return w, sz
+}
+
+func (t *Table) appendExpansion(w []Elem, ce Elem) []Elem {
+	i := splitExpandIndex(ce)
+	n := int(t.ExpandElem[i])
+	i++
+	for _, ce := range t.ExpandElem[i : i+n] {
+		w = append(w, Elem(ce))
+	}
+	return w
+}
+
+func (t *Table) matchContraction(w []Elem, ce Elem, suffix []byte) ([]Elem, int) {
+	index, n, offset := splitContractIndex(ce)
+
+	scan := t.ContractTries.scanner(index, n, suffix)
+	buf := [norm.MaxSegmentSize]byte{}
+	bufp := 0
+	p := scan.scan(0)
+
+	if !scan.done && p < len(suffix) && suffix[p] >= utf8.RuneSelf {
+		// By now we should have filtered most cases.
+		p0 := p
+		bufn := 0
+		rune := norm.NFD.Properties(suffix[p:])
+		p += rune.Size()
+		if rune.LeadCCC() != 0 {
+			prevCC := rune.TrailCCC()
+			// A gap may only occur in the last normalization segment.
+			// This also ensures that len(scan.s) < norm.MaxSegmentSize.
+			if end := norm.NFD.FirstBoundary(suffix[p:]); end != -1 {
+				scan.s = suffix[:p+end]
+			}
+			for p < len(suffix) && !scan.done && suffix[p] >= utf8.RuneSelf {
+				rune = norm.NFD.Properties(suffix[p:])
+				if ccc := rune.LeadCCC(); ccc == 0 || prevCC >= ccc {
+					break
+				}
+				prevCC = rune.TrailCCC()
+				if pp := scan.scan(p); pp != p {
+					// Copy the interstitial runes for later processing.
+					bufn += copy(buf[bufn:], suffix[p0:p])
+					if scan.pindex == pp {
+						bufp = bufn
+					}
+					p, p0 = pp, pp
+				} else {
+					p += rune.Size()
+				}
+			}
+		}
+	}
+	// Append weights for the matched contraction, which may be an expansion.
+	i, n := scan.result()
+	ce = Elem(t.ContractElem[i+offset])
+	if ce.ctype() == ceNormal {
+		w = append(w, ce)
+	} else {
+		w = t.appendExpansion(w, ce)
+	}
+	// Append weights for the runes in the segment not part of the contraction.
+	for b, p := buf[:bufp], 0; len(b) > 0; b = b[p:] {
+		w, p = t.appendNext(w, source{bytes: b})
+	}
+	return w, n
+}
+
+// TODO: unify the two implementations. This is best done after first simplifying
+// the algorithm taking into account the inclusion of both NFC and NFD forms
+// in the table.
+func (t *Table) matchContractionString(w []Elem, ce Elem, suffix string) ([]Elem, int) {
+	index, n, offset := splitContractIndex(ce)
+
+	scan := t.ContractTries.scannerString(index, n, suffix)
+	buf := [norm.MaxSegmentSize]byte{}
+	bufp := 0
+	p := scan.scan(0)
+
+	if !scan.done && p < len(suffix) && suffix[p] >= utf8.RuneSelf {
+		// By now we should have filtered most cases.
+		p0 := p
+		bufn := 0
+		rune := norm.NFD.PropertiesString(suffix[p:])
+		p += rune.Size()
+		if rune.LeadCCC() != 0 {
+			prevCC := rune.TrailCCC()
+			// A gap may only occur in the last normalization segment.
+			// This also ensures that len(scan.s) < norm.MaxSegmentSize.
+			if end := norm.NFD.FirstBoundaryInString(suffix[p:]); end != -1 {
+				scan.s = suffix[:p+end]
+			}
+			for p < len(suffix) && !scan.done && suffix[p] >= utf8.RuneSelf {
+				rune = norm.NFD.PropertiesString(suffix[p:])
+				if ccc := rune.LeadCCC(); ccc == 0 || prevCC >= ccc {
+					break
+				}
+				prevCC = rune.TrailCCC()
+				if pp := scan.scan(p); pp != p {
+					// Copy the interstitial runes for later processing.
+					bufn += copy(buf[bufn:], suffix[p0:p])
+					if scan.pindex == pp {
+						bufp = bufn
+					}
+					p, p0 = pp, pp
+				} else {
+					p += rune.Size()
+				}
+			}
+		}
+	}
+	// Append weights for the matched contraction, which may be an expansion.
+	i, n := scan.result()
+	ce = Elem(t.ContractElem[i+offset])
+	if ce.ctype() == ceNormal {
+		w = append(w, ce)
+	} else {
+		w = t.appendExpansion(w, ce)
+	}
+	// Append weights for the runes in the segment not part of the contraction.
+	for b, p := buf[:bufp], 0; len(b) > 0; b = b[p:] {
+		w, p = t.appendNext(w, source{bytes: b})
+	}
+	return w, n
+}

vendor/golang.org/x/text/internal/colltab/trie.go

@@ -0,0 +1,159 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// The trie in this file is used to associate the first full character in an
+// UTF-8 string to a collation element. All but the last byte in a UTF-8 byte
+// sequence are used to lookup offsets in the index table to be used for the
+// next byte. The last byte is used to index into a table of collation elements.
+// For a full description, see go.text/collate/build/trie.go.
+
+package colltab
+
+const blockSize = 64
+
+type Trie struct {
+	Index0  []uint16 // index for first byte (0xC0-0xFF)
+	Values0 []uint32 // index for first byte (0x00-0x7F)
+	Index   []uint16
+	Values  []uint32
+}
+
+const (
+	t1 = 0x00 // 0000 0000
+	tx = 0x80 // 1000 0000
+	t2 = 0xC0 // 1100 0000
+	t3 = 0xE0 // 1110 0000
+	t4 = 0xF0 // 1111 0000
+	t5 = 0xF8 // 1111 1000
+	t6 = 0xFC // 1111 1100
+	te = 0xFE // 1111 1110
+)
+
+func (t *Trie) lookupValue(n uint16, b byte) Elem {
+	return Elem(t.Values[int(n)<<6+int(b)])
+}
+
+// lookup returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *Trie) lookup(s []byte) (v Elem, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < tx:
+		return Elem(t.Values0[c0]), 1
+	case c0 < t2:
+		return 0, 1
+	case c0 < t3:
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := t.Index0[c0]
+		c1 := s[1]
+		if c1 < tx || t2 <= c1 {
+			return 0, 1
+		}
+		return t.lookupValue(i, c1), 2
+	case c0 < t4:
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := t.Index0[c0]
+		c1 := s[1]
+		if c1 < tx || t2 <= c1 {
+			return 0, 1
+		}
+		o := int(i)<<6 + int(c1)
+		i = t.Index[o]
+		c2 := s[2]
+		if c2 < tx || t2 <= c2 {
+			return 0, 2
+		}
+		return t.lookupValue(i, c2), 3
+	case c0 < t5:
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := t.Index0[c0]
+		c1 := s[1]
+		if c1 < tx || t2 <= c1 {
+			return 0, 1
+		}
+		o := int(i)<<6 + int(c1)
+		i = t.Index[o]
+		c2 := s[2]
+		if c2 < tx || t2 <= c2 {
+			return 0, 2
+		}
+		o = int(i)<<6 + int(c2)
+		i = t.Index[o]
+		c3 := s[3]
+		if c3 < tx || t2 <= c3 {
+			return 0, 3
+		}
+		return t.lookupValue(i, c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// The body of lookupString is a verbatim copy of that of lookup.
+func (t *Trie) lookupString(s string) (v Elem, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < tx:
+		return Elem(t.Values0[c0]), 1
+	case c0 < t2:
+		return 0, 1
+	case c0 < t3:
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := t.Index0[c0]
+		c1 := s[1]
+		if c1 < tx || t2 <= c1 {
+			return 0, 1
+		}
+		return t.lookupValue(i, c1), 2
+	case c0 < t4:
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := t.Index0[c0]
+		c1 := s[1]
+		if c1 < tx || t2 <= c1 {
+			return 0, 1
+		}
+		o := int(i)<<6 + int(c1)
+		i = t.Index[o]
+		c2 := s[2]
+		if c2 < tx || t2 <= c2 {
+			return 0, 2
+		}
+		return t.lookupValue(i, c2), 3
+	case c0 < t5:
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := t.Index0[c0]
+		c1 := s[1]
+		if c1 < tx || t2 <= c1 {
+			return 0, 1
+		}
+		o := int(i)<<6 + int(c1)
+		i = t.Index[o]
+		c2 := s[2]
+		if c2 < tx || t2 <= c2 {
+			return 0, 2
+		}
+		o = int(i)<<6 + int(c2)
+		i = t.Index[o]
+		c3 := s[3]
+		if c3 < tx || t2 <= c3 {
+			return 0, 3
+		}
+		return t.lookupValue(i, c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}

vendor/golang.org/x/text/internal/colltab/weighter.go

@@ -0,0 +1,31 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package colltab // import "golang.org/x/text/internal/colltab"
+
+// A Weighter can be used as a source for Collator and Searcher.
+type Weighter interface {
+	// Start finds the start of the segment that includes position p.
+	Start(p int, b []byte) int
+
+	// StartString finds the start of the segment that includes position p.
+	StartString(p int, s string) int
+
+	// AppendNext appends Elems to buf corresponding to the longest match
+	// of a single character or contraction from the start of s.
+	// It returns the new buf and the number of bytes consumed.
+	AppendNext(buf []Elem, s []byte) (ce []Elem, n int)
+
+	// AppendNextString appends Elems to buf corresponding to the longest match
+	// of a single character or contraction from the start of s.
+	// It returns the new buf and the number of bytes consumed.
+	AppendNextString(buf []Elem, s string) (ce []Elem, n int)
+
+	// Domain returns a slice of all single characters and contractions for which
+	// collation elements are defined in this table.
+	Domain() []string
+
+	// Top returns the highest variable primary value.
+	Top() uint32
+}

vendor/golang.org/x/text/internal/gen/code.go

@@ -0,0 +1,369 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gen
+
+import (
+	"bytes"
+	"encoding/gob"
+	"fmt"
+	"hash"
+	"hash/fnv"
+	"io"
+	"log"
+	"os"
+	"reflect"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+// This file contains utilities for generating code.
+
+// TODO: other write methods like:
+// - slices, maps, types, etc.
+
+// CodeWriter is a utility for writing structured code. It computes the content
+// hash and size of written content. It ensures there are newlines between
+// written code blocks.
+type CodeWriter struct {
+	buf  bytes.Buffer
+	Size int
+	Hash hash.Hash32 // content hash
+	gob  *gob.Encoder
+	// For comments we skip the usual one-line separator if they are followed by
+	// a code block.
+	skipSep bool
+}
+
+func (w *CodeWriter) Write(p []byte) (n int, err error) {
+	return w.buf.Write(p)
+}
+
+// NewCodeWriter returns a new CodeWriter.
+func NewCodeWriter() *CodeWriter {
+	h := fnv.New32()
+	return &CodeWriter{Hash: h, gob: gob.NewEncoder(h)}
+}
+
+// WriteGoFile appends the buffer with the total size of all created structures
+// and writes it as a Go file to the the given file with the given package name.
+func (w *CodeWriter) WriteGoFile(filename, pkg string) {
+	f, err := os.Create(filename)
+	if err != nil {
+		log.Fatalf("Could not create file %s: %v", filename, err)
+	}
+	defer f.Close()
+	if _, err = w.WriteGo(f, pkg, ""); err != nil {
+		log.Fatalf("Error writing file %s: %v", filename, err)
+	}
+}
+
+// WriteVersionedGoFile appends the buffer with the total size of all created
+// structures and writes it as a Go file to the the given file with the given
+// package name and build tags for the current Unicode version,
+func (w *CodeWriter) WriteVersionedGoFile(filename, pkg string) {
+	tags := buildTags()
+	if tags != "" {
+		filename = insertVersion(filename, UnicodeVersion())
+	}
+	f, err := os.Create(filename)
+	if err != nil {
+		log.Fatalf("Could not create file %s: %v", filename, err)
+	}
+	defer f.Close()
+	if _, err = w.WriteGo(f, pkg, tags); err != nil {
+		log.Fatalf("Error writing file %s: %v", filename, err)
+	}
+}
+
+// WriteGo appends the buffer with the total size of all created structures and
+// writes it as a Go file to the the given writer with the given package name.
+func (w *CodeWriter) WriteGo(out io.Writer, pkg, tags string) (n int, err error) {
+	sz := w.Size
+	w.WriteComment("Total table size %d bytes (%dKiB); checksum: %X\n", sz, sz/1024, w.Hash.Sum32())
+	defer w.buf.Reset()
+	return WriteGo(out, pkg, tags, w.buf.Bytes())
+}
+
+func (w *CodeWriter) printf(f string, x ...interface{}) {
+	fmt.Fprintf(w, f, x...)
+}
+
+func (w *CodeWriter) insertSep() {
+	if w.skipSep {
+		w.skipSep = false
+		return
+	}
+	// Use at least two newlines to ensure a blank space between the previous
+	// block. WriteGoFile will remove extraneous newlines.
+	w.printf("\n\n")
+}
+
+// WriteComment writes a comment block. All line starts are prefixed with "//".
+// Initial empty lines are gobbled. The indentation for the first line is
+// stripped from consecutive lines.
+func (w *CodeWriter) WriteComment(comment string, args ...interface{}) {
+	s := fmt.Sprintf(comment, args...)
+	s = strings.Trim(s, "\n")
+
+	// Use at least two newlines to ensure a blank space between the previous
+	// block. WriteGoFile will remove extraneous newlines.
+	w.printf("\n\n// ")
+	w.skipSep = true
+
+	// strip first indent level.
+	sep := "\n"
+	for ; len(s) > 0 && (s[0] == '\t' || s[0] == ' '); s = s[1:] {
+		sep += s[:1]
+	}
+
+	strings.NewReplacer(sep, "\n// ", "\n", "\n// ").WriteString(w, s)
+
+	w.printf("\n")
+}
+
+func (w *CodeWriter) writeSizeInfo(size int) {
+	w.printf("// Size: %d bytes\n", size)
+}
+
+// WriteConst writes a constant of the given name and value.
+func (w *CodeWriter) WriteConst(name string, x interface{}) {
+	w.insertSep()
+	v := reflect.ValueOf(x)
+
+	switch v.Type().Kind() {
+	case reflect.String:
+		w.printf("const %s %s = ", name, typeName(x))
+		w.WriteString(v.String())
+		w.printf("\n")
+	default:
+		w.printf("const %s = %#v\n", name, x)
+	}
+}
+
+// WriteVar writes a variable of the given name and value.
+func (w *CodeWriter) WriteVar(name string, x interface{}) {
+	w.insertSep()
+	v := reflect.ValueOf(x)
+	oldSize := w.Size
+	sz := int(v.Type().Size())
+	w.Size += sz
+
+	switch v.Type().Kind() {
+	case reflect.String:
+		w.printf("var %s %s = ", name, typeName(x))
+		w.WriteString(v.String())
+	case reflect.Struct:
+		w.gob.Encode(x)
+		fallthrough
+	case reflect.Slice, reflect.Array:
+		w.printf("var %s = ", name)
+		w.writeValue(v)
+		w.writeSizeInfo(w.Size - oldSize)
+	default:
+		w.printf("var %s %s = ", name, typeName(x))
+		w.gob.Encode(x)
+		w.writeValue(v)
+		w.writeSizeInfo(w.Size - oldSize)
+	}
+	w.printf("\n")
+}
+
+func (w *CodeWriter) writeValue(v reflect.Value) {
+	x := v.Interface()
+	switch v.Kind() {
+	case reflect.String:
+		w.WriteString(v.String())
+	case reflect.Array:
+		// Don't double count: callers of WriteArray count on the size being
+		// added, so we need to discount it here.
+		w.Size -= int(v.Type().Size())
+		w.writeSlice(x, true)
+	case reflect.Slice:
+		w.writeSlice(x, false)
+	case reflect.Struct:
+		w.printf("%s{\n", typeName(v.Interface()))
+		t := v.Type()
+		for i := 0; i < v.NumField(); i++ {
+			w.printf("%s: ", t.Field(i).Name)
+			w.writeValue(v.Field(i))
+			w.printf(",\n")
+		}
+		w.printf("}")
+	default:
+		w.printf("%#v", x)
+	}
+}
+
+// WriteString writes a string literal.
+func (w *CodeWriter) WriteString(s string) {
+	s = strings.Replace(s, `\`, `\\`, -1)
+	io.WriteString(w.Hash, s) // content hash
+	w.Size += len(s)
+
+	const maxInline = 40
+	if len(s) <= maxInline {
+		w.printf("%q", s)
+		return
+	}
+
+	// We will render the string as a multi-line string.
+	const maxWidth = 80 - 4 - len(`"`) - len(`" +`)
+
+	// When starting on its own line, go fmt indents line 2+ an extra level.
+	n, max := maxWidth, maxWidth-4
+
+	// As per https://golang.org/issue/18078, the compiler has trouble
+	// compiling the concatenation of many strings, s0 + s1 + s2 + ... + sN,
+	// for large N. We insert redundant, explicit parentheses to work around
+	// that, lowering the N at any given step: (s0 + s1 + ... + s63) + (s64 +
+	// ... + s127) + etc + (etc + ... + sN).
+	explicitParens, extraComment := len(s) > 128*1024, ""
+	if explicitParens {
+		w.printf(`(`)
+		extraComment = "; the redundant, explicit parens are for https://golang.org/issue/18078"
+	}
+
+	// Print "" +\n, if a string does not start on its own line.
+	b := w.buf.Bytes()
+	if p := len(bytes.TrimRight(b, " \t")); p > 0 && b[p-1] != '\n' {
+		w.printf("\"\" + // Size: %d bytes%s\n", len(s), extraComment)
+		n, max = maxWidth, maxWidth
+	}
+
+	w.printf(`"`)
+
+	for sz, p, nLines := 0, 0, 0; p < len(s); {
+		var r rune
+		r, sz = utf8.DecodeRuneInString(s[p:])
+		out := s[p : p+sz]
+		chars := 1
+		if !unicode.IsPrint(r) || r == utf8.RuneError || r == '"' {
+			switch sz {
+			case 1:
+				out = fmt.Sprintf("\\x%02x", s[p])
+			case 2, 3:
+				out = fmt.Sprintf("\\u%04x", r)
+			case 4:
+				out = fmt.Sprintf("\\U%08x", r)
+			}
+			chars = len(out)
+		}
+		if n -= chars; n < 0 {
+			nLines++
+			if explicitParens && nLines&63 == 63 {
+				w.printf("\") + (\"")
+			}
+			w.printf("\" +\n\"")
+			n = max - len(out)
+		}
+		w.printf("%s", out)
+		p += sz
+	}
+	w.printf(`"`)
+	if explicitParens {
+		w.printf(`)`)
+	}
+}
+
+// WriteSlice writes a slice value.
+func (w *CodeWriter) WriteSlice(x interface{}) {
+	w.writeSlice(x, false)
+}
+
+// WriteArray writes an array value.
+func (w *CodeWriter) WriteArray(x interface{}) {
+	w.writeSlice(x, true)
+}
+
+func (w *CodeWriter) writeSlice(x interface{}, isArray bool) {
+	v := reflect.ValueOf(x)
+	w.gob.Encode(v.Len())
+	w.Size += v.Len() * int(v.Type().Elem().Size())
+	name := typeName(x)
+	if isArray {
+		name = fmt.Sprintf("[%d]%s", v.Len(), name[strings.Index(name, "]")+1:])
+	}
+	if isArray {
+		w.printf("%s{\n", name)
+	} else {
+		w.printf("%s{ // %d elements\n", name, v.Len())
+	}
+
+	switch kind := v.Type().Elem().Kind(); kind {
+	case reflect.String:
+		for _, s := range x.([]string) {
+			w.WriteString(s)
+			w.printf(",\n")
+		}
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		// nLine and nBlock are the number of elements per line and block.
+		nLine, nBlock, format := 8, 64, "%d,"
+		switch kind {
+		case reflect.Uint8:
+			format = "%#02x,"
+		case reflect.Uint16:
+			format = "%#04x,"
+		case reflect.Uint32:
+			nLine, nBlock, format = 4, 32, "%#08x,"
+		case reflect.Uint, reflect.Uint64:
+			nLine, nBlock, format = 4, 32, "%#016x,"
+		case reflect.Int8:
+			nLine = 16
+		}
+		n := nLine
+		for i := 0; i < v.Len(); i++ {
+			if i%nBlock == 0 && v.Len() > nBlock {
+				w.printf("// Entry %X - %X\n", i, i+nBlock-1)
+			}
+			x := v.Index(i).Interface()
+			w.gob.Encode(x)
+			w.printf(format, x)
+			if n--; n == 0 {
+				n = nLine
+				w.printf("\n")
+			}
+		}
+		w.printf("\n")
+	case reflect.Struct:
+		zero := reflect.Zero(v.Type().Elem()).Interface()
+		for i := 0; i < v.Len(); i++ {
+			x := v.Index(i).Interface()
+			w.gob.EncodeValue(v)
+			if !reflect.DeepEqual(zero, x) {
+				line := fmt.Sprintf("%#v,\n", x)
+				line = line[strings.IndexByte(line, '{'):]
+				w.printf("%d: ", i)
+				w.printf(line)
+			}
+		}
+	case reflect.Array:
+		for i := 0; i < v.Len(); i++ {
+			w.printf("%d: %#v,\n", i, v.Index(i).Interface())
+		}
+	default:
+		panic("gen: slice elem type not supported")
+	}
+	w.printf("}")
+}
+
+// WriteType writes a definition of the type of the given value and returns the
+// type name.
+func (w *CodeWriter) WriteType(x interface{}) string {
+	t := reflect.TypeOf(x)
+	w.printf("type %s struct {\n", t.Name())
+	for i := 0; i < t.NumField(); i++ {
+		w.printf("\t%s %s\n", t.Field(i).Name, t.Field(i).Type)
+	}
+	w.printf("}\n")
+	return t.Name()
+}
+
+// typeName returns the name of the go type of x.
+func typeName(x interface{}) string {
+	t := reflect.ValueOf(x).Type()
+	return strings.Replace(fmt.Sprint(t), "main.", "", 1)
+}

vendor/golang.org/x/text/internal/gen/gen.go

@@ -0,0 +1,333 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package gen contains common code for the various code generation tools in the
+// text repository. Its usage ensures consistency between tools.
+//
+// This package defines command line flags that are common to most generation
+// tools. The flags allow for specifying specific Unicode and CLDR versions
+// in the public Unicode data repository (http://www.unicode.org/Public).
+//
+// A local Unicode data mirror can be set through the flag -local or the
+// environment variable UNICODE_DIR. The former takes precedence. The local
+// directory should follow the same structure as the public repository.
+//
+// IANA data can also optionally be mirrored by putting it in the iana directory
+// rooted at the top of the local mirror. Beware, though, that IANA data is not
+// versioned. So it is up to the developer to use the right version.
+package gen // import "golang.org/x/text/internal/gen"
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/build"
+	"go/format"
+	"io"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+	"sync"
+	"unicode"
+
+	"golang.org/x/text/unicode/cldr"
+)
+
+var (
+	url = flag.String("url",
+		"http://www.unicode.org/Public",
+		"URL of Unicode database directory")
+	iana = flag.String("iana",
+		"http://www.iana.org",
+		"URL of the IANA repository")
+	unicodeVersion = flag.String("unicode",
+		getEnv("UNICODE_VERSION", unicode.Version),
+		"unicode version to use")
+	cldrVersion = flag.String("cldr",
+		getEnv("CLDR_VERSION", cldr.Version),
+		"cldr version to use")
+)
+
+func getEnv(name, def string) string {
+	if v := os.Getenv(name); v != "" {
+		return v
+	}
+	return def
+}
+
+// Init performs common initialization for a gen command. It parses the flags
+// and sets up the standard logging parameters.
+func Init() {
+	log.SetPrefix("")
+	log.SetFlags(log.Lshortfile)
+	flag.Parse()
+}
+
+const header = `// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+`
+
+// UnicodeVersion reports the requested Unicode version.
+func UnicodeVersion() string {
+	return *unicodeVersion
+}
+
+// CLDRVersion reports the requested CLDR version.
+func CLDRVersion() string {
+	return *cldrVersion
+}
+
+var tags = []struct{ version, buildTags string }{
+	{"10.0.0", "go1.10"},
+	{"", "!go1.10"},
+}
+
+// buildTags reports the build tags used for the current Unicode version.
+func buildTags() string {
+	v := UnicodeVersion()
+	for _, x := range tags {
+		// We should do a numeric comparison, but including the collate package
+		// would create an import cycle. We approximate it by assuming that
+		// longer version strings are later.
+		if len(x.version) <= len(v) {
+			return x.buildTags
+		}
+		if len(x.version) == len(v) && x.version <= v {
+			return x.buildTags
+		}
+	}
+	return tags[0].buildTags
+}
+
+// IsLocal reports whether data files are available locally.
+func IsLocal() bool {
+	dir, err := localReadmeFile()
+	if err != nil {
+		return false
+	}
+	if _, err = os.Stat(dir); err != nil {
+		return false
+	}
+	return true
+}
+
+// OpenUCDFile opens the requested UCD file. The file is specified relative to
+// the public Unicode root directory. It will call log.Fatal if there are any
+// errors.
+func OpenUCDFile(file string) io.ReadCloser {
+	return openUnicode(path.Join(*unicodeVersion, "ucd", file))
+}
+
+// OpenCLDRCoreZip opens the CLDR core zip file. It will call log.Fatal if there
+// are any errors.
+func OpenCLDRCoreZip() io.ReadCloser {
+	return OpenUnicodeFile("cldr", *cldrVersion, "core.zip")
+}
+
+// OpenUnicodeFile opens the requested file of the requested category from the
+// root of the Unicode data archive. The file is specified relative to the
+// public Unicode root directory. If version is "", it will use the default
+// Unicode version. It will call log.Fatal if there are any errors.
+func OpenUnicodeFile(category, version, file string) io.ReadCloser {
+	if version == "" {
+		version = UnicodeVersion()
+	}
+	return openUnicode(path.Join(category, version, file))
+}
+
+// OpenIANAFile opens the requested IANA file. The file is specified relative
+// to the IANA root, which is typically either http://www.iana.org or the
+// iana directory in the local mirror. It will call log.Fatal if there are any
+// errors.
+func OpenIANAFile(path string) io.ReadCloser {
+	return Open(*iana, "iana", path)
+}
+
+var (
+	dirMutex sync.Mutex
+	localDir string
+)
+
+const permissions = 0755
+
+func localReadmeFile() (string, error) {
+	p, err := build.Import("golang.org/x/text", "", build.FindOnly)
+	if err != nil {
+		return "", fmt.Errorf("Could not locate package: %v", err)
+	}
+	return filepath.Join(p.Dir, "DATA", "README"), nil
+}
+
+func getLocalDir() string {
+	dirMutex.Lock()
+	defer dirMutex.Unlock()
+
+	readme, err := localReadmeFile()
+	if err != nil {
+		log.Fatal(err)
+	}
+	dir := filepath.Dir(readme)
+	if _, err := os.Stat(readme); err != nil {
+		if err := os.MkdirAll(dir, permissions); err != nil {
+			log.Fatalf("Could not create directory: %v", err)
+		}
+		ioutil.WriteFile(readme, []byte(readmeTxt), permissions)
+	}
+	return dir
+}
+
+const readmeTxt = `Generated by golang.org/x/text/internal/gen. DO NOT EDIT.
+
+This directory contains downloaded files used to generate the various tables
+in the golang.org/x/text subrepo.
+
+Note that the language subtag repo (iana/assignments/language-subtag-registry)
+and all other times in the iana subdirectory are not versioned and will need
+to be periodically manually updated. The easiest way to do this is to remove
+the entire iana directory. This is mostly of concern when updating the language
+package.
+`
+
+// Open opens subdir/path if a local directory is specified and the file exists,
+// where subdir is a directory relative to the local root, or fetches it from
+// urlRoot/path otherwise. It will call log.Fatal if there are any errors.
+func Open(urlRoot, subdir, path string) io.ReadCloser {
+	file := filepath.Join(getLocalDir(), subdir, filepath.FromSlash(path))
+	return open(file, urlRoot, path)
+}
+
+func openUnicode(path string) io.ReadCloser {
+	file := filepath.Join(getLocalDir(), filepath.FromSlash(path))
+	return open(file, *url, path)
+}
+
+// TODO: automatically periodically update non-versioned files.
+
+func open(file, urlRoot, path string) io.ReadCloser {
+	if f, err := os.Open(file); err == nil {
+		return f
+	}
+	r := get(urlRoot, path)
+	defer r.Close()
+	b, err := ioutil.ReadAll(r)
+	if err != nil {
+		log.Fatalf("Could not download file: %v", err)
+	}
+	os.MkdirAll(filepath.Dir(file), permissions)
+	if err := ioutil.WriteFile(file, b, permissions); err != nil {
+		log.Fatalf("Could not create file: %v", err)
+	}
+	return ioutil.NopCloser(bytes.NewReader(b))
+}
+
+func get(root, path string) io.ReadCloser {
+	url := root + "/" + path
+	fmt.Printf("Fetching %s...", url)
+	defer fmt.Println(" done.")
+	resp, err := http.Get(url)
+	if err != nil {
+		log.Fatalf("HTTP GET: %v", err)
+	}
+	if resp.StatusCode != 200 {
+		log.Fatalf("Bad GET status for %q: %q", url, resp.Status)
+	}
+	return resp.Body
+}
+
+// TODO: use Write*Version in all applicable packages.
+
+// WriteUnicodeVersion writes a constant for the Unicode version from which the
+// tables are generated.
+func WriteUnicodeVersion(w io.Writer) {
+	fmt.Fprintf(w, "// UnicodeVersion is the Unicode version from which the tables in this package are derived.\n")
+	fmt.Fprintf(w, "const UnicodeVersion = %q\n\n", UnicodeVersion())
+}
+
+// WriteCLDRVersion writes a constant for the CLDR version from which the
+// tables are generated.
+func WriteCLDRVersion(w io.Writer) {
+	fmt.Fprintf(w, "// CLDRVersion is the CLDR version from which the tables in this package are derived.\n")
+	fmt.Fprintf(w, "const CLDRVersion = %q\n\n", CLDRVersion())
+}
+
+// WriteGoFile prepends a standard file comment and package statement to the
+// given bytes, applies gofmt, and writes them to a file with the given name.
+// It will call log.Fatal if there are any errors.
+func WriteGoFile(filename, pkg string, b []byte) {
+	w, err := os.Create(filename)
+	if err != nil {
+		log.Fatalf("Could not create file %s: %v", filename, err)
+	}
+	defer w.Close()
+	if _, err = WriteGo(w, pkg, "", b); err != nil {
+		log.Fatalf("Error writing file %s: %v", filename, err)
+	}
+}
+
+func insertVersion(filename, version string) string {
+	suffix := ".go"
+	if strings.HasSuffix(filename, "_test.go") {
+		suffix = "_test.go"
+	}
+	return fmt.Sprint(filename[:len(filename)-len(suffix)], version, suffix)
+}
+
+// WriteVersionedGoFile prepends a standard file comment, adds build tags to
+// version the file for the current Unicode version, and package statement to
+// the given bytes, applies gofmt, and writes them to a file with the given
+// name. It will call log.Fatal if there are any errors.
+func WriteVersionedGoFile(filename, pkg string, b []byte) {
+	tags := buildTags()
+	if tags != "" {
+		filename = insertVersion(filename, UnicodeVersion())
+	}
+	w, err := os.Create(filename)
+	if err != nil {
+		log.Fatalf("Could not create file %s: %v", filename, err)
+	}
+	defer w.Close()
+	if _, err = WriteGo(w, pkg, tags, b); err != nil {
+		log.Fatalf("Error writing file %s: %v", filename, err)
+	}
+}
+
+// WriteGo prepends a standard file comment and package statement to the given
+// bytes, applies gofmt, and writes them to w.
+func WriteGo(w io.Writer, pkg, tags string, b []byte) (n int, err error) {
+	src := []byte(header)
+	if tags != "" {
+		src = append(src, fmt.Sprintf("// +build %s\n\n", tags)...)
+	}
+	src = append(src, fmt.Sprintf("package %s\n\n", pkg)...)
+	src = append(src, b...)
+	formatted, err := format.Source(src)
+	if err != nil {
+		// Print the generated code even in case of an error so that the
+		// returned error can be meaningfully interpreted.
+		n, _ = w.Write(src)
+		return n, err
+	}
+	return w.Write(formatted)
+}
+
+// Repackage rewrites a Go file from belonging to package main to belonging to
+// the given package.
+func Repackage(inFile, outFile, pkg string) {
+	src, err := ioutil.ReadFile(inFile)
+	if err != nil {
+		log.Fatalf("reading %s: %v", inFile, err)
+	}
+	const toDelete = "package main\n\n"
+	i := bytes.Index(src, []byte(toDelete))
+	if i < 0 {
+		log.Fatalf("Could not find %q in %s.", toDelete, inFile)
+	}
+	w := &bytes.Buffer{}
+	w.Write(src[i+len(toDelete):])
+	WriteGoFile(outFile, pkg, w.Bytes())
+}

vendor/golang.org/x/text/internal/tag/tag.go

@@ -0,0 +1,100 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package tag contains functionality handling tags and related data.
+package tag // import "golang.org/x/text/internal/tag"
+
+import "sort"
+
+// An Index converts tags to a compact numeric value.
+//
+// All elements are of size 4. Tags may be up to 4 bytes long. Excess bytes can
+// be used to store additional information about the tag.
+type Index string
+
+// Elem returns the element data at the given index.
+func (s Index) Elem(x int) string {
+	return string(s[x*4 : x*4+4])
+}
+
+// Index reports the index of the given key or -1 if it could not be found.
+// Only the first len(key) bytes from the start of the 4-byte entries will be
+// considered for the search and the first match in Index will be returned.
+func (s Index) Index(key []byte) int {
+	n := len(key)
+	// search the index of the first entry with an equal or higher value than
+	// key in s.
+	index := sort.Search(len(s)/4, func(i int) bool {
+		return cmp(s[i*4:i*4+n], key) != -1
+	})
+	i := index * 4
+	if cmp(s[i:i+len(key)], key) != 0 {
+		return -1
+	}
+	return index
+}
+
+// Next finds the next occurrence of key after index x, which must have been
+// obtained from a call to Index using the same key. It returns x+1 or -1.
+func (s Index) Next(key []byte, x int) int {
+	if x++; x*4 < len(s) && cmp(s[x*4:x*4+len(key)], key) == 0 {
+		return x
+	}
+	return -1
+}
+
+// cmp returns an integer comparing a and b lexicographically.
+func cmp(a Index, b []byte) int {
+	n := len(a)
+	if len(b) < n {
+		n = len(b)
+	}
+	for i, c := range b[:n] {
+		switch {
+		case a[i] > c:
+			return 1
+		case a[i] < c:
+			return -1
+		}
+	}
+	switch {
+	case len(a) < len(b):
+		return -1
+	case len(a) > len(b):
+		return 1
+	}
+	return 0
+}
+
+// Compare returns an integer comparing a and b lexicographically.
+func Compare(a string, b []byte) int {
+	return cmp(Index(a), b)
+}
+
+// FixCase reformats b to the same pattern of cases as form.
+// If returns false if string b is malformed.
+func FixCase(form string, b []byte) bool {
+	if len(form) != len(b) {
+		return false
+	}
+	for i, c := range b {
+		if form[i] <= 'Z' {
+			if c >= 'a' {
+				c -= 'z' - 'Z'
+			}
+			if c < 'A' || 'Z' < c {
+				return false
+			}
+		} else {
+			if c <= 'Z' {
+				c += 'z' - 'Z'
+			}
+			if c < 'a' || 'z' < c {
+				return false
+			}
+		}
+		b[i] = c
+	}
+	return true
+}

vendor/golang.org/x/text/internal/triegen/compact.go

@@ -0,0 +1,58 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package triegen
+
+// This file defines Compacter and its implementations.
+
+import "io"
+
+// A Compacter generates an alternative, more space-efficient way to store a
+// trie value block. A trie value block holds all possible values for the last
+// byte of a UTF-8 encoded rune. Excluding ASCII characters, a trie value block
+// always has 64 values, as a UTF-8 encoding ends with a byte in [0x80, 0xC0).
+type Compacter interface {
+	// Size returns whether the Compacter could encode the given block as well
+	// as its size in case it can. len(v) is always 64.
+	Size(v []uint64) (sz int, ok bool)
+
+	// Store stores the block using the Compacter's compression method.
+	// It returns a handle with which the block can be retrieved.
+	// len(v) is always 64.
+	Store(v []uint64) uint32
+
+	// Print writes the data structures associated to the given store to w.
+	Print(w io.Writer) error
+
+	// Handler returns the name of a function that gets called during trie
+	// lookup for blocks generated by the Compacter. The function should be of
+	// the form func (n uint32, b byte) uint64, where n is the index returned by
+	// the Compacter's Store method and b is the last byte of the UTF-8
+	// encoding, where 0x80 <= b < 0xC0, for which to do the lookup in the
+	// block.
+	Handler() string
+}
+
+// simpleCompacter is the default Compacter used by builder. It implements a
+// normal trie block.
+type simpleCompacter builder
+
+func (b *simpleCompacter) Size([]uint64) (sz int, ok bool) {
+	return blockSize * b.ValueSize, true
+}
+
+func (b *simpleCompacter) Store(v []uint64) uint32 {
+	h := uint32(len(b.ValueBlocks) - blockOffset)
+	b.ValueBlocks = append(b.ValueBlocks, v)
+	return h
+}
+
+func (b *simpleCompacter) Print(io.Writer) error {
+	// Structures are printed in print.go.
+	return nil
+}
+
+func (b *simpleCompacter) Handler() string {
+	panic("Handler should be special-cased for this Compacter")
+}

vendor/golang.org/x/text/internal/triegen/print.go

@@ -0,0 +1,251 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package triegen
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"strings"
+	"text/template"
+)
+
+// print writes all the data structures as well as the code necessary to use the
+// trie to w.
+func (b *builder) print(w io.Writer) error {
+	b.Stats.NValueEntries = len(b.ValueBlocks) * blockSize
+	b.Stats.NValueBytes = len(b.ValueBlocks) * blockSize * b.ValueSize
+	b.Stats.NIndexEntries = len(b.IndexBlocks) * blockSize
+	b.Stats.NIndexBytes = len(b.IndexBlocks) * blockSize * b.IndexSize
+	b.Stats.NHandleBytes = len(b.Trie) * 2 * b.IndexSize
+
+	// If we only have one root trie, all starter blocks are at position 0 and
+	// we can access the arrays directly.
+	if len(b.Trie) == 1 {
+		// At this point we cannot refer to the generated tables directly.
+		b.ASCIIBlock = b.Name + "Values"
+		b.StarterBlock = b.Name + "Index"
+	} else {
+		// Otherwise we need to have explicit starter indexes in the trie
+		// structure.
+		b.ASCIIBlock = "t.ascii"
+		b.StarterBlock = "t.utf8Start"
+	}
+
+	b.SourceType = "[]byte"
+	if err := lookupGen.Execute(w, b); err != nil {
+		return err
+	}
+
+	b.SourceType = "string"
+	if err := lookupGen.Execute(w, b); err != nil {
+		return err
+	}
+
+	if err := trieGen.Execute(w, b); err != nil {
+		return err
+	}
+
+	for _, c := range b.Compactions {
+		if err := c.c.Print(w); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func printValues(n int, values []uint64) string {
+	w := &bytes.Buffer{}
+	boff := n * blockSize
+	fmt.Fprintf(w, "\t// Block %#x, offset %#x", n, boff)
+	var newline bool
+	for i, v := range values {
+		if i%6 == 0 {
+			newline = true
+		}
+		if v != 0 {
+			if newline {
+				fmt.Fprintf(w, "\n")
+				newline = false
+			}
+			fmt.Fprintf(w, "\t%#02x:%#04x, ", boff+i, v)
+		}
+	}
+	return w.String()
+}
+
+func printIndex(b *builder, nr int, n *node) string {
+	w := &bytes.Buffer{}
+	boff := nr * blockSize
+	fmt.Fprintf(w, "\t// Block %#x, offset %#x", nr, boff)
+	var newline bool
+	for i, c := range n.children {
+		if i%8 == 0 {
+			newline = true
+		}
+		if c != nil {
+			v := b.Compactions[c.index.compaction].Offset + uint32(c.index.index)
+			if v != 0 {
+				if newline {
+					fmt.Fprintf(w, "\n")
+					newline = false
+				}
+				fmt.Fprintf(w, "\t%#02x:%#02x, ", boff+i, v)
+			}
+		}
+	}
+	return w.String()
+}
+
+var (
+	trieGen = template.Must(template.New("trie").Funcs(template.FuncMap{
+		"printValues": printValues,
+		"printIndex":  printIndex,
+		"title":       strings.Title,
+		"dec":         func(x int) int { return x - 1 },
+		"psize": func(n int) string {
+			return fmt.Sprintf("%d bytes (%.2f KiB)", n, float64(n)/1024)
+		},
+	}).Parse(trieTemplate))
+	lookupGen = template.Must(template.New("lookup").Parse(lookupTemplate))
+)
+
+// TODO: consider the return type of lookup. It could be uint64, even if the
+// internal value type is smaller. We will have to verify this with the
+// performance of unicode/norm, which is very sensitive to such changes.
+const trieTemplate = `{{$b := .}}{{$multi := gt (len .Trie) 1}}
+// {{.Name}}Trie. Total size: {{psize .Size}}. Checksum: {{printf "%08x" .Checksum}}.
+type {{.Name}}Trie struct { {{if $multi}}
+	ascii []{{.ValueType}} // index for ASCII bytes
+	utf8Start  []{{.IndexType}} // index for UTF-8 bytes >= 0xC0
+{{end}}}
+
+func new{{title .Name}}Trie(i int) *{{.Name}}Trie { {{if $multi}}
+	h := {{.Name}}TrieHandles[i]
+	return &{{.Name}}Trie{ {{.Name}}Values[uint32(h.ascii)<<6:], {{.Name}}Index[uint32(h.multi)<<6:] }
+}
+
+type {{.Name}}TrieHandle struct {
+	ascii, multi {{.IndexType}}
+}
+
+// {{.Name}}TrieHandles: {{len .Trie}} handles, {{.Stats.NHandleBytes}} bytes
+var {{.Name}}TrieHandles = [{{len .Trie}}]{{.Name}}TrieHandle{
+{{range .Trie}}	{ {{.ASCIIIndex}}, {{.StarterIndex}} }, // {{printf "%08x" .Checksum}}: {{.Name}}
+{{end}}}{{else}}
+	return &{{.Name}}Trie{}
+}
+{{end}}
+// lookupValue determines the type of block n and looks up the value for b.
+func (t *{{.Name}}Trie) lookupValue(n uint32, b byte) {{.ValueType}}{{$last := dec (len .Compactions)}} {
+	switch { {{range $i, $c := .Compactions}}
+		{{if eq $i $last}}default{{else}}case n < {{$c.Cutoff}}{{end}}:{{if ne $i 0}}
+			n -= {{$c.Offset}}{{end}}
+			return {{print $b.ValueType}}({{$c.Handler}}){{end}}
+	}
+}
+
+// {{.Name}}Values: {{len .ValueBlocks}} blocks, {{.Stats.NValueEntries}} entries, {{.Stats.NValueBytes}} bytes
+// The third block is the zero block.
+var {{.Name}}Values = [{{.Stats.NValueEntries}}]{{.ValueType}} {
+{{range $i, $v := .ValueBlocks}}{{printValues $i $v}}
+{{end}}}
+
+// {{.Name}}Index: {{len .IndexBlocks}} blocks, {{.Stats.NIndexEntries}} entries, {{.Stats.NIndexBytes}} bytes
+// Block 0 is the zero block.
+var {{.Name}}Index = [{{.Stats.NIndexEntries}}]{{.IndexType}} {
+{{range $i, $v := .IndexBlocks}}{{printIndex $b $i $v}}
+{{end}}}
+`
+
+// TODO: consider allowing zero-length strings after evaluating performance with
+// unicode/norm.
+const lookupTemplate = `
+// lookup{{if eq .SourceType "string"}}String{{end}} returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *{{.Name}}Trie) lookup{{if eq .SourceType "string"}}String{{end}}(s {{.SourceType}}) (v {{.ValueType}}, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return {{.ASCIIBlock}}[c0], 1
+	case c0 < 0xC2:
+		return 0, 1  // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := {{.StarterBlock}}[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := {{.StarterBlock}}[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = {{.Name}}Index[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := {{.StarterBlock}}[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = {{.Name}}Index[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = {{.Name}}Index[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookup{{if eq .SourceType "string"}}String{{end}}Unsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *{{.Name}}Trie) lookup{{if eq .SourceType "string"}}String{{end}}Unsafe(s {{.SourceType}}) {{.ValueType}} {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return {{.ASCIIBlock}}[c0]
+	}
+	i := {{.StarterBlock}}[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = {{.Name}}Index[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = {{.Name}}Index[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+`

vendor/golang.org/x/text/internal/triegen/triegen.go

@@ -0,0 +1,494 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package triegen implements a code generator for a trie for associating
+// unsigned integer values with UTF-8 encoded runes.
+//
+// Many of the go.text packages use tries for storing per-rune information.  A
+// trie is especially useful if many of the runes have the same value. If this
+// is the case, many blocks can be expected to be shared allowing for
+// information on many runes to be stored in little space.
+//
+// As most of the lookups are done directly on []byte slices, the tries use the
+// UTF-8 bytes directly for the lookup. This saves a conversion from UTF-8 to
+// runes and contributes a little bit to better performance. It also naturally
+// provides a fast path for ASCII.
+//
+// Space is also an issue. There are many code points defined in Unicode and as
+// a result tables can get quite large. So every byte counts. The triegen
+// package automatically chooses the smallest integer values to represent the
+// tables. Compacters allow further compression of the trie by allowing for
+// alternative representations of individual trie blocks.
+//
+// triegen allows generating multiple tries as a single structure. This is
+// useful when, for example, one wants to generate tries for several languages
+// that have a lot of values in common. Some existing libraries for
+// internationalization store all per-language data as a dynamically loadable
+// chunk. The go.text packages are designed with the assumption that the user
+// typically wants to compile in support for all supported languages, in line
+// with the approach common to Go to create a single standalone binary. The
+// multi-root trie approach can give significant storage savings in this
+// scenario.
+//
+// triegen generates both tables and code. The code is optimized to use the
+// automatically chosen data types. The following code is generated for a Trie
+// or multiple Tries named "foo":
+//	- type fooTrie
+//		The trie type.
+//
+//	- func newFooTrie(x int) *fooTrie
+//		Trie constructor, where x is the index of the trie passed to Gen.
+//
+//	- func (t *fooTrie) lookup(s []byte) (v uintX, sz int)
+//		The lookup method, where uintX is automatically chosen.
+//
+//	- func lookupString, lookupUnsafe and lookupStringUnsafe
+//		Variants of the above.
+//
+//	- var fooValues and fooIndex and any tables generated by Compacters.
+//		The core trie data.
+//
+//	- var fooTrieHandles
+//		Indexes of starter blocks in case of multiple trie roots.
+//
+// It is recommended that users test the generated trie by checking the returned
+// value for every rune. Such exhaustive tests are possible as the the number of
+// runes in Unicode is limited.
+package triegen // import "golang.org/x/text/internal/triegen"
+
+// TODO: Arguably, the internally optimized data types would not have to be
+// exposed in the generated API. We could also investigate not generating the
+// code, but using it through a package. We would have to investigate the impact
+// on performance of making such change, though. For packages like unicode/norm,
+// small changes like this could tank performance.
+
+import (
+	"encoding/binary"
+	"fmt"
+	"hash/crc64"
+	"io"
+	"log"
+	"unicode/utf8"
+)
+
+// builder builds a set of tries for associating values with runes. The set of
+// tries can share common index and value blocks.
+type builder struct {
+	Name string
+
+	// ValueType is the type of the trie values looked up.
+	ValueType string
+
+	// ValueSize is the byte size of the ValueType.
+	ValueSize int
+
+	// IndexType is the type of trie index values used for all UTF-8 bytes of
+	// a rune except the last one.
+	IndexType string
+
+	// IndexSize is the byte size of the IndexType.
+	IndexSize int
+
+	// SourceType is used when generating the lookup functions. If the user
+	// requests StringSupport, all lookup functions will be generated for
+	// string input as well.
+	SourceType string
+
+	Trie []*Trie
+
+	IndexBlocks []*node
+	ValueBlocks [][]uint64
+	Compactions []compaction
+	Checksum    uint64
+
+	ASCIIBlock   string
+	StarterBlock string
+
+	indexBlockIdx map[uint64]int
+	valueBlockIdx map[uint64]nodeIndex
+	asciiBlockIdx map[uint64]int
+
+	// Stats are used to fill out the template.
+	Stats struct {
+		NValueEntries int
+		NValueBytes   int
+		NIndexEntries int
+		NIndexBytes   int
+		NHandleBytes  int
+	}
+
+	err error
+}
+
+// A nodeIndex encodes the index of a node, which is defined by the compaction
+// which stores it and an index within the compaction. For internal nodes, the
+// compaction is always 0.
+type nodeIndex struct {
+	compaction int
+	index      int
+}
+
+// compaction keeps track of stats used for the compaction.
+type compaction struct {
+	c         Compacter
+	blocks    []*node
+	maxHandle uint32
+	totalSize int
+
+	// Used by template-based generator and thus exported.
+	Cutoff  uint32
+	Offset  uint32
+	Handler string
+}
+
+func (b *builder) setError(err error) {
+	if b.err == nil {
+		b.err = err
+	}
+}
+
+// An Option can be passed to Gen.
+type Option func(b *builder) error
+
+// Compact configures the trie generator to use the given Compacter.
+func Compact(c Compacter) Option {
+	return func(b *builder) error {
+		b.Compactions = append(b.Compactions, compaction{
+			c:       c,
+			Handler: c.Handler() + "(n, b)"})
+		return nil
+	}
+}
+
+// Gen writes Go code for a shared trie lookup structure to w for the given
+// Tries. The generated trie type will be called nameTrie. newNameTrie(x) will
+// return the *nameTrie for tries[x]. A value can be looked up by using one of
+// the various lookup methods defined on nameTrie. It returns the table size of
+// the generated trie.
+func Gen(w io.Writer, name string, tries []*Trie, opts ...Option) (sz int, err error) {
+	// The index contains two dummy blocks, followed by the zero block. The zero
+	// block is at offset 0x80, so that the offset for the zero block for
+	// continuation bytes is 0.
+	b := &builder{
+		Name:        name,
+		Trie:        tries,
+		IndexBlocks: []*node{{}, {}, {}},
+		Compactions: []compaction{{
+			Handler: name + "Values[n<<6+uint32(b)]",
+		}},
+		// The 0 key in indexBlockIdx and valueBlockIdx is the hash of the zero
+		// block.
+		indexBlockIdx: map[uint64]int{0: 0},
+		valueBlockIdx: map[uint64]nodeIndex{0: {}},
+		asciiBlockIdx: map[uint64]int{},
+	}
+	b.Compactions[0].c = (*simpleCompacter)(b)
+
+	for _, f := range opts {
+		if err := f(b); err != nil {
+			return 0, err
+		}
+	}
+	b.build()
+	if b.err != nil {
+		return 0, b.err
+	}
+	if err = b.print(w); err != nil {
+		return 0, err
+	}
+	return b.Size(), nil
+}
+
+// A Trie represents a single root node of a trie. A builder may build several
+// overlapping tries at once.
+type Trie struct {
+	root *node
+
+	hiddenTrie
+}
+
+// hiddenTrie contains values we want to be visible to the template generator,
+// but hidden from the API documentation.
+type hiddenTrie struct {
+	Name         string
+	Checksum     uint64
+	ASCIIIndex   int
+	StarterIndex int
+}
+
+// NewTrie returns a new trie root.
+func NewTrie(name string) *Trie {
+	return &Trie{
+		&node{
+			children: make([]*node, blockSize),
+			values:   make([]uint64, utf8.RuneSelf),
+		},
+		hiddenTrie{Name: name},
+	}
+}
+
+// Gen is a convenience wrapper around the Gen func passing t as the only trie
+// and uses the name passed to NewTrie. It returns the size of the generated
+// tables.
+func (t *Trie) Gen(w io.Writer, opts ...Option) (sz int, err error) {
+	return Gen(w, t.Name, []*Trie{t}, opts...)
+}
+
+// node is a node of the intermediate trie structure.
+type node struct {
+	// children holds this node's children. It is always of length 64.
+	// A child node may be nil.
+	children []*node
+
+	// values contains the values of this node. If it is non-nil, this node is
+	// either a root or leaf node:
+	// For root nodes, len(values) == 128 and it maps the bytes in [0x00, 0x7F].
+	// For leaf nodes, len(values) ==  64 and it maps the bytes in [0x80, 0xBF].
+	values []uint64
+
+	index nodeIndex
+}
+
+// Insert associates value with the given rune. Insert will panic if a non-zero
+// value is passed for an invalid rune.
+func (t *Trie) Insert(r rune, value uint64) {
+	if value == 0 {
+		return
+	}
+	s := string(r)
+	if []rune(s)[0] != r && value != 0 {
+		// Note: The UCD tables will always assign what amounts to a zero value
+		// to a surrogate. Allowing a zero value for an illegal rune allows
+		// users to iterate over [0..MaxRune] without having to explicitly
+		// exclude surrogates, which would be tedious.
+		panic(fmt.Sprintf("triegen: non-zero value for invalid rune %U", r))
+	}
+	if len(s) == 1 {
+		// It is a root node value (ASCII).
+		t.root.values[s[0]] = value
+		return
+	}
+
+	n := t.root
+	for ; len(s) > 1; s = s[1:] {
+		if n.children == nil {
+			n.children = make([]*node, blockSize)
+		}
+		p := s[0] % blockSize
+		c := n.children[p]
+		if c == nil {
+			c = &node{}
+			n.children[p] = c
+		}
+		if len(s) > 2 && c.values != nil {
+			log.Fatalf("triegen: insert(%U): found internal node with values", r)
+		}
+		n = c
+	}
+	if n.values == nil {
+		n.values = make([]uint64, blockSize)
+	}
+	if n.children != nil {
+		log.Fatalf("triegen: insert(%U): found leaf node that also has child nodes", r)
+	}
+	n.values[s[0]-0x80] = value
+}
+
+// Size returns the number of bytes the generated trie will take to store. It
+// needs to be exported as it is used in the templates.
+func (b *builder) Size() int {
+	// Index blocks.
+	sz := len(b.IndexBlocks) * blockSize * b.IndexSize
+
+	// Skip the first compaction, which represents the normal value blocks, as
+	// its totalSize does not account for the ASCII blocks, which are managed
+	// separately.
+	sz += len(b.ValueBlocks) * blockSize * b.ValueSize
+	for _, c := range b.Compactions[1:] {
+		sz += c.totalSize
+	}
+
+	// TODO: this computation does not account for the fixed overhead of a using
+	// a compaction, either code or data. As for data, though, the typical
+	// overhead of data is in the order of bytes (2 bytes for cases). Further,
+	// the savings of using a compaction should anyway be substantial for it to
+	// be worth it.
+
+	// For multi-root tries, we also need to account for the handles.
+	if len(b.Trie) > 1 {
+		sz += 2 * b.IndexSize * len(b.Trie)
+	}
+	return sz
+}
+
+func (b *builder) build() {
+	// Compute the sizes of the values.
+	var vmax uint64
+	for _, t := range b.Trie {
+		vmax = maxValue(t.root, vmax)
+	}
+	b.ValueType, b.ValueSize = getIntType(vmax)
+
+	// Compute all block allocations.
+	// TODO: first compute the ASCII blocks for all tries and then the other
+	// nodes. ASCII blocks are more restricted in placement, as they require two
+	// blocks to be placed consecutively. Processing them first may improve
+	// sharing (at least one zero block can be expected to be saved.)
+	for _, t := range b.Trie {
+		b.Checksum += b.buildTrie(t)
+	}
+
+	// Compute the offsets for all the Compacters.
+	offset := uint32(0)
+	for i := range b.Compactions {
+		c := &b.Compactions[i]
+		c.Offset = offset
+		offset += c.maxHandle + 1
+		c.Cutoff = offset
+	}
+
+	// Compute the sizes of indexes.
+	// TODO: different byte positions could have different sizes. So far we have
+	// not found a case where this is beneficial.
+	imax := uint64(b.Compactions[len(b.Compactions)-1].Cutoff)
+	for _, ib := range b.IndexBlocks {
+		if x := uint64(ib.index.index); x > imax {
+			imax = x
+		}
+	}
+	b.IndexType, b.IndexSize = getIntType(imax)
+}
+
+func maxValue(n *node, max uint64) uint64 {
+	if n == nil {
+		return max
+	}
+	for _, c := range n.children {
+		max = maxValue(c, max)
+	}
+	for _, v := range n.values {
+		if max < v {
+			max = v
+		}
+	}
+	return max
+}
+
+func getIntType(v uint64) (string, int) {
+	switch {
+	case v < 1<<8:
+		return "uint8", 1
+	case v < 1<<16:
+		return "uint16", 2
+	case v < 1<<32:
+		return "uint32", 4
+	}
+	return "uint64", 8
+}
+
+const (
+	blockSize = 64
+
+	// Subtract two blocks to offset 0x80, the first continuation byte.
+	blockOffset = 2
+
+	// Subtract three blocks to offset 0xC0, the first non-ASCII starter.
+	rootBlockOffset = 3
+)
+
+var crcTable = crc64.MakeTable(crc64.ISO)
+
+func (b *builder) buildTrie(t *Trie) uint64 {
+	n := t.root
+
+	// Get the ASCII offset. For the first trie, the ASCII block will be at
+	// position 0.
+	hasher := crc64.New(crcTable)
+	binary.Write(hasher, binary.BigEndian, n.values)
+	hash := hasher.Sum64()
+
+	v, ok := b.asciiBlockIdx[hash]
+	if !ok {
+		v = len(b.ValueBlocks)
+		b.asciiBlockIdx[hash] = v
+
+		b.ValueBlocks = append(b.ValueBlocks, n.values[:blockSize], n.values[blockSize:])
+		if v == 0 {
+			// Add the zero block at position 2 so that it will be assigned a
+			// zero reference in the lookup blocks.
+			// TODO: always do this? This would allow us to remove a check from
+			// the trie lookup, but at the expense of extra space. Analyze
+			// performance for unicode/norm.
+			b.ValueBlocks = append(b.ValueBlocks, make([]uint64, blockSize))
+		}
+	}
+	t.ASCIIIndex = v
+
+	// Compute remaining offsets.
+	t.Checksum = b.computeOffsets(n, true)
+	// We already subtracted the normal blockOffset from the index. Subtract the
+	// difference for starter bytes.
+	t.StarterIndex = n.index.index - (rootBlockOffset - blockOffset)
+	return t.Checksum
+}
+
+func (b *builder) computeOffsets(n *node, root bool) uint64 {
+	// For the first trie, the root lookup block will be at position 3, which is
+	// the offset for UTF-8 non-ASCII starter bytes.
+	first := len(b.IndexBlocks) == rootBlockOffset
+	if first {
+		b.IndexBlocks = append(b.IndexBlocks, n)
+	}
+
+	// We special-case the cases where all values recursively are 0. This allows
+	// for the use of a zero block to which all such values can be directed.
+	hash := uint64(0)
+	if n.children != nil || n.values != nil {
+		hasher := crc64.New(crcTable)
+		for _, c := range n.children {
+			var v uint64
+			if c != nil {
+				v = b.computeOffsets(c, false)
+			}
+			binary.Write(hasher, binary.BigEndian, v)
+		}
+		binary.Write(hasher, binary.BigEndian, n.values)
+		hash = hasher.Sum64()
+	}
+
+	if first {
+		b.indexBlockIdx[hash] = rootBlockOffset - blockOffset
+	}
+
+	// Compacters don't apply to internal nodes.
+	if n.children != nil {
+		v, ok := b.indexBlockIdx[hash]
+		if !ok {
+			v = len(b.IndexBlocks) - blockOffset
+			b.IndexBlocks = append(b.IndexBlocks, n)
+			b.indexBlockIdx[hash] = v
+		}
+		n.index = nodeIndex{0, v}
+	} else {
+		h, ok := b.valueBlockIdx[hash]
+		if !ok {
+			bestI, bestSize := 0, blockSize*b.ValueSize
+			for i, c := range b.Compactions[1:] {
+				if sz, ok := c.c.Size(n.values); ok && bestSize > sz {
+					bestI, bestSize = i+1, sz
+				}
+			}
+			c := &b.Compactions[bestI]
+			c.totalSize += bestSize
+			v := c.c.Store(n.values)
+			if c.maxHandle < v {
+				c.maxHandle = v
+			}
+			h = nodeIndex{bestI, int(v)}
+			b.valueBlockIdx[hash] = h
+		}
+		n.index = h
+	}
+	return hash
+}

vendor/golang.org/x/text/internal/ucd/ucd.go

@@ -0,0 +1,371 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package ucd provides a parser for Unicode Character Database files, the
+// format of which is defined in http://www.unicode.org/reports/tr44/. See
+// http://www.unicode.org/Public/UCD/latest/ucd/ for example files.
+//
+// It currently does not support substitutions of missing fields.
+package ucd // import "golang.org/x/text/internal/ucd"
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// UnicodeData.txt fields.
+const (
+	CodePoint = iota
+	Name
+	GeneralCategory
+	CanonicalCombiningClass
+	BidiClass
+	DecompMapping
+	DecimalValue
+	DigitValue
+	NumericValue
+	BidiMirrored
+	Unicode1Name
+	ISOComment
+	SimpleUppercaseMapping
+	SimpleLowercaseMapping
+	SimpleTitlecaseMapping
+)
+
+// Parse calls f for each entry in the given reader of a UCD file. It will close
+// the reader upon return. It will call log.Fatal if any error occurred.
+//
+// This implements the most common usage pattern of using Parser.
+func Parse(r io.ReadCloser, f func(p *Parser)) {
+	defer r.Close()
+
+	p := New(r)
+	for p.Next() {
+		f(p)
+	}
+	if err := p.Err(); err != nil {
+		r.Close() // os.Exit will cause defers not to be called.
+		log.Fatal(err)
+	}
+}
+
+// An Option is used to configure a Parser.
+type Option func(p *Parser)
+
+func keepRanges(p *Parser) {
+	p.keepRanges = true
+}
+
+var (
+	// KeepRanges prevents the expansion of ranges. The raw ranges can be
+	// obtained by calling Range(0) on the parser.
+	KeepRanges Option = keepRanges
+)
+
+// The Part option register a handler for lines starting with a '@'. The text
+// after a '@' is available as the first field. Comments are handled as usual.
+func Part(f func(p *Parser)) Option {
+	return func(p *Parser) {
+		p.partHandler = f
+	}
+}
+
+// The CommentHandler option passes comments that are on a line by itself to
+// a given handler.
+func CommentHandler(f func(s string)) Option {
+	return func(p *Parser) {
+		p.commentHandler = f
+	}
+}
+
+// A Parser parses Unicode Character Database (UCD) files.
+type Parser struct {
+	scanner *bufio.Scanner
+
+	keepRanges bool // Don't expand rune ranges in field 0.
+
+	err     error
+	comment string
+	field   []string
+	// parsedRange is needed in case Range(0) is called more than once for one
+	// field. In some cases this requires scanning ahead.
+	line                 int
+	parsedRange          bool
+	rangeStart, rangeEnd rune
+
+	partHandler    func(p *Parser)
+	commentHandler func(s string)
+}
+
+func (p *Parser) setError(err error, msg string) {
+	if p.err == nil && err != nil {
+		if msg == "" {
+			p.err = fmt.Errorf("ucd:line:%d: %v", p.line, err)
+		} else {
+			p.err = fmt.Errorf("ucd:line:%d:%s: %v", p.line, msg, err)
+		}
+	}
+}
+
+func (p *Parser) getField(i int) string {
+	if i >= len(p.field) {
+		return ""
+	}
+	return p.field[i]
+}
+
+// Err returns a non-nil error if any error occurred during parsing.
+func (p *Parser) Err() error {
+	return p.err
+}
+
+// New returns a Parser for the given Reader.
+func New(r io.Reader, o ...Option) *Parser {
+	p := &Parser{
+		scanner: bufio.NewScanner(r),
+	}
+	for _, f := range o {
+		f(p)
+	}
+	return p
+}
+
+// Next parses the next line in the file. It returns true if a line was parsed
+// and false if it reached the end of the file.
+func (p *Parser) Next() bool {
+	if !p.keepRanges && p.rangeStart < p.rangeEnd {
+		p.rangeStart++
+		return true
+	}
+	p.comment = ""
+	p.field = p.field[:0]
+	p.parsedRange = false
+
+	for p.scanner.Scan() && p.err == nil {
+		p.line++
+		s := p.scanner.Text()
+		if s == "" {
+			continue
+		}
+		if s[0] == '#' {
+			if p.commentHandler != nil {
+				p.commentHandler(strings.TrimSpace(s[1:]))
+			}
+			continue
+		}
+
+		// Parse line
+		if i := strings.IndexByte(s, '#'); i != -1 {
+			p.comment = strings.TrimSpace(s[i+1:])
+			s = s[:i]
+		}
+		if s[0] == '@' {
+			if p.partHandler != nil {
+				p.field = append(p.field, strings.TrimSpace(s[1:]))
+				p.partHandler(p)
+				p.field = p.field[:0]
+			}
+			p.comment = ""
+			continue
+		}
+		for {
+			i := strings.IndexByte(s, ';')
+			if i == -1 {
+				p.field = append(p.field, strings.TrimSpace(s))
+				break
+			}
+			p.field = append(p.field, strings.TrimSpace(s[:i]))
+			s = s[i+1:]
+		}
+		if !p.keepRanges {
+			p.rangeStart, p.rangeEnd = p.getRange(0)
+		}
+		return true
+	}
+	p.setError(p.scanner.Err(), "scanner failed")
+	return false
+}
+
+func parseRune(b string) (rune, error) {
+	if len(b) > 2 && b[0] == 'U' && b[1] == '+' {
+		b = b[2:]
+	}
+	x, err := strconv.ParseUint(b, 16, 32)
+	return rune(x), err
+}
+
+func (p *Parser) parseRune(s string) rune {
+	x, err := parseRune(s)
+	p.setError(err, "failed to parse rune")
+	return x
+}
+
+// Rune parses and returns field i as a rune.
+func (p *Parser) Rune(i int) rune {
+	if i > 0 || p.keepRanges {
+		return p.parseRune(p.getField(i))
+	}
+	return p.rangeStart
+}
+
+// Runes interprets and returns field i as a sequence of runes.
+func (p *Parser) Runes(i int) (runes []rune) {
+	add := func(s string) {
+		if s = strings.TrimSpace(s); len(s) > 0 {
+			runes = append(runes, p.parseRune(s))
+		}
+	}
+	for b := p.getField(i); ; {
+		i := strings.IndexByte(b, ' ')
+		if i == -1 {
+			add(b)
+			break
+		}
+		add(b[:i])
+		b = b[i+1:]
+	}
+	return
+}
+
+var (
+	errIncorrectLegacyRange = errors.New("ucd: unmatched <* First>")
+
+	// reRange matches one line of a legacy rune range.
+	reRange = regexp.MustCompile("^([0-9A-F]*);<([^,]*), ([^>]*)>(.*)$")
+)
+
+// Range parses and returns field i as a rune range. A range is inclusive at
+// both ends. If the field only has one rune, first and last will be identical.
+// It supports the legacy format for ranges used in UnicodeData.txt.
+func (p *Parser) Range(i int) (first, last rune) {
+	if !p.keepRanges {
+		return p.rangeStart, p.rangeStart
+	}
+	return p.getRange(i)
+}
+
+func (p *Parser) getRange(i int) (first, last rune) {
+	b := p.getField(i)
+	if k := strings.Index(b, ".."); k != -1 {
+		return p.parseRune(b[:k]), p.parseRune(b[k+2:])
+	}
+	// The first field may not be a rune, in which case we may ignore any error
+	// and set the range as 0..0.
+	x, err := parseRune(b)
+	if err != nil {
+		// Disable range parsing henceforth. This ensures that an error will be
+		// returned if the user subsequently will try to parse this field as
+		// a Rune.
+		p.keepRanges = true
+	}
+	// Special case for UnicodeData that was retained for backwards compatibility.
+	if i == 0 && len(p.field) > 1 && strings.HasSuffix(p.field[1], "First>") {
+		if p.parsedRange {
+			return p.rangeStart, p.rangeEnd
+		}
+		mf := reRange.FindStringSubmatch(p.scanner.Text())
+		p.line++
+		if mf == nil || !p.scanner.Scan() {
+			p.setError(errIncorrectLegacyRange, "")
+			return x, x
+		}
+		// Using Bytes would be more efficient here, but Text is a lot easier
+		// and this is not a frequent case.
+		ml := reRange.FindStringSubmatch(p.scanner.Text())
+		if ml == nil || mf[2] != ml[2] || ml[3] != "Last" || mf[4] != ml[4] {
+			p.setError(errIncorrectLegacyRange, "")
+			return x, x
+		}
+		p.rangeStart, p.rangeEnd = x, p.parseRune(p.scanner.Text()[:len(ml[1])])
+		p.parsedRange = true
+		return p.rangeStart, p.rangeEnd
+	}
+	return x, x
+}
+
+// bools recognizes all valid UCD boolean values.
+var bools = map[string]bool{
+	"":      false,
+	"N":     false,
+	"No":    false,
+	"F":     false,
+	"False": false,
+	"Y":     true,
+	"Yes":   true,
+	"T":     true,
+	"True":  true,
+}
+
+// Bool parses and returns field i as a boolean value.
+func (p *Parser) Bool(i int) bool {
+	f := p.getField(i)
+	for s, v := range bools {
+		if f == s {
+			return v
+		}
+	}
+	p.setError(strconv.ErrSyntax, "error parsing bool")
+	return false
+}
+
+// Int parses and returns field i as an integer value.
+func (p *Parser) Int(i int) int {
+	x, err := strconv.ParseInt(string(p.getField(i)), 10, 64)
+	p.setError(err, "error parsing int")
+	return int(x)
+}
+
+// Uint parses and returns field i as an unsigned integer value.
+func (p *Parser) Uint(i int) uint {
+	x, err := strconv.ParseUint(string(p.getField(i)), 10, 64)
+	p.setError(err, "error parsing uint")
+	return uint(x)
+}
+
+// Float parses and returns field i as a decimal value.
+func (p *Parser) Float(i int) float64 {
+	x, err := strconv.ParseFloat(string(p.getField(i)), 64)
+	p.setError(err, "error parsing float")
+	return x
+}
+
+// String parses and returns field i as a string value.
+func (p *Parser) String(i int) string {
+	return string(p.getField(i))
+}
+
+// Strings parses and returns field i as a space-separated list of strings.
+func (p *Parser) Strings(i int) []string {
+	ss := strings.Split(string(p.getField(i)), " ")
+	for i, s := range ss {
+		ss[i] = strings.TrimSpace(s)
+	}
+	return ss
+}
+
+// Comment returns the comments for the current line.
+func (p *Parser) Comment() string {
+	return string(p.comment)
+}
+
+var errUndefinedEnum = errors.New("ucd: undefined enum value")
+
+// Enum interprets and returns field i as a value that must be one of the values
+// in enum.
+func (p *Parser) Enum(i int, enum ...string) string {
+	f := p.getField(i)
+	for _, s := range enum {
+		if f == s {
+			return s
+		}
+	}
+	p.setError(errUndefinedEnum, "error parsing enum")
+	return ""
+}

vendor/golang.org/x/text/language/common.go

@@ -0,0 +1,16 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+package language
+
+// This file contains code common to the maketables.go and the package code.
+
+// langAliasType is the type of an alias in langAliasMap.
+type langAliasType int8
+
+const (
+	langDeprecated langAliasType = iota
+	langMacro
+	langLegacy
+
+	langAliasTypeUnknown langAliasType = -1
+)

vendor/golang.org/x/text/language/coverage.go

@@ -0,0 +1,197 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package language
+
+import (
+	"fmt"
+	"sort"
+)
+
+// The Coverage interface is used to define the level of coverage of an
+// internationalization service. Note that not all types are supported by all
+// services. As lists may be generated on the fly, it is recommended that users
+// of a Coverage cache the results.
+type Coverage interface {
+	// Tags returns the list of supported tags.
+	Tags() []Tag
+
+	// BaseLanguages returns the list of supported base languages.
+	BaseLanguages() []Base
+
+	// Scripts returns the list of supported scripts.
+	Scripts() []Script
+
+	// Regions returns the list of supported regions.
+	Regions() []Region
+}
+
+var (
+	// Supported defines a Coverage that lists all supported subtags. Tags
+	// always returns nil.
+	Supported Coverage = allSubtags{}
+)
+
+// TODO:
+// - Support Variants, numbering systems.
+// - CLDR coverage levels.
+// - Set of common tags defined in this package.
+
+type allSubtags struct{}
+
+// Regions returns the list of supported regions. As all regions are in a
+// consecutive range, it simply returns a slice of numbers in increasing order.
+// The "undefined" region is not returned.
+func (s allSubtags) Regions() []Region {
+	reg := make([]Region, numRegions)
+	for i := range reg {
+		reg[i] = Region{regionID(i + 1)}
+	}
+	return reg
+}
+
+// Scripts returns the list of supported scripts. As all scripts are in a
+// consecutive range, it simply returns a slice of numbers in increasing order.
+// The "undefined" script is not returned.
+func (s allSubtags) Scripts() []Script {
+	scr := make([]Script, numScripts)
+	for i := range scr {
+		scr[i] = Script{scriptID(i + 1)}
+	}
+	return scr
+}
+
+// BaseLanguages returns the list of all supported base languages. It generates
+// the list by traversing the internal structures.
+func (s allSubtags) BaseLanguages() []Base {
+	base := make([]Base, 0, numLanguages)
+	for i := 0; i < langNoIndexOffset; i++ {
+		// We included "und" already for the value 0.
+		if i != nonCanonicalUnd {
+			base = append(base, Base{langID(i)})
+		}
+	}
+	i := langNoIndexOffset
+	for _, v := range langNoIndex {
+		for k := 0; k < 8; k++ {
+			if v&1 == 1 {
+				base = append(base, Base{langID(i)})
+			}
+			v >>= 1
+			i++
+		}
+	}
+	return base
+}
+
+// Tags always returns nil.
+func (s allSubtags) Tags() []Tag {
+	return nil
+}
+
+// coverage is used used by NewCoverage which is used as a convenient way for
+// creating Coverage implementations for partially defined data. Very often a
+// package will only need to define a subset of slices. coverage provides a
+// convenient way to do this. Moreover, packages using NewCoverage, instead of
+// their own implementation, will not break if later new slice types are added.
+type coverage struct {
+	tags    func() []Tag
+	bases   func() []Base
+	scripts func() []Script
+	regions func() []Region
+}
+
+func (s *coverage) Tags() []Tag {
+	if s.tags == nil {
+		return nil
+	}
+	return s.tags()
+}
+
+// bases implements sort.Interface and is used to sort base languages.
+type bases []Base
+
+func (b bases) Len() int {
+	return len(b)
+}
+
+func (b bases) Swap(i, j int) {
+	b[i], b[j] = b[j], b[i]
+}
+
+func (b bases) Less(i, j int) bool {
+	return b[i].langID < b[j].langID
+}
+
+// BaseLanguages returns the result from calling s.bases if it is specified or
+// otherwise derives the set of supported base languages from tags.
+func (s *coverage) BaseLanguages() []Base {
+	if s.bases == nil {
+		tags := s.Tags()
+		if len(tags) == 0 {
+			return nil
+		}
+		a := make([]Base, len(tags))
+		for i, t := range tags {
+			a[i] = Base{langID(t.lang)}
+		}
+		sort.Sort(bases(a))
+		k := 0
+		for i := 1; i < len(a); i++ {
+			if a[k] != a[i] {
+				k++
+				a[k] = a[i]
+			}
+		}
+		return a[:k+1]
+	}
+	return s.bases()
+}
+
+func (s *coverage) Scripts() []Script {
+	if s.scripts == nil {
+		return nil
+	}
+	return s.scripts()
+}
+
+func (s *coverage) Regions() []Region {
+	if s.regions == nil {
+		return nil
+	}
+	return s.regions()
+}
+
+// NewCoverage returns a Coverage for the given lists. It is typically used by
+// packages providing internationalization services to define their level of
+// coverage. A list may be of type []T or func() []T, where T is either Tag,
+// Base, Script or Region. The returned Coverage derives the value for Bases
+// from Tags if no func or slice for []Base is specified. For other unspecified
+// types the returned Coverage will return nil for the respective methods.
+func NewCoverage(list ...interface{}) Coverage {
+	s := &coverage{}
+	for _, x := range list {
+		switch v := x.(type) {
+		case func() []Base:
+			s.bases = v
+		case func() []Script:
+			s.scripts = v
+		case func() []Region:
+			s.regions = v
+		case func() []Tag:
+			s.tags = v
+		case []Base:
+			s.bases = func() []Base { return v }
+		case []Script:
+			s.scripts = func() []Script { return v }
+		case []Region:
+			s.regions = func() []Region { return v }
+		case []Tag:
+			s.tags = func() []Tag { return v }
+		default:
+			panic(fmt.Sprintf("language: unsupported set type %T", v))
+		}
+	}
+	return s
+}

vendor/golang.org/x/text/language/doc.go

@@ -0,0 +1,102 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package language implements BCP 47 language tags and related functionality.
+//
+// The most important function of package language is to match a list of
+// user-preferred languages to a list of supported languages.
+// It alleviates the developer of dealing with the complexity of this process
+// and provides the user with the best experience
+// (see https://blog.golang.org/matchlang).
+//
+//
+// Matching preferred against supported languages
+//
+// A Matcher for an application that supports English, Australian English,
+// Danish, and standard Mandarin can be created as follows:
+//
+//    var matcher = language.NewMatcher([]language.Tag{
+//        language.English,   // The first language is used as fallback.
+//        language.MustParse("en-AU"),
+//        language.Danish,
+//        language.Chinese,
+//    })
+//
+// This list of supported languages is typically implied by the languages for
+// which there exists translations of the user interface.
+//
+// User-preferred languages usually come as a comma-separated list of BCP 47
+// language tags.
+// The MatchString finds best matches for such strings:
+//
+//    handler(w http.ResponseWriter, r *http.Request) {
+//        lang, _ := r.Cookie("lang")
+//        accept := r.Header.Get("Accept-Language")
+//        tag, _ := language.MatchStrings(matcher, lang.String(), accept)
+//
+//        // tag should now be used for the initialization of any
+//        // locale-specific service.
+//    }
+//
+// The Matcher's Match method can be used to match Tags directly.
+//
+// Matchers are aware of the intricacies of equivalence between languages, such
+// as deprecated subtags, legacy tags, macro languages, mutual
+// intelligibility between scripts and languages, and transparently passing
+// BCP 47 user configuration.
+// For instance, it will know that a reader of Bokmål Danish can read Norwegian
+// and will know that Cantonese ("yue") is a good match for "zh-HK".
+//
+//
+// Using match results
+//
+// To guarantee a consistent user experience to the user it is important to
+// use the same language tag for the selection of any locale-specific services.
+// For example, it is utterly confusing to substitute spelled-out numbers
+// or dates in one language in text of another language.
+// More subtly confusing is using the wrong sorting order or casing
+// algorithm for a certain language.
+//
+//    All the packages in x/text that provide locale-specific services
+//    (e.g. collate, cases) should be initialized with the tag that was
+//    obtained at the start of an interaction with the user.
+//
+// Note that Tag that is returned by Match and MatchString may differ from any
+// of the supported languages, as it may contain carried over settings from
+// the user tags.
+// This may be inconvenient when your application has some additional
+// locale-specific data for your supported languages.
+// Match and MatchString both return the index of the matched supported tag
+// to simplify associating such data with the matched tag.
+//
+//
+// Canonicalization
+//
+// If one uses the Matcher to compare languages one does not need to
+// worry about canonicalization.
+//
+// The meaning of a Tag varies per application. The language package
+// therefore delays canonicalization and preserves information as much
+// as possible. The Matcher, however, will always take into account that
+// two different tags may represent the same language.
+//
+// By default, only legacy and deprecated tags are converted into their
+// canonical equivalent. All other information is preserved. This approach makes
+// the confidence scores more accurate and allows matchers to distinguish
+// between variants that are otherwise lost.
+//
+// As a consequence, two tags that should be treated as identical according to
+// BCP 47 or CLDR, like "en-Latn" and "en", will be represented differently. The
+// Matcher handles such distinctions, though, and is aware of the
+// equivalence relations. The CanonType type can be used to alter the
+// canonicalization form.
+//
+// References
+//
+// BCP 47 - Tags for Identifying Languages http://tools.ietf.org/html/bcp47
+//
+package language // import "golang.org/x/text/language"
+
+// TODO: explanation on how to match languages for your own locale-specific
+// service.