Merge branch 'master' into add-attributes

# Conflicts:
#	mpd/mpd_test.go

Fixup tests.

Author: mbowBC

README.md

@@ -54,7 +54,7 @@ make examples-ondemand
 
 ### Dependencies
 
-Tested on go 1.9.1.
+Tested on go 1.9.2.
 
 ### Build and run unit tests
 

mpd/duration.go

@@ -4,15 +4,41 @@ package mpd
 
 import (
 	"encoding/xml"
+	"errors"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
 	"time"
 )
 
 type Duration time.Duration
 
+var (
+	rStart   = "^P"          // Must start with a 'P'
+	rDays    = "(\\d+D)?"    // We only allow Days for durations, not Months or Years
+	rTime    = "(?:T"        // If there's any 'time' units then they must be preceded by a 'T'
+	rHours   = "(\\d+H)?"    // Hours
+	rMinutes = "(\\d+M)?"    // Minutes
+	rSeconds = "([\\d.]+S)?" // Seconds (Potentially decimal)
+	rEnd     = ")?$"         // end of regex must close "T" capture group
+)
+
+var xmlDurationRegex = regexp.MustCompile(rStart + rDays + rTime + rHours + rMinutes + rSeconds + rEnd)
+
 func (d Duration) MarshalXMLAttr(name xml.Name) (xml.Attr, error) {
 	return xml.Attr{name, d.String()}, nil
 }
 
+func (d *Duration) UnmarshalXMLAttr(attr xml.Attr) error {
+	dur, err := parseDuration(attr.Value)
+	if err != nil {
+		return err
+	}
+	*d = Duration(dur)
+	return nil
+}
+
 // String renders a Duration in XML Duration Data Type format
 func (d *Duration) String() string {
 	// Largest time is 2540400h10m10.000000000s
@@ -126,3 +152,55 @@ func fmtInt(buf []byte, v uint64) int {
 	}
 	return w
 }
+
+func parseDuration(str string) (time.Duration, error) {
+	if len(str) < 3 {
+		return 0, errors.New("At least one number and designator are required")
+	}
+
+	if strings.Contains(str, "-") {
+		return 0, errors.New("Duration cannot be negative")
+	}
+
+	// Check that only the parts we expect exist and that everything's in the correct order
+	if !xmlDurationRegex.Match([]byte(str)) {
+		return 0, errors.New("Duration must be in the format: P[nD][T[nH][nM][nS]]")
+	}
+
+	var parts = xmlDurationRegex.FindStringSubmatch(str)
+	var total time.Duration
+
+	if parts[1] != "" {
+		days, err := strconv.Atoi(strings.TrimRight(parts[1], "D"))
+		if err != nil {
+			return 0, fmt.Errorf("Error parsing Days: %s", err)
+		}
+		total += time.Duration(days) * time.Hour * 24
+	}
+
+	if parts[2] != "" {
+		hours, err := strconv.Atoi(strings.TrimRight(parts[2], "H"))
+		if err != nil {
+			return 0, fmt.Errorf("Error parsing Hours: %s", err)
+		}
+		total += time.Duration(hours) * time.Hour
+	}
+
+	if parts[3] != "" {
+		mins, err := strconv.Atoi(strings.TrimRight(parts[3], "M"))
+		if err != nil {
+			return 0, fmt.Errorf("Error parsing Minutes: %s", err)
+		}
+		total += time.Duration(mins) * time.Minute
+	}
+
+	if parts[4] != "" {
+		secs, err := strconv.ParseFloat(strings.TrimRight(parts[4], "S"), 64)
+		if err != nil {
+			return 0, fmt.Errorf("Error parsing Seconds: %s", err)
+		}
+		total += time.Duration(secs * float64(time.Second))
+	}
+
+	return total, nil
+}

mpd/duration_test.go

@@ -4,7 +4,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestDuration(t *testing.T) {
@@ -15,8 +15,45 @@ func TestDuration(t *testing.T) {
 	}
 	for ins, ex := range in {
 		timeDur, err := time.ParseDuration(ins)
-		assert.Equal(t, nil, err)
+		require.Equal(t, nil, err)
 		dur := Duration(timeDur)
-		assert.Equal(t, ex, dur.String())
+		require.Equal(t, ex, dur.String())
+	}
+}
+
+func TestParseDuration(t *testing.T) {
+	in := map[string]float64{
+		"PT0S":          0,
+		"PT1M":          60,
+		"PT2H":          7200,
+		"PT6M16S":       376,
+		"PT1.97S":       1.97,
+		"PT1H2M3.456S":  3723.456,
+		"P1DT2H":        (26 * time.Hour).Seconds(),
+		"PT20M":         (20 * time.Minute).Seconds(),
+		"PT1M30.5S":     (time.Minute + 30*time.Second + 500*time.Millisecond).Seconds(),
+		"PT1004199059S": (1004199059 * time.Second).Seconds(),
+	}
+	for ins, ex := range in {
+		act, err := parseDuration(ins)
+		require.NoError(t, err, ins)
+		require.Equal(t, ex, act.Seconds(), ins)
+	}
+}
+
+func TestParseBadDurations(t *testing.T) {
+	in := map[string]string{
+		"P20M":   `Duration must be in the format: P[nD][T[nH][nM][nS]]`, // We don't allow Months (doesn't make sense when converting to duration)
+		"P20Y":   `Duration must be in the format: P[nD][T[nH][nM][nS]]`, // We don't allow Years (doesn't make sense when converting to duration)
+		"P15.5D": `Duration must be in the format: P[nD][T[nH][nM][nS]]`, // Only seconds can be expressed as a decimal
+		"P2H":    `Duration must be in the format: P[nD][T[nH][nM][nS]]`, // "T" must be present to separate days and hours
+		"2DT1H":  `Duration must be in the format: P[nD][T[nH][nM][nS]]`, // "P" must always be present
+		"PT2M1H": `Duration must be in the format: P[nD][T[nH][nM][nS]]`, // Hours must appear before Minutes
+		"P":      `At least one number and designator are required`,      // At least one number and designator are required
+		"-P20H":  `Duration cannot be negative`,                          // Negative duration doesn't make sense
+	}
+	for ins, msg := range in {
+		_, err := parseDuration(ins)
+		require.EqualError(t, err, msg, "Expected an error for: %s", ins)
 	}
 }