Init project

Author: noah

.gitignore

@@ -0,0 +1,21 @@
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+go.work

go.mod

@@ -0,0 +1,3 @@
+module github.com/gitploy-io/cronexpr
+
+go 1.17

parser.go

@@ -0,0 +1,215 @@
+package cronexpr
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type (
+	bitset uint64
+
+	bound struct {
+		min, max int
+	}
+
+	translater map[string]int
+)
+
+const (
+	bitsetStar = 1<<64 - 1
+)
+
+var (
+	boundMinute = bound{0, 59}
+	boundHour   = bound{0, 24}
+	boundDOM    = bound{1, 31}
+	boundMonth  = bound{1, 12}
+	boundDOW    = bound{0, 6}
+)
+
+var (
+	translaterMonth = translater{
+		"JAN": 1,
+		"FEB": 2,
+		"MAR": 3,
+		"APR": 4,
+		"MAY": 5,
+		"JUN": 6,
+		"JUL": 7,
+		"AUG": 8,
+		"SEP": 9,
+		"OCT": 10,
+		"NOV": 11,
+		"DEC": 12,
+	}
+
+	translaterDay = translater{
+		"SUN": 0,
+		"MON": 1,
+		"TUE": 2,
+		"WED": 3,
+		"THU": 4,
+		"FRI": 5,
+		"SAT": 6,
+	}
+)
+
+func MustParse(expr string) *Schedule {
+	s, err := Parse(expr)
+	if err != nil {
+		panic(err)
+	}
+
+	return s
+}
+
+func Parse(expr string) (*Schedule, error) {
+	err := verifyExpr(expr)
+	if err != nil {
+		return nil, err
+	}
+
+	var (
+		minute, hour, dom, month, dow bitset
+	)
+
+	fields := strings.Fields(strings.TrimSpace(expr))
+
+	if minute, err = parseField(fields[0], boundMinute, translater{}); err != nil {
+		return nil, err
+	}
+
+	if hour, err = parseField(fields[1], boundMinute, translater{}); err != nil {
+		return nil, err
+	}
+
+	if dom, err = parseField(fields[2], boundMinute, translater{}); err != nil {
+		return nil, err
+	}
+
+	if month, err = parseField(fields[3], boundMinute, translaterMonth); err != nil {
+		return nil, err
+	}
+
+	if dow, err = parseField(fields[4], boundMinute, translaterDay); err != nil {
+		return nil, err
+	}
+
+	return &Schedule{
+		Minute: minute,
+		Hour:   hour,
+		Dom:    dom,
+		Month:  month,
+		Dow:    dow,
+	}, nil
+}
+
+// parseField returns an int with the bits set representing all of the times that
+// the field represents or error parsing field value.
+func parseField(field string, b bound, t translater) (bitset, error) {
+	var bitsets bitset = 0
+
+	// Split with "," (OR).
+	fieldexprs := strings.Split(field, ",")
+	for _, fieldexpr := range fieldexprs {
+		b, err := parseFieldExpr(fieldexpr, b, t)
+		if err != nil {
+			return 0, err
+		}
+
+		bitsets = bitsets | b
+	}
+
+	return bitsets, nil
+}
+
+// parseFieldExpr returns the bits indicated by the given expression:
+//   number | number "-" number [ "/" number ]
+func parseFieldExpr(fieldexpr string, b bound, t translater) (bitset, error) {
+	if fieldexpr == "*" {
+		return bitsetStar, nil
+	}
+
+	rangeAndStep := strings.Split(fieldexpr, "/")
+	if !(len(rangeAndStep) == 1 || len(rangeAndStep) == 2) {
+		return 0, fmt.Errorf("Failed to parse the expr '%s', too many '/'", fieldexpr)
+	}
+
+	hasStep := len(rangeAndStep) == 2
+
+	// Parse the range, first.
+	var (
+		begin, end int
+	)
+	{
+		lowAndHigh := strings.Split(rangeAndStep[0], "-")
+		if !(len(lowAndHigh) == 1 || len(lowAndHigh) == 2) {
+			return 0, fmt.Errorf("Failed to parse the expr '%s', too many '-'", fieldexpr)
+		}
+
+		low, err := parseInt(lowAndHigh[0], t)
+		if err != nil {
+			return 0, fmt.Errorf("Failed to parse the expr '%s': %w", fieldexpr, err)
+		}
+
+		begin = low
+
+		// Special handling: "N/step" means "N-max/step".
+		if len(lowAndHigh) == 1 && hasStep {
+			end = b.max
+		} else if len(lowAndHigh) == 1 && !hasStep {
+			end = low
+		} else if len(lowAndHigh) == 2 {
+			high, err := parseInt(lowAndHigh[1], t)
+			if err != nil {
+				return 0, fmt.Errorf("Failed to parse the expr '%s': %w", fieldexpr, err)
+			}
+
+			end = high
+		}
+	}
+
+	// Parse the step, second.
+	step := 1
+	if len(rangeAndStep) == 2 {
+		var err error
+		if step, err = strconv.Atoi(rangeAndStep[1]); err != nil {
+			return 0, fmt.Errorf("Failed to parse the expr '%s': %w", fieldexpr, err)
+		}
+	}
+
+	return buildBitset(begin, end, step), nil
+}
+
+func parseInt(s string, t translater) (int, error) {
+	if i, err := strconv.Atoi(s); err == nil {
+		return i, nil
+	}
+
+	i, ok := t[strings.ToUpper(s)]
+	if !ok {
+		return 0, fmt.Errorf("'%s' is out of reserved words", s)
+	}
+
+	return i, nil
+}
+
+func buildBitset(min, max, step int) bitset {
+	var b bitset
+
+	for i := min; i <= max; i += step {
+		b = b | (1 << i)
+	}
+
+	return b
+}
+
+func verifyExpr(expr string) error {
+	fields := strings.Fields(expr)
+	if len(fields) != 5 {
+		return fmt.Errorf("The length of fields must be five.")
+	}
+
+	return nil
+}

