More cleanup

README.md

@@ -37,7 +37,7 @@ Next, add a go:generate comment somewhere (in this example all code lives
 in main.go):
 
 ```go
-//go:generate parquetgen -input main.go -type Person -package main
+// go:generate parquetgen -input main.go -type Person -package main
 ```
 
 Generate the code for the reader and writer:
@@ -104,7 +104,7 @@ of rows in a page before a new one is created) and sets the page data compressio
 to snappy:
 
 ```go
-    w, err := NewParquetWriter(&buf, MaxPageSize(10000), Snappy)
+w, err := NewParquetWriter(&buf, MaxPageSize(10000), Snappy)
 ```
 
 See [this](./examples/people) for a complete example of how to generate the code

fields.go

@@ -56,6 +56,7 @@ func (f *RequiredField) DoWrite(w io.Writer, meta *Metadata, vals []byte, count
 	return err
 }
 
+// DoRead reads the actual raw data.
 func (f *RequiredField) DoRead(r io.ReadSeeker, pg Page) (io.Reader, []int, error) {
 	var nRead int
 	var out []byte
@@ -79,23 +80,25 @@ func (f *RequiredField) DoRead(r io.ReadSeeker, pg Page) (io.Reader, []int, erro
 	return bytes.NewBuffer(out), sizes, nil
 }
 
+// Name returns the column name of this field
 func (f *RequiredField) Name() string {
 	return strings.Join(f.pth, ".")
 }
 
+// Path returns the path of this field
 func (f *RequiredField) Path() []string {
 	return f.pth
 }
 
-func (f *RequiredField) Key() string {
-	return strings.Join(f.pth, ".")
-}
-
+// MaxLevel holds the maximum definition and
+// repeptition level for a given field.
 type MaxLevel struct {
 	Def uint8
 	Rep uint8
 }
 
+// OptionalField is any exported field in a
+// struct that is a pointer.
 type OptionalField struct {
 	Defs           []uint8
 	Reps           []uint8
@@ -115,6 +118,7 @@ func getRepetitionTypes(in []int) fields.RepetitionTypes {
 	return fields.RepetitionTypes(out)
 }
 
+// NewOptionalField...
 func NewOptionalField(pth []string, types []int, opts ...func(*OptionalField)) OptionalField {
 	rts := getRepetitionTypes(types)
 	f := OptionalField{
@@ -241,14 +245,11 @@ func (f *OptionalField) Name() string {
 	return strings.Join(f.pth, ".")
 }
 
+// Path returns the path of this field
 func (f *OptionalField) Path() []string {
 	return f.pth
 }
 
-func (f *OptionalField) Key() string {
-	return strings.Join(f.pth, ".")
-}
-
 // writeCounter keeps track of the number of bytes written
 // it is used for calls to binary.Write, which does not
 // return the number of bytes written.
@@ -264,9 +265,8 @@ func (w *writeCounter) Write(p []byte) (int, error) {
 	return n, err
 }
 
-// writeCounter keeps track of the number of bytes written
-// it is used for calls to binary.Write, which does not
-// return the number of bytes written.
+// readCounter keeps track of the number of bytes written
+// it is used for calls to binary.Write.
 type readCounter struct {
 	n int64
 	r io.Reader

internal/fields/field.go → internal/fields/fields.go

@@ -87,6 +87,8 @@ type RepCase struct {
 	Rep  int
 }
 
+// RepCases returns a RepCase slice based on the field types and
+// what sub-fields have already been seen.
 func (f Field) RepCases(seen RepetitionTypes) []RepCase {
 	mr := int(f.MaxRep())
 	if mr == int(seen.MaxRep()) {
@@ -100,7 +102,9 @@ func (f Field) RepCases(seen RepetitionTypes) []RepCase {
 	return out
 }
 
-func (f Field) NilField(i int) (string, RepetitionType, int, int) {
+// NilField finds the nth field that is optional and returns some
+// information about it.
+func (f Field) NilField(n int) (string, RepetitionType, int, int) {
 	var fields []string
 	var count int
 	var j, reps int
@@ -114,7 +118,7 @@ func (f Field) NilField(i int) (string, RepetitionType, int, int) {
 			count++
 			reps++
 		}
-		if count > i {
+		if count > n {
 			break
 		}
 	}
@@ -129,22 +133,6 @@ func (f Field) Child(i int) Field {
 	}
 }
 
-func (f Field) DefChild(def int) Field {
-	i := f.DefIndex(def)
-	if i >= len(f.FieldNames) {
-		return Field{
-			FieldNames:      nil,
-			FieldTypes:      nil,
-			RepetitionTypes: nil,
-		}
-	}
-	return Field{
-		FieldNames:      f.FieldNames[i:],
-		FieldTypes:      f.FieldTypes[i:],
-		RepetitionTypes: f.RepetitionTypes[i:],
-	}
-}
-
 func (f Field) Parent(i int) Field {
 	return Field{
 		RepetitionTypes: f.RepetitionTypes[:i],

internal/fields/fields_test.go

@@ -382,3 +382,49 @@ func TestChild(t *testing.T) {
 	}
 	assert.Equal(t, ch, f.Child(1))
 }
+
+func TestRepCases(t *testing.T) {
+	testCases := []struct {
+		f        fields.Field
+		seen     []fields.RepetitionType
+		expected []fields.RepCase
+	}{
+		{
+			f:        fields.Field{FieldNames: []string{"Names", "Languages", "Country"}, FieldTypes: []string{"Name", "Language", "string"}, RepetitionTypes: []fields.RepetitionType{fields.Repeated, fields.Repeated, fields.Optional}},
+			expected: []fields.RepCase{fields.RepCase{Case: "case 0:", Rep: 0}, fields.RepCase{Case: "case 1:", Rep: 1}, fields.RepCase{Case: "case 2:", Rep: 2}},
+		},
+		{
+			f:        fields.Field{FieldNames: []string{"Names", "Languages", "Country"}, FieldTypes: []string{"Name", "Language", "string"}, RepetitionTypes: []fields.RepetitionType{fields.Repeated, fields.Repeated, fields.Optional}},
+			seen:     []fields.RepetitionType{fields.Repeated, fields.Repeated},
+			expected: []fields.RepCase{fields.RepCase{Case: "default:", Rep: 0}},
+		},
+	}
+
+	for i, tc := range testCases {
+		t.Run(fmt.Sprintf("%02d", i), func(t *testing.T) {
+			assert.Equal(t, tc.expected, tc.f.RepCases(tc.seen))
+		})
+	}
+}
+
+func TestNilField(t *testing.T) {
+	f := fields.Field{FieldNames: []string{"Names", "Languages", "Country"}, FieldTypes: []string{"Name", "Language", "string"}, RepetitionTypes: []fields.RepetitionType{fields.Repeated, fields.Repeated, fields.Optional}}
+	name, rt, i, reps := f.NilField(1)
+	assert.Equal(t, "Names.Languages", name)
+	assert.Equal(t, fields.Repeated, rt)
+	assert.Equal(t, 1, i)
+	assert.Equal(t, 2, reps)
+}
+
+func TestField(t *testing.T) {
+	f := fields.Field{FieldNames: []string{"Names", "Languages", "Country"}, FieldTypes: []string{"Name", "Language", "string"}, RepetitionTypes: []fields.RepetitionType{fields.Repeated, fields.Repeated, fields.Optional}}
+	assert.True(t, f.Repeated())
+	assert.True(t, f.Optional())
+	assert.False(t, f.Required())
+}
+
+func TestRepetitionTypes(t *testing.T) {
+	rts := fields.RepetitionTypes([]fields.RepetitionType{fields.Repeated, fields.Optional})
+	assert.Equal(t, rts.Def(1), fields.Repeated)
+	assert.Equal(t, rts.Def(2), fields.Optional)
+}

internal/fields/repetition.go

@@ -11,6 +11,7 @@ const (
 
 type RepetitionTypes []RepetitionType
 
+// Def returns the repetition type for the definition level
 func (r RepetitionTypes) Def(def int) RepetitionType {
 	var out RepetitionType
 	var count int
@@ -26,6 +27,7 @@ func (r RepetitionTypes) Def(def int) RepetitionType {
 	return out
 }
 
+// MaxDef returns the largest definition level
 func (r RepetitionTypes) MaxDef() uint8 {
 	var out uint8
 	for _, rt := range r {
@@ -36,6 +38,7 @@ func (r RepetitionTypes) MaxDef() uint8 {
 	return out
 }
 
+// MaxDef returns the largest repetition level
 func (r RepetitionTypes) MaxRep() uint8 {
 	var out uint8
 	for _, rt := range r {
@@ -46,6 +49,7 @@ func (r RepetitionTypes) MaxRep() uint8 {
 	return out
 }
 
+// Repeated figures out if there is a repeated field
 func (r RepetitionTypes) Repeated() bool {
 	for _, rt := range r {
 		if rt == Repeated {
@@ -55,6 +59,7 @@ func (r RepetitionTypes) Repeated() bool {
 	return false
 }
 
+// Optional figures out if there is an optional field
 func (r RepetitionTypes) Optional() bool {
 	for _, rt := range r {
 		if rt == Optional {
@@ -64,6 +69,7 @@ func (r RepetitionTypes) Optional() bool {
 	return false
 }
 
+// Required figures out if there are no optional or repeated fields
 func (r RepetitionTypes) Required() bool {
 	for _, rt := range r {
 		if rt != Required {
@@ -73,6 +79,8 @@ func (r RepetitionTypes) Required() bool {
 	return true
 }
 
+// NRepeated figures out if the sub-field at position i
+// is repeated.
 func (r RepetitionTypes) NRepeated(i int) bool {
 	var count int
 	for _, rt := range r {

internal/fields/templates.go

@@ -17,28 +17,17 @@ func init() {
 		log.Fatal(err)
 	}
 
-	initTpl, err = template.New("subfield").Parse(`{{if eq .RT 0}}{{template "required" .}}{{else}}{{if eq .RT 1}}{{template "optional" .}}{{else}}{{template "repeated" .}}{{end}}{{end}}`)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	initTpl, err = initTpl.Parse(`{{define "required"}}{{if .Primitive}}{{.Val}}{{else}}{{.Type}}{ {{.Val}} }{{end}}{{end}}`)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	initTpl, err = initTpl.Parse(`{{define "optional"}}{{if .Primitive}}p{{.Type}}({{.Val}}){{else}}&{{.Type}}{ {{.Val}} }{{end}}{{end}}`)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	initTpl, err = initTpl.Parse(`{{define "repeated"}}{{if .Slice}}{{template "slice" .}}{{else}}{{if .Primitive}}{{.Val}}{{else}}{{.Type}}{ {{.Val}} } {{end}}{{end}}{{end}}`)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	initTpl, err = initTpl.Parse(`{{define "slice"}}{{if .Primitive}}[]{{.Type}}{ {{.Val}} }{{else}}[]{{.Type}}{ { {{.Val}} } }{{end}}{{end}}`)
-	if err != nil {
-		log.Fatal(err)
+	initTpl = template.New("subfield")
+	for _, t := range []string{
+		`{{if eq .RT 0}}{{template "required" .}}{{else}}{{if eq .RT 1}}{{template "optional" .}}{{else}}{{template "repeated" .}}{{end}}{{end}}`,
+		`{{define "required"}}{{if .Primitive}}{{.Val}}{{else}}{{.Type}}{ {{.Val}} }{{end}}{{end}}`,
+		`{{define "optional"}}{{if .Primitive}}p{{.Type}}({{.Val}}){{else}}&{{.Type}}{ {{.Val}} }{{end}}{{end}}`,
+		`{{define "repeated"}}{{if .Slice}}{{template "slice" .}}{{else}}{{if .Primitive}}{{.Val}}{{else}}{{.Type}}{ {{.Val}} } {{end}}{{end}}{{end}}`,
+		`{{define "slice"}}{{if .Primitive}}[]{{.Type}}{ {{.Val}} }{{else}}[]{{.Type}}{ { {{.Val}} } }{{end}}{{end}}`,
+	} {
+		initTpl, err = initTpl.Parse(t)
+		if err != nil {
+			log.Fatal(err)
+		}
 	}
 }

internal/parse/fields_test.go

@@ -360,51 +360,4 @@ func TestDefIndex(t *testing.T) {
 			assert.Equal(t, tc.expected, tc.field.DefIndex(tc.def))
 		})
 	}
-
-}
-
-func TestDefChild(t *testing.T) {
-	testCases := []struct {
-		def      int
-		field    fields.Field
-		expected fields.Field
-	}{
-		{
-			def:      1,
-			field:    fields.Field{FieldNames: []string{"a", "b", "c"}, FieldTypes: []string{"a", "b", "string"}, RepetitionTypes: []fields.RepetitionType{fields.Required, fields.Optional, fields.Repeated}},
-			expected: fields.Field{FieldNames: []string{"b", "c"}, FieldTypes: []string{"b", "string"}, RepetitionTypes: []fields.RepetitionType{fields.Optional, fields.Repeated}},
-		},
-		{
-			def:      2,
-			field:    fields.Field{FieldNames: []string{"a", "b", "c"}, FieldTypes: []string{"a", "b", "string"}, RepetitionTypes: []fields.RepetitionType{fields.Required, fields.Optional, fields.Repeated}},
-			expected: fields.Field{FieldNames: []string{"c"}, FieldTypes: []string{"string"}, RepetitionTypes: []fields.RepetitionType{fields.Repeated}},
-		},
-		{
-			def:      1,
-			field:    fields.Field{FieldNames: []string{"a", "b", "c"}, FieldTypes: []string{"a", "b", "string"}, RepetitionTypes: []fields.RepetitionType{fields.Optional, fields.Required, fields.Repeated}},
-			expected: fields.Field{FieldNames: []string{"a", "b", "c"}, FieldTypes: []string{"a", "b", "string"}, RepetitionTypes: []fields.RepetitionType{fields.Optional, fields.Required, fields.Repeated}},
-		},
-		{
-			def:      2,
-			field:    fields.Field{FieldNames: []string{"a", "b", "c"}, FieldTypes: []string{"a", "b", "string"}, RepetitionTypes: []fields.RepetitionType{fields.Optional, fields.Required, fields.Repeated}},
-			expected: fields.Field{FieldNames: []string{"c"}, FieldTypes: []string{"string"}, RepetitionTypes: []fields.RepetitionType{fields.Repeated}},
-		},
-		{
-			def:      2,
-			field:    fields.Field{FieldNames: []string{"a", "b", "c"}, FieldTypes: []string{"a", "b", "string"}, RepetitionTypes: []fields.RepetitionType{fields.Repeated, fields.Optional, fields.Required}},
-			expected: fields.Field{FieldNames: []string{"b", "c"}, FieldTypes: []string{"b", "string"}, RepetitionTypes: []fields.RepetitionType{fields.Optional, fields.Required}},
-		},
-		{
-			def:      1,
-			field:    fields.Field{FieldNames: []string{"a", "b", "c"}, FieldTypes: []string{"a", "b", "string"}, RepetitionTypes: []fields.RepetitionType{fields.Repeated, fields.Optional, fields.Required}},
-			expected: fields.Field{FieldNames: []string{"a", "b", "c"}, FieldTypes: []string{"a", "b", "string"}, RepetitionTypes: []fields.RepetitionType{fields.Repeated, fields.Optional, fields.Required}},
-		},
-	}
-
-	for i, tc := range testCases {
-		t.Run(fmt.Sprintf("%02d", i), func(t *testing.T) {
-			assert.Equal(t, tc.expected, tc.field.DefChild(tc.def))
-		})
-	}
-
 }