@@ -9,29 +9,6 @@ import (

 	"strings"

 )

-// PartParser parses and validates the specified string (data) using the specified template

-// e.g. ip:public:private -> 192.168.0.1:80:8000

-func PartParser(template, data string) (map[string]string, error) {

-	// ip:public:private

-	var (

-		templateParts = strings.Split(template, ":")

-		parts         = strings.Split(data, ":")

-		out           = make(map[string]string, len(templateParts))

-	)

-	if len(parts) != len(templateParts) {

-		return nil, fmt.Errorf("Invalid format to parse. %s should match template %s", data, template)

-	}

-

-	for i, t := range templateParts {

-		value := ""

-		if len(parts) > i {

-			value = parts[i]

-		}

-		out[t] = value

-	}

-	return out, nil

-}

-

 // ParseKeyValueOpt parses and validates the specified string as a key/value pair (key=value)

 func ParseKeyValueOpt(opt string) (string, string, error) {

 	parts := strings.SplitN(opt, "=", 2)

@@ -41,32 +18,6 @@ func ParseKeyValueOpt(opt string) (string, string, error) {

 	return strings.TrimSpace(parts[0]), strings.TrimSpace(parts[1]), nil

 }

-// ParsePortRange parses and validates the specified string as a port-range (8000-9000)

-func ParsePortRange(ports string) (uint64, uint64, error) {

-	if ports == "" {

-		return 0, 0, fmt.Errorf("Empty string specified for ports.")

-	}

-	if !strings.Contains(ports, "-") {

-		start, err := strconv.ParseUint(ports, 10, 16)

-		end := start

-		return start, end, err

-	}

-

-	parts := strings.Split(ports, "-")

-	start, err := strconv.ParseUint(parts[0], 10, 16)

-	if err != nil {

-		return 0, 0, err

-	}

-	end, err := strconv.ParseUint(parts[1], 10, 16)

-	if err != nil {

-		return 0, 0, err

-	}

-	if end < start {

-		return 0, 0, fmt.Errorf("Invalid range specified for the Port: %s", ports)

-	}

-	return start, end, nil

-}

-

 // ParseUintList parses and validates the specified string as the value

 // found in some cgroup file (e.g. `cpuset.cpus`, `cpuset.mems`), which could be

 // one of the formats below. Note that duplicates are actually allowed in the

@@ -2,7 +2,6 @@ package parsers

 import (

 	"reflect"

-	"strings"

 	"testing"

 )

@@ -33,54 +32,6 @@ func TestParseKeyValueOpt(t *testing.T) {

 	}

 }

-func TestParsePortRange(t *testing.T) {

-	if start, end, err := ParsePortRange("8000-8080"); err != nil || start != 8000 || end != 8080 {

-		t.Fatalf("Error: %s or Expecting {start,end} values {8000,8080} but found {%d,%d}.", err, start, end)

-	}

-}

-

-func TestParsePortRangeEmpty(t *testing.T) {

-	if _, _, err := ParsePortRange(""); err == nil || err.Error() != "Empty string specified for ports." {

-		t.Fatalf("Expected error 'Empty string specified for ports.', got %v", err)

-	}

-}

-

-func TestParsePortRangeWithNoRange(t *testing.T) {

-	start, end, err := ParsePortRange("8080")

-	if err != nil {

-		t.Fatal(err)

-	}

-	if start != 8080 || end != 8080 {

-		t.Fatalf("Expected start and end to be the same and equal to 8080, but were %v and %v", start, end)

-	}

-}

-

-func TestParsePortRangeIncorrectRange(t *testing.T) {

-	if _, _, err := ParsePortRange("9000-8080"); err == nil || !strings.Contains(err.Error(), "Invalid range specified for the Port") {

-		t.Fatalf("Expecting error 'Invalid range specified for the Port' but received %s.", err)

-	}

-}

-

-func TestParsePortRangeIncorrectEndRange(t *testing.T) {

-	if _, _, err := ParsePortRange("8000-a"); err == nil || !strings.Contains(err.Error(), "invalid syntax") {

-		t.Fatalf("Expecting error 'Invalid range specified for the Port' but received %s.", err)

-	}

-

-	if _, _, err := ParsePortRange("8000-30a"); err == nil || !strings.Contains(err.Error(), "invalid syntax") {

-		t.Fatalf("Expecting error 'Invalid range specified for the Port' but received %s.", err)

-	}

-}

-

-func TestParsePortRangeIncorrectStartRange(t *testing.T) {

-	if _, _, err := ParsePortRange("a-8000"); err == nil || !strings.Contains(err.Error(), "invalid syntax") {

-		t.Fatalf("Expecting error 'Invalid range specified for the Port' but received %s.", err)

-	}

-

-	if _, _, err := ParsePortRange("30a-8000"); err == nil || !strings.Contains(err.Error(), "invalid syntax") {

-		t.Fatalf("Expecting error 'Invalid range specified for the Port' but received %s.", err)

-	}

-}

-

 func TestParseUintList(t *testing.T) {

 	valids := map[string]map[int]bool{

 		"":             {},

@@ -11,7 +11,6 @@ import (

 	"github.com/docker/docker/opts"

 	flag "github.com/docker/docker/pkg/mflag"

 	"github.com/docker/docker/pkg/mount"

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

 	"github.com/docker/docker/pkg/signal"

 	"github.com/docker/docker/volume"

 	"github.com/docker/go-connections/nat"

@@ -285,7 +284,7 @@ func Parse(cmd *flag.FlagSet, args []string) (*container.Config, *container.Host

 		proto, port := nat.SplitProtoPort(e)

 		//parse the start and end port and create a sequence of ports to expose

 		//if expose a port, the start and end port are the same

-		start, end, err := parsers.ParsePortRange(port)

+		start, end, err := nat.ParsePortRange(port)

 		if err != nil {

 			return nil, nil, cmd, fmt.Errorf("Invalid range format for --expose: %s, error: %s", e, err)

 		}