parser_test.go

@@ -0,0 +1,87 @@
+package cronexpr
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func Test_Parse(t *testing.T) {
+	t.Run("Parse the cron expr", func(t *testing.T) {
+		// TODO:
+	})
+}
+
+func Test_parseField(t *testing.T) {
+	t.Run("Parse the field.", func(t *testing.T) {
+		cases := []struct {
+			value string
+			b     bound
+			t     translater
+			want  bitset
+		}{
+			{
+				value: "*",
+				b:     boundMinute,
+				want:  bitsetStar,
+			},
+			{
+				value: "5",
+				b:     boundMinute,
+				want:  1 << 5,
+			},
+			{
+				value: "5,10",
+				b:     boundMinute,
+				want:  1<<5 | 1<<10,
+			},
+			{
+				value: "5-20",
+				b:     boundMinute,
+				want:  buildBitset(5, 20, 1),
+			},
+			{
+				value: "JAN-MAR",
+				b:     boundMonth,
+				t:     translaterMonth,
+				want:  buildBitset(1, 3, 1),
+			},
+			{
+				value: "5-20/5",
+				b:     boundMinute,
+				want:  (1 << 5) | (1 << 10) | (1 << 15) | (1 << 20),
+			},
+		}
+
+		for _, c := range cases {
+			b, err := parseField(c.value, c.b, c.t)
+			if err != nil {
+				t.Fatalf("parseField returns an error: %s", err)
+			}
+
+			if !reflect.DeepEqual(b, c.want) {
+				t.Fatalf("parseField(%s) = %v, wanted %v", c.value, strconv.FormatUint(uint64(b), 2), strconv.FormatUint(uint64(c.want), 2))
+			}
+		}
+	})
+
+	t.Run("Return an error of parsing the field.", func(t *testing.T) {
+		cases := []struct {
+			value string
+			b     bound
+			t     translater
+		}{
+			{
+				value: "1-3-5/3",
+				b:     boundMinute,
+			},
+		}
+
+		for _, c := range cases {
+			_, err := parseField(c.value, c.b, c.t)
+			if err == nil {
+				t.Fatal("parseField must returns an error")
+			}
+		}
+	})
+}