@@ -2,7 +2,6 @@

 package awslogs

 import (

-	"bytes"

 	"fmt"

 	"os"

 	"regexp"

@@ -22,7 +21,6 @@ import (

 	"github.com/docker/docker/daemon/logger"

 	"github.com/docker/docker/daemon/logger/loggerutils"

 	"github.com/docker/docker/dockerversion"

-	"github.com/docker/docker/pkg/templates"

 	"github.com/pkg/errors"

 	"github.com/sirupsen/logrus"

 )

@@ -194,19 +192,6 @@ var strftimeToRegex = map[string]string{

 	/*milliseconds          */ `%L`: `\.\d{3}`,

 }

-func parseLogGroup(info logger.Info, groupTemplate string) (string, error) {

-	tmpl, err := templates.NewParse("log-group", groupTemplate)

-	if err != nil {

-		return "", err

-	}

-	buf := new(bytes.Buffer)

-	if err := tmpl.Execute(buf, &info); err != nil {

-		return "", err

-	}

-

-	return buf.String(), nil

-}

-

 // newRegionFinder is a variable such that the implementation

 // can be swapped out for unit tests.

 var newRegionFinder = func() regionFinder {

@@ -4,7 +4,7 @@ import (

 	"bytes"

 	"github.com/docker/docker/daemon/logger"

-	"github.com/docker/docker/pkg/templates"

+	"github.com/docker/docker/daemon/logger/templates"

 )

 // DefaultTemplate defines the defaults template logger should use.

new file mode 100644

@@ -0,0 +1,50 @@

+package templates

+

+import (

+	"bytes"

+	"encoding/json"

+	"strings"

+	"text/template"

+)

+

+// basicFunctions are the set of initial

+// functions provided to every template.

+var basicFunctions = template.FuncMap{

+	"json": func(v interface{}) string {

+		buf := &bytes.Buffer{}

+		enc := json.NewEncoder(buf)

+		enc.SetEscapeHTML(false)

+		enc.Encode(v)

+		// Remove the trailing new line added by the encoder

+		return strings.TrimSpace(buf.String())

+	},

+	"split":    strings.Split,

+	"join":     strings.Join,

+	"title":    strings.Title,

+	"lower":    strings.ToLower,

+	"upper":    strings.ToUpper,

+	"pad":      padWithSpace,

+	"truncate": truncateWithLength,

+}

+

+// NewParse creates a new tagged template with the basic functions

+// and parses the given format.

+func NewParse(tag, format string) (*template.Template, error) {

+	return template.New(tag).Funcs(basicFunctions).Parse(format)

+}

+

+// padWithSpace adds whitespace to the input if the input is non-empty

+func padWithSpace(source string, prefix, suffix int) string {

+	if source == "" {

+		return source

+	}

+	return strings.Repeat(" ", prefix) + source + strings.Repeat(" ", suffix)

+}

+

+// truncateWithLength truncates the source string up to the length provided by the input

+func truncateWithLength(source string, length int) string {

+	if len(source) < length {

+		return source

+	}

+	return source[:length]

+}

new file mode 100644

@@ -0,0 +1,18 @@

+package templates

+

+import (

+	"bytes"

+	"testing"

+

+	"github.com/stretchr/testify/assert"

+)

+

+func TestNewParse(t *testing.T) {

+	tm, err := NewParse("foo", "this is a {{ . }}")

+	assert.NoError(t, err)

+

+	var b bytes.Buffer

+	assert.NoError(t, tm.Execute(&b, "string"))

+	want := "this is a string"

+	assert.Equal(t, want, b.String())

+}

deleted file mode 100644

@@ -1,78 +0,0 @@

-package templates

-

-import (

-	"bytes"

-	"encoding/json"

-	"strings"

-	"text/template"

-)

-

-// basicFunctions are the set of initial

-// functions provided to every template.

-var basicFunctions = template.FuncMap{

-	"json": func(v interface{}) string {

-		buf := &bytes.Buffer{}

-		enc := json.NewEncoder(buf)

-		enc.SetEscapeHTML(false)

-		enc.Encode(v)

-		// Remove the trailing new line added by the encoder

-		return strings.TrimSpace(buf.String())

-	},

-	"split":    strings.Split,

-	"join":     strings.Join,

-	"title":    strings.Title,

-	"lower":    strings.ToLower,

-	"upper":    strings.ToUpper,

-	"pad":      padWithSpace,

-	"truncate": truncateWithLength,

-}

-

-// HeaderFunctions are used to created headers of a table.

-// This is a replacement of basicFunctions for header generation

-// because we want the header to remain intact.

-// Some functions like `split` are irrelevant so not added.

-var HeaderFunctions = template.FuncMap{

-	"json": func(v string) string {

-		return v

-	},

-	"title": func(v string) string {

-		return v

-	},

-	"lower": func(v string) string {

-		return v

-	},

-	"upper": func(v string) string {

-		return v

-	},

-	"truncate": func(v string, l int) string {

-		return v

-	},

-}

-

-// Parse creates a new anonymous template with the basic functions

-// and parses the given format.

-func Parse(format string) (*template.Template, error) {

-	return NewParse("", format)

-}

-

-// NewParse creates a new tagged template with the basic functions

-// and parses the given format.

-func NewParse(tag, format string) (*template.Template, error) {

-	return template.New(tag).Funcs(basicFunctions).Parse(format)

-}

-

-// padWithSpace adds whitespace to the input if the input is non-empty

-func padWithSpace(source string, prefix, suffix int) string {

-	if source == "" {

-		return source

-	}

-	return strings.Repeat(" ", prefix) + source + strings.Repeat(" ", suffix)

-}

-

-// truncateWithLength truncates the source string up to the length provided by the input

-func truncateWithLength(source string, length int) string {

-	if len(source) < length {

-		return source

-	}

-	return source[:length]

-}

deleted file mode 100644

@@ -1,88 +0,0 @@

-package templates

-

-import (

-	"bytes"

-	"testing"

-

-	"github.com/stretchr/testify/assert"

-)

-

-// Github #32120

-func TestParseJSONFunctions(t *testing.T) {

-	tm, err := Parse(`{{json .Ports}}`)

-	assert.NoError(t, err)

-

-	var b bytes.Buffer

-	assert.NoError(t, tm.Execute(&b, map[string]string{"Ports": "0.0.0.0:2->8/udp"}))

-	want := "\"0.0.0.0:2->8/udp\""

-	assert.Equal(t, want, b.String())

-}

-

-func TestParseStringFunctions(t *testing.T) {

-	tm, err := Parse(`{{join (split . ":") "/"}}`)

-	assert.NoError(t, err)

-

-	var b bytes.Buffer

-	assert.NoError(t, tm.Execute(&b, "text:with:colon"))

-	want := "text/with/colon"

-	assert.Equal(t, want, b.String())

-}

-

-func TestNewParse(t *testing.T) {

-	tm, err := NewParse("foo", "this is a {{ . }}")

-	assert.NoError(t, err)

-

-	var b bytes.Buffer

-	assert.NoError(t, tm.Execute(&b, "string"))

-	want := "this is a string"

-	assert.Equal(t, want, b.String())

-}

-

-func TestParseTruncateFunction(t *testing.T) {

-	source := "tupx5xzf6hvsrhnruz5cr8gwp"

-

-	testCases := []struct {

-		template string

-		expected string

-	}{

-		{

-			template: `{{truncate . 5}}`,

-			expected: "tupx5",

-		},

-		{

-			template: `{{truncate . 25}}`,

-			expected: "tupx5xzf6hvsrhnruz5cr8gwp",

-		},

-		{

-			template: `{{truncate . 30}}`,

-			expected: "tupx5xzf6hvsrhnruz5cr8gwp",

-		},

-		{

-			template: `{{pad . 3 3}}`,

-			expected: "   tupx5xzf6hvsrhnruz5cr8gwp   ",

-		},

-	}

-

-	for _, testCase := range testCases {

-		tm, err := Parse(testCase.template)

-		assert.NoError(t, err)

-

-		t.Run("Non Empty Source Test with template: "+testCase.template, func(t *testing.T) {

-			var b bytes.Buffer

-			assert.NoError(t, tm.Execute(&b, source))

-			assert.Equal(t, testCase.expected, b.String())

-		})

-

-		t.Run("Empty Source Test with template: "+testCase.template, func(t *testing.T) {

-			var c bytes.Buffer

-			assert.NoError(t, tm.Execute(&c, ""))

-			assert.Equal(t, "", c.String())

-		})

-

-		t.Run("Nil Source Test with template: "+testCase.template, func(t *testing.T) {

-			var c bytes.Buffer

-			assert.Error(t, tm.Execute(&c, nil))

-			assert.Equal(t, "", c.String())

-		})

-	}

-}

@@ -9,9 +9,9 @@ import (

 	"os"

 	"path"

 	"strings"

+	"text/template"

 	"github.com/docker/docker/pkg/aaparser"

-	"github.com/docker/docker/pkg/templates"

 )

 var (

@@ -33,7 +33,7 @@ type profileData struct {

 // generateDefault creates an apparmor profile from ProfileData.

 func (p *profileData) generateDefault(out io.Writer) error {

-	compiled, err := templates.NewParse("apparmor_profile", baseTemplate)

+	compiled, err := template.New("apparmor_profile").Parse(baseTemplate)

 	if err != nil {

 		return err

 	}