Merge pull request #2609 from QiWang19/moveformats

move formats pkg to and vendor from buildah

3 files changed, 0 insertions, 291 deletions

diff --git a/cmd/podman/formats/formats.go b/cmd/podman/formats/formats.go
deleted file mode 100644
index 37f9b8a20..000000000
--- a/cmd/podman/formats/formats.go
+++ /dev/null
@@ -1,171 +0,0 @@
-package formats
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"os"
-	"strings"
-	"text/tabwriter"
-	"text/template"
-
-	"github.com/ghodss/yaml"
-	"github.com/pkg/errors"
-	"golang.org/x/crypto/ssh/terminal"
-)
-
-const (
-	// JSONString const to save on duplicate variable names
-	JSONString = "json"
-	// IDString const to save on duplicates for Go templates
-	IDString = "{{.ID}}"
-
-	parsingErrorStr = "Template parsing error"
-)
-
-// Writer interface for outputs
-type Writer interface {
-	Out() error
-}
-
-// JSONStructArray for JSON output
-type JSONStructArray struct {
-	Output []interface{}
-}
-
-// StdoutTemplateArray for Go template output
-type StdoutTemplateArray struct {
-	Output   []interface{}
-	Template string
-	Fields   map[string]string
-}
-
-// JSONStruct for JSON output
-type JSONStruct struct {
-	Output interface{}
-}
-
-// StdoutTemplate for Go template output
-type StdoutTemplate struct {
-	Output   interface{}
-	Template string
-	Fields   map[string]string
-}
-
-// YAMLStruct for YAML output
-type YAMLStruct struct {
-	Output interface{}
-}
-
-func setJSONFormatEncoder(isTerminal bool, w io.Writer) *json.Encoder {
-	enc := json.NewEncoder(w)
-	enc.SetIndent("", "    ")
-	if isTerminal {
-		enc.SetEscapeHTML(false)
-	}
-	return enc
-}
-
-// Out method for JSON Arrays
-func (j JSONStructArray) Out() error {
-	buf := bytes.NewBuffer(nil)
-	enc := setJSONFormatEncoder(terminal.IsTerminal(int(os.Stdout.Fd())), buf)
-	if err := enc.Encode(j.Output); err != nil {
-		return err
-	}
-	data := buf.Bytes()
-
-	// JSON returns a byte array with a literal null [110 117 108 108] in it
-	// if it is passed empty data.  We used bytes.Compare to see if that is
-	// the case.
-	if diff := bytes.Compare(data, []byte("null")); diff == 0 {
-		data = []byte("[]")
-	}
-
-	// If the we did get NULL back, we should spit out {} which is
-	// at least valid JSON for the consumer.
-	fmt.Printf("%s", data)
-	humanNewLine()
-	return nil
-}
-
-// Out method for Go templates
-func (t StdoutTemplateArray) Out() error {
-	w := tabwriter.NewWriter(os.Stdout, 0, 0, 3, ' ', 0)
-	if strings.HasPrefix(t.Template, "table") {
-		// replace any spaces with tabs in template so that tabwriter can align it
-		t.Template = strings.Replace(strings.TrimSpace(t.Template[5:]), " ", "\t", -1)
-		headerTmpl, err := template.New("header").Funcs(headerFunctions).Parse(t.Template)
-		if err != nil {
-			return errors.Wrapf(err, parsingErrorStr)
-		}
-		err = headerTmpl.Execute(w, t.Fields)
-		if err != nil {
-			return err
-		}
-		fmt.Fprintln(w, "")
-	}
-	t.Template = strings.Replace(t.Template, " ", "\t", -1)
-	tmpl, err := template.New("image").Funcs(basicFunctions).Parse(t.Template)
-	if err != nil {
-		return errors.Wrapf(err, parsingErrorStr)
-	}
-	for i, raw := range t.Output {
-		basicTmpl := tmpl.Funcs(basicFunctions)
-		if err := basicTmpl.Execute(w, raw); err != nil {
-			return errors.Wrapf(err, parsingErrorStr)
-		}
-		if i != len(t.Output)-1 {
-			fmt.Fprintln(w, "")
-			continue
-		}
-	}
-	fmt.Fprintln(w, "")
-	return w.Flush()
-}
-
-// Out method for JSON struct
-func (j JSONStruct) Out() error {
-	data, err := json.MarshalIndent(j.Output, "", "    ")
-	if err != nil {
-		return err
-	}
-	fmt.Printf("%s", data)
-	humanNewLine()
-	return nil
-}
-
-//Out method for Go templates
-func (t StdoutTemplate) Out() error {
-	tmpl, err := template.New("image").Parse(t.Template)
-	if err != nil {
-		return errors.Wrapf(err, "template parsing error")
-	}
-	err = tmpl.Execute(os.Stdout, t.Output)
-	if err != nil {
-		return err
-	}
-	humanNewLine()
-	return nil
-}
-
-// Out method for YAML
-func (y YAMLStruct) Out() error {
-	var buf []byte
-	var err error
-	buf, err = yaml.Marshal(y.Output)
-	if err != nil {
-		return err
-	}
-	fmt.Printf("%s", string(buf))
-	humanNewLine()
-	return nil
-}
-
-// humanNewLine prints a new line at the end of the output only if stdout is the terminal
-func humanNewLine() {
-	if terminal.IsTerminal(int(os.Stdout.Fd())) {
-		fmt.Println()
-	}
-}
diff --git a/cmd/podman/formats/formats_test.go b/cmd/podman/formats/formats_test.go
deleted file mode 100644
index c75109d65..000000000
--- a/cmd/podman/formats/formats_test.go
+++ /dev/null
@@ -1,42 +0,0 @@
-package formats
-
-import (
-	"bytes"
-	"strings"
-	"testing"
-
-	"github.com/containers/libpod/pkg/inspect"
-)
-
-func TestSetJSONFormatEncoder(t *testing.T) {
-	tt := []struct {
-		name       string
-		imageData  *inspect.ImageData
-		expected   string
-		isTerminal bool
-	}{
-		{
-			name:       "HTML tags are not escaped",
-			imageData:  &inspect.ImageData{Author: "dave <dave@corp.io>"},
-			expected:   `"Author": "dave <dave@corp.io>"`,
-			isTerminal: true,
-		},
-		{
-			name:       "HTML tags are escaped",
-			imageData:  &inspect.ImageData{Author: "dave <dave@corp.io>"},
-			expected:   `"Author": "dave \u003cdave@corp.io\u003e"`,
-			isTerminal: false,
-		},
-	}
-
-	for _, tc := range tt {
-		buf := bytes.NewBuffer(nil)
-		enc := setJSONFormatEncoder(tc.isTerminal, buf)
-		if err := enc.Encode(tc.imageData); err != nil {
-			t.Errorf("test %#v failed encoding: %s", tc.name, err)
-		}
-		if !strings.Contains(buf.String(), tc.expected) {
-			t.Errorf("test %#v expected output to contain %#v. Output:\n%v\n", tc.name, tc.expected, buf.String())
-		}
-	}
-}
diff --git a/cmd/podman/formats/templates.go b/cmd/podman/formats/templates.go
deleted file mode 100644
index c2582552a..000000000
--- a/cmd/podman/formats/templates.go
+++ /dev/null
@@ -1,78 +0,0 @@
-package formats
-
-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]
-}