From d9bba774bfe4910b01ece1c7d657ba1b429c7636 Mon Sep 17 00:00:00 2001 From: Charlie Stanton Date: Thu, 28 Dec 2023 09:30:10 +0000 Subject: Rewrite walk/walk.go to no longer use a path --- walk/walk.go | 229 +++++++++++++---------------------------------------------- 1 file changed, 48 insertions(+), 181 deletions(-) (limited to 'walk/walk.go') diff --git a/walk/walk.go b/walk/walk.go index aca6a8c..289d9ee 100644 --- a/walk/walk.go +++ b/walk/walk.go @@ -3,242 +3,109 @@ package walk import ( "fmt" "strings" - "unicode/utf8" ) -type valueIter struct { - values []Value - index int -} -func (iter *valueIter) Next() Edible { - if iter.index >= len(iter.values) { - return nil - } - iter.index += 1 - return iter.values[iter.index - 1] -} - -func NewValueIter(values []Value) StructureIter { - return &valueIter { - values: values, - index: 0, - } -} - -type OutputList interface { - outputList() -} - -type StructureIter interface { - Next() Edible -} - -type Edible interface { - edible() -} - -type Atom interface { - Edible - atom() -} - -type Scalar interface { - Atom - Value -} - -type Structure interface { - Value - structure() - Iter() StructureIter -} - type Value interface { - Edible value() Debug() string } -type Terminal interface { - Atom - terminal() -} - -type ValueList []Value -func (_ ValueList) outputList() {} - -type RuneList []StringRuneAtom -func (_ RuneList) outputList() {} - -type NullScalar struct{} -func (_ NullScalar) edible() {} -func (_ NullScalar) atom() {} -func (_ NullScalar) value() {} -func (_ NullScalar) Debug() string { +type NullValue struct{} +func (_ NullValue) value() {} +func (_ NullValue) Debug() string { return "null" } -type BoolScalar bool -func (_ BoolScalar) edible() {} -func (_ BoolScalar) atom() {} -func (_ BoolScalar) value() {} -func (b BoolScalar) Debug() string { +type BoolValue bool +func (_ BoolValue) value() {} +func (b BoolValue) Debug() string { if b { return "true" } return "false" } -type NumberScalar float64 -func (_ NumberScalar) edible() {} -func (_ NumberScalar) atom() {} -func (_ NumberScalar) value() {} -func (n NumberScalar) Debug() string { +type NumberValue float64 +func (_ NumberValue) value() {} +func (n NumberValue) Debug() string { return fmt.Sprintf("%v", float64(n)) } -type StringStructure string -func (_ StringStructure) edible() {} -func (_ StringStructure) value() {} -func (_ StringStructure) structure() {} -func (s StringStructure) Iter() StructureIter { - return &stringStructureIter { - string: string(s), - position: 0, - } +type RuneValue rune +func (_ RuneValue) value() {} +func (r RuneValue) Debug() string { + return string(r) } -func (s StringStructure) Debug() string { + +type StringValue string +func (_ StringValue) value() {} +func (s StringValue) Debug() string { return fmt.Sprintf("%q", string(s)) } -type stringStructureIter struct { - string string - position int -} -func (iter *stringStructureIter) Next() Edible { - if iter.position == -1 { - return nil - } - r, width := utf8.DecodeRuneInString(iter.string[iter.position:]) - if width == 0 { - iter.position = -1 - return StringEndTerminal{} - } - iter.position += width - return StringRuneAtom(r) +type ArrayElement struct { + Index int + Value Value } -type StringBeginTerminal struct{} -func (_ StringBeginTerminal) edible() {} -func (_ StringBeginTerminal) atom() {} -func (_ StringBeginTerminal) terminal() {} - -type StringEndTerminal struct{} -func (_ StringEndTerminal) edible() {} -func (_ StringEndTerminal) atom() {} -func (_ StringEndTerminal) terminal() {} - -type StringRuneAtom rune -func (_ StringRuneAtom) edible() {} -func (_ StringRuneAtom) atom() {} - -type ArrayStructure []Value -func (_ ArrayStructure) edible() {} -func (_ ArrayStructure) value() {} -func (_ ArrayStructure) structure() {} -func (array ArrayStructure) Iter() StructureIter { - return &arrayStructureIter { - array: []Value(array), - index: 0, - } -} -func (array ArrayStructure) Debug() string { +type ArrayValue []ArrayElement +func (_ ArrayValue) value() {} +func (array ArrayValue) Debug() string { builder := strings.Builder{} builder.WriteRune('[') var sep string for _, element := range array { builder.WriteString(sep) - builder.WriteString(fmt.Sprintf("%v", element)) + builder.WriteString(fmt.Sprintf("%v", element.Index)) + builder.WriteString(": ") + builder.WriteString(element.Value.Debug()) sep = ", " } builder.WriteRune(']') return builder.String() } -type arrayStructureIter struct { - array []Value - index int +type MapElement struct { + Key string + Value Value } -func (iter *arrayStructureIter) Next() Edible { - if iter.index > len(iter.array) { - return nil - } - if iter.index == len(iter.array) { - iter.index += 1 - return ArrayEndTerminal{} - } - iter.index += 1 - return iter.array[iter.index - 1] -} - -type ArrayBeginTerminal struct{} -func (_ ArrayBeginTerminal) edible() {} -func (_ ArrayBeginTerminal) atom() {} -func (_ ArrayBeginTerminal) terminal() {} - -type ArrayEndTerminal struct{} -func (_ ArrayEndTerminal) edible() {} -func (_ ArrayEndTerminal) atom() {} -func (_ ArrayEndTerminal) terminal() {} -type MapStructure map[string]Value -func (_ MapStructure) edible() {} -func (_ MapStructure) value() {} -func (_ MapStructure) structure() {} -func (m MapStructure) Debug() string { +type MapValue []MapElement +func (_ MapValue) value() {} +func (m MapValue) Debug() string { builder := strings.Builder{} builder.WriteRune('{') var sep string - for key, value := range m { + for _, element := range m { builder.WriteString(sep) - builder.WriteString(fmt.Sprintf("%q", key)) + builder.WriteString(fmt.Sprintf("%q", element.Key)) builder.WriteString(": ") - builder.WriteString(fmt.Sprintf("%q", value)) + builder.WriteString(element.Value.Debug()) sep = ", " } builder.WriteRune('}') return builder.String() } -type MapBeginTerminal struct{} -func (_ MapBeginTerminal) edible() {} -func (_ MapBeginTerminal) atom() {} -func (_ MapBeginTerminal) terminal() {} - -type MapEndTerminal struct{} -func (_ MapEndTerminal) edible() {} -func (_ MapEndTerminal) atom() {} -func (_ MapEndTerminal) terminal() {} - type WalkItem struct { - Value ValueList - Path ValueList + Value Value + Start, PrevStart, End, NextEnd bool } func (item WalkItem) Debug() string { builder := strings.Builder{} - var sep string - for _, pathSegment := range item.Path { - builder.WriteString(sep) - builder.WriteString(fmt.Sprintf("%s", pathSegment.Debug())) - sep = "." + if item.Start { + builder.WriteRune('a') } - builder.WriteString(": ") - sep = "" - for _, value := range item.Value { - builder.WriteString(sep) - builder.WriteString(fmt.Sprintf("%s", value.Debug())) - sep = ", " + if item.PrevStart { + builder.WriteRune('A') + } + if item.NextEnd { + builder.WriteRune('Z') + } + if item.End { + builder.WriteRune('z') } + builder.WriteString(item.Value.Debug()) return builder.String() } -- cgit v1.2.3