Merge pull request robfig#73 from soltysh/issue58

Add method capable of parsing standard cron spec

Author: robfig

parser.go

@@ -9,6 +9,46 @@ import (
 	"time"
 )
 
+// ParseStandard returns a new crontab schedule representing the given standardSpec
+// (https://en.wikipedia.org/wiki/Cron). It differs from Parse requiring to always
+// pass 5 entries representing: minute, hour, day of month, month and day of week,
+// in that order. It returns a descriptive error if the spec is not valid.
+//
+// It accepts
+//   - Standard crontab specs, e.g. "* * * * ?"
+//   - Descriptors, e.g. "@midnight", "@every 1h30m"
+func ParseStandard(standardSpec string) (_ Schedule, err error) {
+	// Convert panics into errors
+	defer func() {
+		if recovered := recover(); recovered != nil {
+			err = fmt.Errorf("%v", recovered)
+		}
+	}()
+
+	if standardSpec[0] == '@' {
+		return parseDescriptor(standardSpec), nil
+	}
+
+	// Split on whitespace.  We require exactly 5 fields.
+	// (minute) (hour) (day of month) (month) (day of week)
+	fields := strings.Fields(standardSpec)
+	if len(fields) != 5 {
+		log.Panicf("Expected exactly 5, found %d: %s", len(fields), standardSpec)
+	}
+
+	schedule := &SpecSchedule{
+		Second: 1 << seconds.min,
+		Minute: getField(fields[0], minutes),
+		Hour:   getField(fields[1], hours),
+		Dom:    getField(fields[2], dom),
+		Month:  getField(fields[3], months),
+		Dow:    getField(fields[4], dow),
+	}
+
+	return schedule, nil
+
+}
+
 // Parse returns a new crontab schedule representing the given spec.
 // It returns a descriptive error if the spec is not valid.
 //

parser_test.go

@@ -115,3 +115,23 @@ func TestSpecSchedule(t *testing.T) {
 		}
 	}
 }
+
+func TestStandardSpecSchedule(t *testing.T) {
+	entries := []struct {
+		expr     string
+		expected Schedule
+	}{
+		{"5 * * * *", &SpecSchedule{1 << seconds.min, 1 << 5, all(hours), all(dom), all(months), all(dow)}},
+		{"@every 5m", ConstantDelaySchedule{time.Duration(5) * time.Minute}},
+	}
+
+	for _, c := range entries {
+		actual, err := ParseStandard(c.expr)
+		if err != nil {
+			t.Error(err)
+		}
+		if !reflect.DeepEqual(actual, c.expected) {
+			t.Errorf("%s => (expected) %b != %b (actual)", c.expr, c.expected, actual)
+		}
+	}
+}