Read/Edit DBs with key/value pairs in root

Not sure how 'good' this is, but apparently some people do it, so we may as well support it.
Merge pull request #43 from sp0cket/master
2021-05-31 09:29:09 -05:00 · 2020-04-08 15:29:24 -05:00 · 2020-04-08 16:09:44 +08:00 · 2020-03-30 16:24:09 -05:00 · 2020-03-30 16:20:48 -05:00 · 2019-12-23 16:57:25 +02:00
8 changed files with 349 additions and 564 deletions
--- a/bolt_model.go
+++ b/bolt_model.go
@@ -1,7 +1,6 @@
 package main

 import (
-	"bytes"
 	"errors"
 	"fmt"
 	"os"
@@ -17,117 +16,29 @@ type BoltDB struct {
 	buckets []BoltBucket
 }

-type PathNode struct {
-	name     []byte
-	dataType Datatype
-}
-
 /*
 BoltBucket is just a struct representation of a Bucket in the Bolt DB
 */
 type BoltBucket struct {
-	name         []byte
-	nameDatatype Datatype
-	pairs        []BoltPair
-	buckets      []BoltBucket
-	parent       *BoltBucket
-	expanded     bool
-	errorFlag    bool
-}
-
-func NewBoltBucket(parent *BoltBucket, name []byte) *BoltBucket {
-	ret := new(BoltBucket)
-	ret.parent = parent
-	ret.name = name
-	for _, dtk := range dataTypeNameSlice {
-		if _, err := datatypes[dtk].ToString(name); err == nil {
-			ret.nameDatatype = datatypes[dtk]
-			break
-		}
-	}
-	return ret
-}
-
-func (b *BoltBucket) GetPathNode() PathNode {
-	return PathNode{
-		name:     b.name,
-		dataType: b.nameDatatype,
-	}
-}
-
-func (b *BoltBucket) SetName(nm []byte) {
-	b.name = nm
+	name      string
+	pairs     []BoltPair
+	buckets   []BoltBucket
+	parent    *BoltBucket
+	expanded  bool
+	errorFlag bool
+	isRoot    bool
 }

 /*
 BoltPair is just a struct representation of a Pair in the Bolt DB
 */
 type BoltPair struct {
-	parent      *BoltBucket
-	key         []byte
-	val         []byte
-	keyDatatype Datatype
-	valDatatype Datatype
+	parent *BoltBucket
+	key    string
+	val    string
 }

-func NewBoltPair(parent *BoltBucket, key, val []byte) *BoltPair {
-	tp := BoltPair{
-    parent: parent,
-		key: key,
-		val: val,
-	}
-	for _, dtk := range dataTypeNameSlice {
-		if _, err := datatypes[dtk].ToString(key); err == nil {
-			tp.keyDatatype = datatypes[dtk]
-			break
-		}
-	}
-	for _, dtk := range dataTypeNameSlice {
-		if _, err := datatypes[dtk].ToString(val); err == nil {
-			tp.valDatatype = datatypes[dtk]
-			break
-		}
-	}
-	return &tp
-}
-
-func (p *BoltPair) GetPathNode() PathNode {
-	return PathNode{
-		name:     p.key,
-		dataType: p.keyDatatype,
-	}
-}
-
-/*
-GetStringKey returns the key of the pair after passing it through it's
-Datatype ToString function
-*/
-func (p *BoltPair) GetStringKey() string {
-	ret, err := p.keyDatatype.ToString(p.key)
-	if err != nil {
-		return "ERROR"
-	}
-	return ret
-}
-
-
-/*
-GetStringVal returns the val of the pair after passing it through it's
-Datatype ToString function
-*/
-func (p *BoltPair) GetStringVal() string {
-	ret, err := p.valDatatype.ToString(p.val)
-	if err != nil {
-    return "ERROR"
-	}
-	return ret
-}
-
-func (bd *BoltDB) getGenericFromStringPath(path []PathNode) (*BoltBucket, *BoltPair, error) {
-	return bd.getGenericFromPath(path)
-}
-
-func (bd *BoltDB) getGenericFromPath(path []PathNode) (*BoltBucket, *BoltPair, error) {
+func (bd *BoltDB) getGenericFromPath(path []string) (*BoltBucket, *BoltPair, error) {
 	// Check if 'path' leads to a pair
 	p, err := bd.getPairFromPath(path)
 	if err == nil {
@@ -142,19 +53,19 @@ func (bd *BoltDB) getGenericFromPath(path []PathNode) (*BoltBucket, *BoltPair, e
 	return nil, nil, errors.New("Invalid Path")
 }

-func (bd *BoltDB) getBucketFromPath(path []PathNode) (*BoltBucket, error) {
+func (bd *BoltDB) getBucketFromPath(path []string) (*BoltBucket, error) {
 	if len(path) > 0 {
 		// Find the BoltBucket with a path == path
 		var b *BoltBucket
 		var err error
 		// Find the root bucket
-		b, err = memBolt.getBucket(path[0].name)
+		b, err = memBolt.getBucket(path[0])
 		if err != nil {
 			return nil, err
 		}
 		if len(path) > 1 {
 			for p := 1; p < len(path); p++ {
-				b, err = b.getBucket(path[p].name)
+				b, err = b.getBucket(path[p])
 				if err != nil {
 					return nil, err
 				}
@@ -165,7 +76,7 @@ func (bd *BoltDB) getBucketFromPath(path []PathNode) (*BoltBucket, error) {
 	return nil, errors.New("Invalid Path")
 }

-func (bd *BoltDB) getPairFromPath(path []PathNode) (*BoltPair, error) {
+func (bd *BoltDB) getPairFromPath(path []string) (*BoltPair, error) {
 	if len(path) <= 0 {
 		return nil, errors.New("No Path")
 	}
@@ -174,11 +85,11 @@ func (bd *BoltDB) getPairFromPath(path []PathNode) (*BoltPair, error) {
 		return nil, err
 	}
 	// Found the bucket, pull out the pair
-	p, err := b.getPair(path[len(path)-1].name)
+	p, err := b.getPair(path[len(path)-1])
 	return p, err
 }

-func (bd *BoltDB) getVisibleItemCount(path []PathNode) (int, error) {
+func (bd *BoltDB) getVisibleItemCount(path []string) (int, error) {
 	vis := 0
 	var retErr error
 	if len(path) == 0 {
@@ -213,12 +124,12 @@ func (bd *BoltDB) getVisibleItemCount(path []PathNode) (int, error) {
 	return vis, retErr
 }

-func (bd *BoltDB) buildVisiblePathSlice() ([][]PathNode, error) {
-	var retSlice [][]PathNode
+func (bd *BoltDB) buildVisiblePathSlice(filter string) ([][]string, error) {
+	var retSlice [][]string
 	var retErr error
 	// The root path, recurse for root buckets
 	for i := range bd.buckets {
-		bktS, bktErr := bd.buckets[i].buildVisiblePathSlice([]PathNode{})
+		bktS, bktErr := bd.buckets[i].buildVisiblePathSlice([]string{}, filter)
 		if bktErr == nil {
 			retSlice = append(retSlice, bktS...)
 		} else {
@@ -229,8 +140,30 @@ func (bd *BoltDB) buildVisiblePathSlice() ([][]PathNode, error) {
 	return retSlice, retErr
 }

-func (bd *BoltDB) getPrevVisiblePath(path []PathNode) []PathNode {
-	visPaths, err := bd.buildVisiblePathSlice()
+func (bd *BoltDB) isVisiblePath(path []string, filter string) bool {
+	visPaths, err := bd.buildVisiblePathSlice(filter)
+	if err != nil {
+		return false
+	}
+	for _, pth := range visPaths {
+		if len(pth) != len(path) {
+			continue
+		}
+		isVisible := true
+		for i := range path {
+			if path[i] != pth[i] {
+				isVisible = false
+				break
+			}
+		}
+		if isVisible {
+			return true
+		}
+	}
+	return false
+}
+func (bd *BoltDB) getPrevVisiblePath(path []string, filter string) []string {
+	visPaths, err := bd.buildVisiblePathSlice(filter)
 	if path == nil {
 		if len(visPaths) > 0 {
 			return visPaths[len(visPaths)-1]
@@ -241,7 +174,7 @@ func (bd *BoltDB) getPrevVisiblePath(path []PathNode) []PathNode {
 		for idx, pth := range visPaths {
 			isCurPath := true
 			for i := range path {
-				if len(pth) <= i || !bytes.Equal(path[i].name, pth[i].name) {
+				if len(pth) <= i || path[i] != pth[i] {
 					isCurPath = false
 					break
 				}
@@ -253,8 +186,8 @@ func (bd *BoltDB) getPrevVisiblePath(path []PathNode) []PathNode {
 	}
 	return nil
 }
-func (bd *BoltDB) getNextVisiblePath(path []PathNode) []PathNode {
-	visPaths, err := bd.buildVisiblePathSlice()
+func (bd *BoltDB) getNextVisiblePath(path []string, filter string) []string {
+	visPaths, err := bd.buildVisiblePathSlice(filter)
 	if path == nil {
 		if len(visPaths) > 0 {
 			return visPaths[0]
@@ -265,7 +198,7 @@ func (bd *BoltDB) getNextVisiblePath(path []PathNode) []PathNode {
 		for idx, pth := range visPaths {
 			isCurPath := true
 			for i := range path {
-				if len(pth) <= i || !bytes.Equal(path[i].name, pth[i].name) {
+				if len(pth) <= i || path[i] != pth[i] {
 					isCurPath = false
 					break
 				}
@@ -278,7 +211,7 @@ func (bd *BoltDB) getNextVisiblePath(path []PathNode) []PathNode {
 	return nil
 }

-func (bd *BoltDB) toggleOpenBucket(path []PathNode) error {
+func (bd *BoltDB) toggleOpenBucket(path []string) error {
 	// Find the BoltBucket with a path == path
 	b, err := bd.getBucketFromPath(path)
 	if err == nil {
@@ -287,7 +220,7 @@ func (bd *BoltDB) toggleOpenBucket(path []PathNode) error {
 	return err
 }

-func (bd *BoltDB) closeBucket(path []PathNode) error {
+func (bd *BoltDB) closeBucket(path []string) error {
 	// Find the BoltBucket with a path == path
 	b, err := bd.getBucketFromPath(path)
 	if err == nil {
@@ -296,7 +229,7 @@ func (bd *BoltDB) closeBucket(path []PathNode) error {
 	return err
 }

-func (bd *BoltDB) openBucket(path []PathNode) error {
+func (bd *BoltDB) openBucket(path []string) error {
 	// Find the BoltBucket with a path == path
 	b, err := bd.getBucketFromPath(path)
 	if err == nil {
@@ -305,9 +238,9 @@ func (bd *BoltDB) openBucket(path []PathNode) error {
 	return err
 }

-func (bd *BoltDB) getBucket(k []byte) (*BoltBucket, error) {
+func (bd *BoltDB) getBucket(k string) (*BoltBucket, error) {
 	for i := range bd.buckets {
-		if bytes.Equal(bd.buckets[i].name, k) {
+		if bd.buckets[i].name == k {
 			return &bd.buckets[i], nil
 		}
 	}
@@ -325,7 +258,7 @@ func (bd *BoltDB) syncOpenBuckets(shadow *BoltDB) {
 	// First test this bucket
 	for i := range bd.buckets {
 		for j := range shadow.buckets {
-			if bytes.Equal(bd.buckets[i].name, shadow.buckets[j].name) {
+			if bd.buckets[i].name == shadow.buckets[j].name {
 				bd.buckets[i].syncOpenBuckets(&shadow.buckets[j])
 			}
 		}
@@ -336,56 +269,54 @@ func (bd *BoltDB) refreshDatabase() *BoltDB {
 	// Reload the database into memBolt
 	memBolt = new(BoltDB)
 	db.View(func(tx *bolt.Tx) error {
-		return tx.ForEach(func(nm []byte, b *bolt.Bucket) error {
-			bb, err := readBucket(nil, b, nm)
+		err := tx.ForEach(func(nm []byte, b *bolt.Bucket) error {
+			bb, err := readBucket(b)
 			if err == nil {
-				bb.SetName(nm)
+				bb.name = string(nm)
 				bb.expanded = false
 				memBolt.buckets = append(memBolt.buckets, *bb)
 				return nil
 			}
 			return err
 		})
+		if err != nil {
+			// Check if there are key/values directly in the root
+			bb, err := readBucket(tx.Cursor().Bucket())
+			if err == nil {
+				bb.isRoot = true
+				bb.expanded = true
+				memBolt.buckets = append(memBolt.buckets, *bb)
+				return nil
+			}
+			return err
+		}
+		return err
 	})
 	return memBolt
 }

-/*
-GetStringName returns the name of the bucket after passing it through it's
-Datatype ToString function
-*/
-func (b *BoltBucket) GetStringName() string {
-	ret, err := b.nameDatatype.ToString(b.name)
-	if err != nil {
-		return "ERROR"
-	}
-	return ret
-}
-
 /*
 GetPath returns the database path leading to this BoltBucket
 */
-func (b *BoltBucket) GetPath() []PathNode {
-	bktPath := b.GetPathNode()
+func (b *BoltBucket) GetPath() []string {
 	if b.parent != nil {
-		return append(b.parent.GetPath(), bktPath)
+		return append(b.parent.GetPath(), b.name)
 	}
-	return []PathNode{bktPath}
+	return []string{b.name}
 }

 /*
-buildVisiblePathSlice builds a slice of PathNode slices containing all visible paths in this bucket
+buildVisiblePathSlice builds a slice of string slices containing all visible paths in this bucket
 The passed prefix is the path leading to the current bucket
 */
-func (b *BoltBucket) buildVisiblePathSlice(prefix []PathNode) ([][]PathNode, error) {
-	var retSlice [][]PathNode
+func (b *BoltBucket) buildVisiblePathSlice(prefix []string, filter string) ([][]string, error) {
+	var retSlice [][]string
 	var retErr error
-	bucketNode := b.GetPathNode()
-	retSlice = append(retSlice, append(prefix, bucketNode))
+	retSlice = append(retSlice, append(prefix, b.name))
 	if b.expanded {
 		// Add subbuckets
 		for i := range b.buckets {
-			bktS, bktErr := b.buckets[i].buildVisiblePathSlice(append(prefix, bucketNode))
+			bktS, bktErr := b.buckets[i].buildVisiblePathSlice(append(prefix, b.name), filter)
 			if bktErr != nil {
 				return retSlice, bktErr
 			}
@@ -393,7 +324,10 @@ func (b *BoltBucket) buildVisiblePathSlice(prefix []PathNode) ([][]PathNode, err
 		}
 		// Add pairs
 		for i := range b.pairs {
-			retSlice = append(retSlice, append(append(prefix, bucketNode, b.pairs[i].GetPathNode())))
+			if filter != "" && !strings.Contains(b.pairs[i].key, filter) {
+				continue
+			}
+			retSlice = append(retSlice, append(append(prefix, b.name), b.pairs[i].key))
 		}
 	}
 	return retSlice, retErr
@@ -404,7 +338,7 @@ func (b *BoltBucket) syncOpenBuckets(shadow *BoltBucket) {
 	b.expanded = shadow.expanded
 	for i := range b.buckets {
 		for j := range shadow.buckets {
-			if bytes.Equal(b.buckets[i].name, shadow.buckets[j].name) {
+			if b.buckets[i].name == shadow.buckets[j].name {
 				b.buckets[i].syncOpenBuckets(&shadow.buckets[j])
 			}
 		}
@@ -418,18 +352,18 @@ func (b *BoltBucket) openAllBuckets() {
 	}
 }

-func (b *BoltBucket) getBucket(k []byte) (*BoltBucket, error) {
+func (b *BoltBucket) getBucket(k string) (*BoltBucket, error) {
 	for i := range b.buckets {
-		if bytes.Equal(b.buckets[i].name, k) {
+		if b.buckets[i].name == k {
 			return &b.buckets[i], nil
 		}
 	}
 	return nil, errors.New("Bucket Not Found")
 }

-func (b *BoltBucket) getPair(k []byte) (*BoltPair, error) {
+func (b *BoltBucket) getPair(k string) (*BoltPair, error) {
 	for i := range b.pairs {
-		if bytes.Equal(b.pairs[i].key, k) {
+		if b.pairs[i].key == k {
 			return &b.pairs[i], nil
 		}
 	}
@@ -439,14 +373,8 @@ func (b *BoltBucket) getPair(k []byte) (*BoltPair, error) {
 /*
 GetPath Returns the path of the BoltPair
 */
-func (p *BoltPair) GetPath() []PathNode {
-  if p.parent == nil {
-    return []PathNode{p.GetPathNode()}
-  }
-	return append(
-		p.parent.GetPath(),
-		p.GetPathNode(),
-	)
+func (p *BoltPair) GetPath() []string {
+	return append(p.parent.GetPath(), p.key)
 }

 /* This is a go-between function (between the boltbrowser structs
@@ -456,9 +384,9 @@ func (p *BoltPair) GetPath() []PathNode {
 * Mainly used for moving a bucket from one path to another
 * as in the 'renameBucket' function below.
 */
-func addBucketFromBoltBucket(path []PathNode, bb *BoltBucket) error {
+func addBucketFromBoltBucket(path []string, bb *BoltBucket) error {
 	if err := insertBucket(path, bb.name); err == nil {
-		bucketPath := append(path, bb.GetPathNode())
+		bucketPath := append(path, bb.name)
 		for i := range bb.pairs {
 			if err = insertPair(bucketPath, bb.pairs[i].key, bb.pairs[i].val); err != nil {
 				return err
@@ -473,7 +401,7 @@ func addBucketFromBoltBucket(path []PathNode, bb *BoltBucket) error {
 	return nil
 }

-func deleteKey(path []PathNode) error {
+func deleteKey(path []string) error {
 	if AppArgs.ReadOnly {
 		return errors.New("DB is in Read-Only Mode")
 	}
@@ -482,13 +410,17 @@ func deleteKey(path []PathNode) error {
 		// the rest are buckets leading to that key
 		if len(path) == 1 {
 			// Deleting a root bucket
-			return tx.DeleteBucket(path[0].name)
+			return tx.DeleteBucket([]byte(path[0]))
+		}
+		b := tx.Bucket([]byte(path[0]))
+		if b == nil {
+			// Invalid path, try for the root bucket
+			b = tx.Cursor().Bucket()
 		}
-		b := tx.Bucket(path[0].name)
 		if b != nil {
 			if len(path) > 1 {
 				for i := range path[1 : len(path)-1] {
-					b = b.Bucket(path[i+1].name)
+					b = b.Bucket([]byte(path[i+1]))
 					if b == nil {
 						return errors.New("deleteKey: Invalid Path")
 					}
@@ -496,11 +428,11 @@ func deleteKey(path []PathNode) error {
 			}
 			// Now delete the last key in the path
 			var err error
-			if deleteBkt := b.Bucket(path[len(path)-1].name); deleteBkt == nil {
+			if deleteBkt := b.Bucket([]byte(path[len(path)-1])); deleteBkt == nil {
 				// Must be a pair
-				err = b.Delete(path[len(path)-1].name)
+				err = b.Delete([]byte(path[len(path)-1]))
 			} else {
-				err = b.DeleteBucket(path[len(path)-1].name)
+				err = b.DeleteBucket([]byte(path[len(path)-1]))
 			}
 			return err
 		}
@@ -509,41 +441,78 @@ func deleteKey(path []PathNode) error {
 	return err
 }

-// Recursively read a bucket and pairs from the DB
-func readBucket(parent *BoltBucket, b *bolt.Bucket, nm []byte) (*BoltBucket, error) {
-  bb := NewBoltBucket(parent, nm)
+func readBucket(b *bolt.Bucket) (*BoltBucket, error) {
+	bb := new(BoltBucket)
+	if b == nil {
+		return nil, errors.New("No bucket passed")
+	}
 	b.ForEach(func(k, v []byte) error {
 		if v == nil {
-			tb, err := readBucket(bb, b.Bucket(k), k)
+			tb, err := readBucket(b.Bucket(k))
+			tb.parent = bb
 			if err == nil {
+				tb.name = string(k)
 				bb.buckets = append(bb.buckets, *tb)
 			}
 		} else {
-			bb.pairs = append(bb.pairs, *NewBoltPair(bb, k, v))
+			tp := BoltPair{key: string(k), val: string(v)}
+			tp.parent = bb
+			bb.pairs = append(bb.pairs, tp)
 		}
 		return nil
 	})
 	return bb, nil
 }

-func renameBucket(path []PathNode, name []byte) error {
-	if bytes.Equal(name, path[len(path)-1].name) {
+func renameBucket(path []string, name string) error {
+	if name == path[len(path)-1] {
 		// No change requested
 		return nil
 	}
 	var bb *BoltBucket // For caching the current bucket
-  bb, err := memBolt.getBucketFromPath(path)
-  if err != nil {
-    return err
-  }
+	err := db.View(func(tx *bolt.Tx) error {
+		// len(b.path)-1 is the key we need to delete,
+		// the rest are buckets leading to that key
+		b := tx.Bucket([]byte(path[0]))
+		if b == nil {
+			// Invalid path, try for the root bucket
+			b = tx.Cursor().Bucket()
+		}
+		if b != nil {
+			if len(path) > 1 {
+				for i := range path[1:] {
+					b = b.Bucket([]byte(path[i+1]))
+					if b == nil {
+						return errors.New("renameBucket: Invalid Path")
+					}
+				}
+			}
+			var err error
+			// Ok, cache b
+			bb, err = readBucket(b)
+			if err != nil {
+				return err
+			}
+		} else {
+			return errors.New("renameBucket: Invalid Bucket")
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	if bb == nil {
+		return errors.New("renameBucket: Couldn't find Bucket")
+	}

-	// Ok, we have the bucket, now delete the current instance
+	// Ok, we have the bucket cached, now delete the current instance
 	if err = deleteKey(path); err != nil {
 		return err
 	}
 	// Rechristen our cached bucket
-	bb.SetName(name)
+	bb.name = name
 	// And re-add it
+
 	parentPath := path[:len(path)-1]
 	if err = addBucketFromBoltBucket(parentPath, bb); err != nil {
 		return err
@@ -551,29 +520,33 @@ func renameBucket(path []PathNode, name []byte) error {
 	return nil
 }

-func updatePairKey(path []PathNode, k []byte) error {
+func updatePairKey(path []string, k string) error {
 	if AppArgs.ReadOnly {
 		return errors.New("DB is in Read-Only Mode")
 	}
 	err := db.Update(func(tx *bolt.Tx) error {
 		// len(b.path)-1 is the key for the pair we're updating,
 		// the rest are buckets leading to that key
-		b := tx.Bucket(path[0].name)
+		b := tx.Bucket([]byte(path[0]))
+		if b == nil {
+			// Invalid path, try for the root bucket
+			b = tx.Cursor().Bucket()
+		}
 		if b != nil {
 			if len(path) > 0 {
 				for i := range path[1 : len(path)-1] {
-					b = b.Bucket(path[i+1].name)
+					b = b.Bucket([]byte(path[i+1]))
 					if b == nil {
 						return errors.New("updatePairValue: Invalid Path")
 					}
 				}
 			}
-			bk := path[len(path)-1]
-			v := b.Get(bk.name)
-			err := b.Delete(bk.name)
+			bk := []byte(path[len(path)-1])
+			v := b.Get(bk)
+			err := b.Delete(bk)
 			if err == nil {
 				// Old pair has been deleted, now add the new one
-				err = b.Put(k, v)
+				err = b.Put([]byte(k), v)
 			}
 			// Now update the last key in the path
 			return err
@@ -583,25 +556,29 @@ func updatePairKey(path []PathNode, k []byte) error {
 	return err
 }

-func updatePairValue(path []PathNode, v []byte) error {
+func updatePairValue(path []string, v string) error {
 	if AppArgs.ReadOnly {
 		return errors.New("DB is in Read-Only Mode")
 	}
 	err := db.Update(func(tx *bolt.Tx) error {
 		// len(b.GetPath())-1 is the key for the pair we're updating,
 		// the rest are buckets leading to that key
-		b := tx.Bucket(path[0].name)
+		b := tx.Bucket([]byte(path[0]))
+		if b == nil {
+			// Invalid path, try for the root bucket
+			b = tx.Cursor().Bucket()
+		}
 		if b != nil {
 			if len(path) > 0 {
 				for i := range path[1 : len(path)-1] {
-					b = b.Bucket(path[i+1].name)
+					b = b.Bucket([]byte(path[i+1]))
 					if b == nil {
 						return errors.New("updatePairValue: Invalid Path")
 					}
 				}
 			}
 			// Now update the last key in the path
-			err := b.Put(path[len(path)-1].name, v)
+			err := b.Put([]byte(path[len(path)-1]), []byte(v))
 			return err
 		}
 		return errors.New("updatePairValue: Invalid Path")
@@ -609,26 +586,26 @@ func updatePairValue(path []PathNode, v []byte) error {
 	return err
 }

-func insertBucket(path []PathNode, n []byte) error {
+func insertBucket(path []string, n string) error {
 	if AppArgs.ReadOnly {
 		return errors.New("DB is in Read-Only Mode")
 	}
 	// Inserts a new bucket named 'n' at 'path'
 	err := db.Update(func(tx *bolt.Tx) error {
-		if len(path) == 0 {
+		if len(path) == 0 || path[0] == "" {
 			// insert at root
-			_, err := tx.CreateBucket(n)
+			_, err := tx.CreateBucket([]byte(n))
 			if err != nil {
 				return fmt.Errorf("insertBucket: %s", err)
 			}
 		} else {
 			rootBucket, path := path[0], path[1:]
-			b := tx.Bucket(rootBucket.name)
+			b := tx.Bucket([]byte(rootBucket))
 			if b != nil {
 				for len(path) > 0 {
-					var tstBucket PathNode
+					tstBucket := ""
 					tstBucket, path = path[0], path[1:]
-					nB := b.Bucket(tstBucket.name)
+					nB := b.Bucket([]byte(tstBucket))
 					if nB == nil {
 						// Not a bucket, if we're out of path, just move on
 						if len(path) != 0 {
@@ -639,7 +616,7 @@ func insertBucket(path []PathNode, n []byte) error {
 						b = nB
 					}
 				}
-				_, err := b.CreateBucket(n)
+				_, err := b.CreateBucket([]byte(n))
 				return err
 			}
 			return fmt.Errorf("insertBucket: Invalid Path %s", rootBucket)
@@ -649,7 +626,7 @@ func insertBucket(path []PathNode, n []byte) error {
 	return err
 }

-func insertPair(path []PathNode, k []byte, v []byte) error {
+func insertPair(path []string, k string, v string) error {
 	if AppArgs.ReadOnly {
 		return errors.New("DB is in Read-Only Mode")
 	}
@@ -660,17 +637,21 @@ func insertPair(path []PathNode, k []byte, v []byte) error {
 			return errors.New("insertPair: Cannot insert pair at root")
 		}
 		var err error
-		b := tx.Bucket(path[0].name)
+		b := tx.Bucket([]byte(path[0]))
+		if b == nil {
+			// Invalid path, try for the root bucket
+			b = tx.Cursor().Bucket()
+		}
 		if b != nil {
 			if len(path) > 0 {
 				for i := 1; i < len(path); i++ {
-					b = b.Bucket(path[i].name)
+					b = b.Bucket([]byte(path[i]))
 					if b == nil {
 						return fmt.Errorf("insertPair: %s", err)
 					}
 				}
 			}
-			err := b.Put(k, v)
+			err := b.Put([]byte(k), []byte(v))
 			if err != nil {
 				return fmt.Errorf("insertPair: %s", err)
 			}
@@ -680,80 +661,56 @@ func insertPair(path []PathNode, k []byte, v []byte) error {
 	return err
 }

-func stringPathToBytePath(path []string) [][]byte {
-	var ret [][]byte
-	for _, v := range path {
-		ret = append(ret, []byte(v))
-	}
-	return ret
-}
-
-func bytePathToStringPath(path [][]byte) []string {
-	var ret []string
-	for _, v := range path {
-		ret = append(ret, string(v))
-	}
-	return ret
-}
-
-func nodePathToStringPath(path []PathNode) []string {
-	var ret []string
-	for _, v := range path {
-		add, err := v.dataType.ToString(v.name)
-		if err != nil {
-			add = "ERROR"
-		}
-		ret = append(ret, add)
-	}
-	return ret
-}
-
-func exportValue(path []PathNode, fName string) error {
+func exportValue(path []string, fName string) error {
 	return db.View(func(tx *bolt.Tx) error {
 		// len(b.path)-1 is the key whose value we want to export
 		// the rest are buckets leading to that key
-		b := tx.Bucket(path[0].name)
+		b := tx.Bucket([]byte(path[0]))
+		if b == nil {
+			// Invalid path, try for the root bucket
+			b = tx.Cursor().Bucket()
+		}
 		if b != nil {
 			if len(path) > 1 {
 				for i := range path[1 : len(path)-1] {
-					b = b.Bucket(path[i+1].name)
+					b = b.Bucket([]byte(path[i+1]))
 					if b == nil {
-						return errors.New("exportValue: Invalid Path: " + strings.Join(nodePathToStringPath(path), "/"))
+						return errors.New("exportValue: Invalid Path: " + strings.Join(path, "/"))
 					}
 				}
 			}
-			bk := path[len(path)-1]
-			v := b.Get(bk.name)
+			bk := []byte(path[len(path)-1])
+			v := b.Get(bk)
 			return writeToFile(fName, string(v)+"\n", os.O_CREATE|os.O_WRONLY|os.O_TRUNC)
 		}
 		return errors.New("exportValue: Invalid Bucket")
 	})
 }

-func exportJSON(path []PathNode, fName string) error {
+func exportJSON(path []string, fName string) error {
 	return db.View(func(tx *bolt.Tx) error {
 		// len(b.path)-1 is the key whose value we want to export
 		// the rest are buckets leading to that key
-		b := tx.Bucket(path[0].name)
+		b := tx.Bucket([]byte(path[0]))
+		if b == nil {
+			// Invalid path, try for the root bucket
+			b = tx.Cursor().Bucket()
+		}
 		if b != nil {
 			if len(path) > 1 {
 				for i := range path[1 : len(path)-1] {
-					b = b.Bucket(path[i+1].name)
+					b = b.Bucket([]byte(path[i+1]))
 					if b == nil {
-						return errors.New("exportValue: Invalid Path: " + strings.Join(nodePathToStringPath(path), "/"))
+						return errors.New("exportValue: Invalid Path: " + strings.Join(path, "/"))
 					}
 				}
 			}
-			bk := path[len(path)-1]
-			if v := b.Get(bk.name); v != nil {
-				str, err := bk.dataType.ToString(bk.name)
-				if err != nil {
-					str = "ERROR"
-				}
-				return writeToFile(fName, "{\""+str+"\":\""+string(v)+"\"}", os.O_CREATE|os.O_WRONLY|os.O_TRUNC)
+			bk := []byte(path[len(path)-1])
+			if v := b.Get(bk); v != nil {
+				return writeToFile(fName, "{\""+string(bk)+"\":\""+string(v)+"\"}", os.O_CREATE|os.O_WRONLY|os.O_TRUNC)
 			}
-			if b.Bucket(bk.name) != nil {
-				return writeToFile(fName, genJSONString(b.Bucket(bk.name)), os.O_CREATE|os.O_WRONLY|os.O_TRUNC)
+			if b.Bucket(bk) != nil {
+				return writeToFile(fName, genJSONString(b.Bucket(bk)), os.O_CREATE|os.O_WRONLY|os.O_TRUNC)
 			}
 			return writeToFile(fName, genJSONString(b), os.O_CREATE|os.O_WRONLY|os.O_TRUNC)
 		}
--- a/datatype.go
+++ b/datatype.go
@@ -1,9 +0,0 @@
-package main
-
-// A Datatype interface knows how to convert a byte slice into a
-// specific data type.
-type Datatype interface {
-	Name() string                      // Type Name, for UI display
-	ToString([]byte) (string, error)   // ToString takes a []byte from the DB and returns the string to display
-	FromString(string) ([]byte, error) // FromString takes a string and returns the []byte for the DB
-}
--- a/datatype_int.go
+++ b/datatype_int.go
@@ -1,39 +0,0 @@
-package main
-
-import (
-  "fmt"
-	"encoding/binary"
-	"strconv"
-)
-
-// Datatype_Int manages the int data type
-type Datatype_Int64 struct{}
-
-func (t *Datatype_Int64) Name() string {
-	return "int"
-}
-
-func (t *Datatype_Int64) ToString(data []byte) (string, error) {
-  return fmt.Sprintf("%d", t.btoi(data)), nil
-}
-
-func (t *Datatype_Int64) FromString(val string) ([]byte, error) {
-  v, err := strconv.ParseInt(val, 10, 64)
-  if err != nil {
-    return []byte{}, err
-  }
-  return t.itob(v), nil
-}
-
-func (t *Datatype_Int64) itob(v int64) []byte {
-  b := make([]byte, 8)
-  binary.BigEndian.PutUint64(b, uint64(v))
-  return b
-}
-
-func (t *Datatype_Int64) btoi(b []byte) int64 {
-  if len(b) < 8 {
-    return 0
-  }
-  return int64(binary.BigEndian.Uint64(b))
-}
--- a/datatype_string.go
+++ b/datatype_string.go
@@ -1,37 +0,0 @@
-package main
-
-import (
-	"errors"
-	"unicode/utf8"
-)
-
-// Datatype_String is basically the default type for
-// boltbrowser (and the boltease library)
-type Datatype_String struct{}
-
-func (t *Datatype_String) Name() string {
-	return "string"
-}
-
-func (t *Datatype_String) ToString(data []byte) (string, error) {
-	if utf8.Valid(data) {
-		ok := true
-		for _, r := range string(data) {
-			if r < 0x20 {
-				ok = false
-				break
-			} else if r >= 0x7f && r <= 0x9f {
-				ok = false
-				break
-			}
-		}
-		if ok {
-			return string(data), nil
-		}
-	}
-	return "", errors.New("Invalid String Data")
-}
-
-func (t *Datatype_String) FromString(val string) ([]byte, error) {
-	return []byte(val), nil
-}
--- a/datatype_uint.go
+++ b/datatype_uint.go
@@ -1,37 +0,0 @@
-package main
-
-import (
-	"encoding/binary"
-	"errors"
-	"strconv"
-)
-
-// Datatype_Uint64 manages the uint64 data type
-// All conversions just use the binary package
-type Datatype_Uint64 struct{}
-
-func (t *Datatype_Uint64) Name() string {
-	return "uint64"
-}
-
-func (t *Datatype_Uint64) ToString(data []byte) (string, error) {
-	ret, bt := binary.Uvarint(data)
-	if bt == 0 {
-		return "", errors.New("Byte Buffer too small")
-	} else if bt < 0 {
-		return "", errors.New("Value larger than 64 bits")
-	}
-	return strconv.FormatUint(ret, 10), nil
-}
-
-func (t *Datatype_Uint64) FromString(val string) ([]byte, error) {
-	var err error
-	var u uint64
-	buf := make([]byte, binary.MaxVarintLen64)
-	u, err = strconv.ParseUint(val, 10, 64)
-	if err != nil {
-		return nil, err
-	}
-	binary.PutUvarint(buf, u)
-	return buf, nil
-}
--- a/main.go
+++ b/main.go
@@ -18,9 +18,6 @@ var databaseFiles []string
 var db *bolt.DB
 var memBolt *BoltDB

-var datatypes map[string]Datatype
-var dataTypeNameSlice []string
-
 var currentFilename string

 const DefaultDBOpenTimeout = time.Second
@@ -28,6 +25,7 @@ const DefaultDBOpenTimeout = time.Second
 var AppArgs struct {
 	DBOpenTimeout time.Duration
 	ReadOnly      bool
+	NoValue       bool
 }

 func init() {
@@ -66,6 +64,10 @@ func parseArgs() {
 				if val == "true" {
 					AppArgs.ReadOnly = true
 				}
+			case "-no-value":
+				if val == "true" {
+					AppArgs.NoValue = true
+				}
 			case "-help":
 				printUsage(nil)
 			default:
@@ -76,6 +78,8 @@ func parseArgs() {
 			switch parms[i] {
 			case "-readonly", "-ro":
 				AppArgs.ReadOnly = true
+			case "-no-value":
+				AppArgs.NoValue = true
 			case "-help":
 				printUsage(nil)
 			default:
@@ -92,13 +96,13 @@ func printUsage(err error) {
 	fmt.Fprintf(os.Stderr, "Usage: %s [OPTIONS] <filename(s)>\nOptions:\n", ProgramName)
 	fmt.Fprintf(os.Stderr, "  -timeout=duration\n        DB file open timeout (default 1s)\n")
 	fmt.Fprintf(os.Stderr, "  -ro, -readonly   \n        Open the DB in read-only mode\n")
+	fmt.Fprintf(os.Stderr, "  -no-value        \n        Do not display a value in left pane\n")
 }

 func main() {
 	var err error

 	parseArgs()
-	initDataTypes()

 	err = termbox.Init()
 	if err != nil {
@@ -138,15 +142,3 @@ func main() {
 		defer db.Close()
 	}
 }
-
-func initDataTypes() {
-	datatypes = make(map[string]Datatype)
-	for _, t := range []Datatype{
-		&Datatype_String{},
-		&Datatype_Int64{},
-		&Datatype_Uint64{},
-	} {
-    dataTypeNameSlice = append(dataTypeNameSlice, t.Name())
-		datatypes[t.Name()] = t
-	}
-}
--- a/screen_browser.go
+++ b/screen_browser.go
@@ -1,9 +1,9 @@
 package main

 import (
-	"bytes"
 	"encoding/json"
 	"fmt"
+	"path/filepath"
 	"strings"
 	"time"

@@ -29,9 +29,10 @@ type BrowserScreen struct {
 	leftViewPort   ViewPort
 	rightViewPort  ViewPort
 	queuedCommand  string
-	currentPath    []PathNode
+	currentPath    []string
 	currentType    int
 	message        string
+	filter         string
 	mode           BrowserMode
 	inputModal     *termboxUtil.InputModal
 	confirmModal   *termboxUtil.ConfirmModal
@@ -40,7 +41,6 @@ type BrowserScreen struct {

 	leftPaneBuffer  []Line
 	rightPaneBuffer []Line
-
 }

 /*
@@ -53,6 +53,7 @@ const (
 	modeChange        = 32  // 0000 0010 0000
 	modeChangeKey     = 33  // 0000 0010 0001
 	modeChangeVal     = 34  // 0000 0010 0010
+	modeFilter        = 35  // 0100 0010 0011
 	modeInsert        = 64  // 0000 0100 0000
 	modeInsertBucket  = 65  // 0000 0100 0001
 	modeInsertPair    = 68  // 0000 0100 0100
@@ -104,11 +105,11 @@ func (screen *BrowserScreen) handleBrowseKeyEvent(event termbox.Event) int {

 	} else if event.Ch == 'g' {
 		// Jump to Beginning
-		screen.currentPath = screen.db.getNextVisiblePath(nil)
+		screen.currentPath = screen.db.getNextVisiblePath(nil, screen.filter)

 	} else if event.Ch == 'G' {
 		// Jump to End
-		screen.currentPath = screen.db.getPrevVisiblePath(nil)
+		screen.currentPath = screen.db.getPrevVisiblePath(nil, screen.filter)

 	} else if event.Key == termbox.KeyCtrlR {
 		screen.refreshDatabase()
@@ -151,18 +152,20 @@ func (screen *BrowserScreen) handleBrowseKeyEvent(event termbox.Event) int {
 		screen.startInsertItemAtParent(typeBucket)

 	} else if event.Ch == 'e' {
-		b, p, _ := screen.db.getGenericFromStringPath(screen.currentPath)
+		b, p, _ := screen.db.getGenericFromPath(screen.currentPath)
 		if b != nil {
 			screen.setMessage("Cannot edit a bucket, did you mean to (r)ename?")
 		} else if p != nil {
 			screen.startEditItem()
 		}
+	} else if event.Ch == '/' {
+		screen.startFilter()

 	} else if event.Ch == 'r' {
 		screen.startRenameItem()

 	} else if event.Key == termbox.KeyEnter {
-		b, p, _ := screen.db.getGenericFromStringPath(screen.currentPath)
+		b, p, _ := screen.db.getGenericFromPath(screen.currentPath)
 		if b != nil {
 			screen.db.toggleOpenBucket(screen.currentPath)
 		} else if p != nil {
@@ -170,7 +173,7 @@ func (screen *BrowserScreen) handleBrowseKeyEvent(event termbox.Event) int {
 		}

 	} else if event.Ch == 'l' || event.Key == termbox.KeyArrowRight {
-		b, p, _ := screen.db.getGenericFromStringPath(screen.currentPath)
+		b, p, _ := screen.db.getGenericFromPath(screen.currentPath)
 		// Select the current item
 		if b != nil {
 			screen.db.toggleOpenBucket(screen.currentPath)
@@ -182,7 +185,7 @@ func (screen *BrowserScreen) handleBrowseKeyEvent(event termbox.Event) int {

 	} else if event.Ch == 'h' || event.Key == termbox.KeyArrowLeft {
 		// If we are _on_ a bucket that's open, close it
-		b, _, e := screen.db.getGenericFromStringPath(screen.currentPath)
+		b, _, e := screen.db.getGenericFromPath(screen.currentPath)
 		if e == nil && b != nil && b.expanded {
 			screen.db.closeBucket(screen.currentPath)
 		} else {
@@ -206,27 +209,6 @@ func (screen *BrowserScreen) handleBrowseKeyEvent(event termbox.Event) int {
 	} else if event.Ch == 'X' {
 		// Export Key/Value (or Bucket) as JSON
 		screen.startExportJSON()
-
-	} else if event.Ch == 't' {
-		// TODO: change the type of the pair value being viewed
-		p, err := screen.db.getPairFromPath(screen.currentPath)
-		if err != nil {
-			screen.setMessage("Cannot change pair type (did you mean 'T': Change pair key/bucket name type?)")
-			return BrowserScreenIndex
-		}
-		p.valDatatype = findNextDatatype(p.valDatatype.Name())
-
-	} else if event.Ch == 'T' {
-		b, p, err := screen.db.getGenericFromStringPath(screen.currentPath)
-		if err != nil {
-			screen.setMessage("Error reading path... Not sure what to do.")
-			return BrowserScreenIndex
-		}
-		if b != nil {
-			b.nameDatatype = findNextDatatype(b.nameDatatype.Name())
-		} else if p != nil {
-			p.keyDatatype = findNextDatatype(p.keyDatatype.Name())
-		}
 	}
 	return BrowserScreenIndex
 }
@@ -238,53 +220,44 @@ func (screen *BrowserScreen) handleInputKeyEvent(event termbox.Event) int {
 	} else {
 		screen.inputModal.HandleEvent(event)
 		if screen.inputModal.IsDone() {
-			b, p, _ := screen.db.getGenericFromStringPath(screen.currentPath)
+			b, p, _ := screen.db.getGenericFromPath(screen.currentPath)
+			if screen.mode == modeFilter {
+				screen.filter = screen.inputModal.GetValue()
+				if !screen.db.isVisiblePath(screen.currentPath, screen.filter) {
+					screen.currentPath = screen.currentPath[:len(screen.currentPath)-1]
+				}
+			}
 			if b != nil {
 				if screen.mode == modeChangeKey {
 					newName := screen.inputModal.GetValue()
-          btName, err := b.nameDatatype.FromString(newName)
-          if err != nil {
-            screen.setMessage("Error renaming bucket: " + err.Error())
-          } else {
-            if renameBucket(screen.currentPath, btName) != nil {
-              screen.setMessage("Error renaming bucket.")
-            } else {
-              b.name = btName
-              screen.currentPath[len(screen.currentPath)-1].name = b.name
-              screen.setMessage("Bucket Renamed!")
-              screen.refreshDatabase()
-            }
+					if renameBucket(screen.currentPath, newName) != nil {
+						screen.setMessage("Error renaming bucket.")
+					} else {
+						b.name = newName
+						screen.currentPath[len(screen.currentPath)-1] = b.name
+						screen.setMessage("Bucket Renamed!")
+						screen.refreshDatabase()
 					}
 				}
 			} else if p != nil {
 				if screen.mode == modeChangeKey {
 					newKey := screen.inputModal.GetValue()
-          btKey, err := p.keyDatatype.FromString(newKey)
-          if err != nil {
-            screen.setMessage("Error updating pair: " + err.Error())
-          } else {
-            if updatePairKey(screen.currentPath, btKey) != nil {
-              screen.setMessage("Error occurred updating Pair.")
-            } else {
-              p.key = btKey
-              screen.currentPath[len(screen.currentPath)-1].name = p.key
-              screen.setMessage("Pair updated!")
-              screen.refreshDatabase()
-            }
+					if err := updatePairKey(screen.currentPath, newKey); err != nil {
+						screen.setMessage("Error occurred updating Pair.")
+					} else {
+						p.key = newKey
+						screen.currentPath[len(screen.currentPath)-1] = p.key
+						screen.setMessage("Pair updated!")
+						screen.refreshDatabase()
 					}
 				} else if screen.mode == modeChangeVal {
 					newVal := screen.inputModal.GetValue()
-          btVal, err := p.valDatatype.FromString(newVal)
-          if err != nil {
-            screen.setMessage("Error updating pair: " + err.Error())
-          } else {
-            if updatePairValue(screen.currentPath, btVal) != nil {
-              screen.setMessage("Error occurred updating Pair.")
-            } else {
-              p.val = btVal
-              screen.setMessage("Pair updated!")
-              screen.refreshDatabase()
-            }
+					if err := updatePairValue(screen.currentPath, newVal); err != nil {
+						screen.setMessage("Error occurred updating Pair.")
+					} else {
+						p.val = newVal
+						screen.setMessage("Pair updated!")
+						screen.refreshDatabase()
 					}
 				}
 			}
@@ -299,15 +272,15 @@ func (screen *BrowserScreen) handleDeleteKeyEvent(event termbox.Event) int {
 	screen.confirmModal.HandleEvent(event)
 	if screen.confirmModal.IsDone() {
 		if screen.confirmModal.IsAccepted() {
-			holdNextPath := screen.db.getNextVisiblePath(screen.currentPath)
-			holdPrevPath := screen.db.getPrevVisiblePath(screen.currentPath)
+			holdNextPath := screen.db.getNextVisiblePath(screen.currentPath, screen.filter)
+			holdPrevPath := screen.db.getPrevVisiblePath(screen.currentPath, screen.filter)
 			if deleteKey(screen.currentPath) == nil {
 				screen.refreshDatabase()
 				// Move the current path endpoint appropriately
 				//found_new_path := false
 				if holdNextPath != nil {
 					if len(holdNextPath) > 2 {
-						if bytes.Equal(holdNextPath[len(holdNextPath)-2].name, screen.currentPath[len(screen.currentPath)-2].name) {
+						if holdNextPath[len(holdNextPath)-2] == screen.currentPath[len(screen.currentPath)-2] {
 							screen.currentPath = holdNextPath
 						} else if holdPrevPath != nil {
 							screen.currentPath = holdPrevPath
@@ -343,21 +316,12 @@ func (screen *BrowserScreen) handleInsertKeyEvent(event termbox.Event) int {
 		screen.inputModal.HandleEvent(event)
 		if screen.inputModal.IsDone() {
 			newVal := screen.inputModal.GetValue()
-			// TODO: Just default datatype to string? Or should we infer it somehow?
-			useType := datatypes["string"]
-			nodeName, err := useType.FromString(newVal)
-			if err != nil {
-				screen.setMessage("Error Inserting new item. Data did not match datatype.")
-				return BrowserScreenIndex
-			}
-			newNode := PathNode{name: nodeName, dataType: useType}
 			screen.inputModal.Clear()
-			var insertPath []PathNode
+			var insertPath []string
 			if len(screen.currentPath) > 0 {
-				_, p, e := screen.db.getGenericFromStringPath(screen.currentPath)
+				_, p, e := screen.db.getGenericFromPath(screen.currentPath)
 				if e != nil {
 					screen.setMessage("Error Inserting new item. Invalid Path.")
-					return BrowserScreenIndex
 				}
 				insertPath = screen.currentPath
 				// where are we inserting?
@@ -369,14 +333,14 @@ func (screen *BrowserScreen) handleInsertKeyEvent(event termbox.Event) int {
 					if len(screen.currentPath) > 1 {
 						insertPath = screen.currentPath[:len(screen.currentPath)-1]
 					} else {
-						insertPath = make([]PathNode, 0)
+						insertPath = make([]string, 0)
 					}
 				}
 			}

-			parentB, _, _ := screen.db.getGenericFromStringPath(insertPath)
+			parentB, _, _ := screen.db.getGenericFromPath(insertPath)
 			if screen.mode&modeInsertBucket == modeInsertBucket {
-				err := insertBucket(insertPath, newNode.name)
+				err := insertBucket(insertPath, newVal)
 				if err != nil {
 					screen.setMessage(fmt.Sprintf("%s => %s", err, insertPath))
 				} else {
@@ -384,13 +348,13 @@ func (screen *BrowserScreen) handleInsertKeyEvent(event termbox.Event) int {
 						parentB.expanded = true
 					}
 				}
-				screen.currentPath = append(insertPath, newNode)
+				screen.currentPath = append(insertPath, newVal)

 				screen.refreshDatabase()
 				screen.mode = modeBrowse
 				screen.inputModal.Clear()
 			} else if screen.mode&modeInsertPair == modeInsertPair {
-				err := insertPair(insertPath, []byte(newVal), []byte{})
+				err := insertPair(insertPath, newVal, "")
 				if err != nil {
 					screen.setMessage(fmt.Sprintf("%s => %s", err, insertPath))
 					screen.refreshDatabase()
@@ -400,7 +364,7 @@ func (screen *BrowserScreen) handleInsertKeyEvent(event termbox.Event) int {
 					if parentB != nil {
 						parentB.expanded = true
 					}
-					screen.currentPath = append(insertPath, newNode)
+					screen.currentPath = append(insertPath, newVal)
 					screen.refreshDatabase()
 					screen.startEditItem()
 				}
@@ -417,7 +381,7 @@ func (screen *BrowserScreen) handleExportKeyEvent(event termbox.Event) int {
 	} else {
 		screen.inputModal.HandleEvent(event)
 		if screen.inputModal.IsDone() {
-			b, p, _ := screen.db.getGenericFromStringPath(screen.currentPath)
+			b, p, _ := screen.db.getGenericFromPath(screen.currentPath)
 			fileName := screen.inputModal.GetValue()
 			if screen.mode&modeExportValue == modeExportValue {
 				// Exporting the value
@@ -447,13 +411,13 @@ func (screen *BrowserScreen) handleExportKeyEvent(event termbox.Event) int {

 func (screen *BrowserScreen) jumpCursorUp(distance int) bool {
 	// Jump up 'distance' lines
-	visPaths, err := screen.db.buildVisiblePathSlice()
+	visPaths, err := screen.db.buildVisiblePathSlice(screen.filter)
 	if err == nil {
 		findPath := screen.currentPath
 		for idx, pth := range visPaths {
 			startJump := true
 			for i := range pth {
-				if len(screen.currentPath) > i && !bytes.Equal(pth[i].name, screen.currentPath[i].name) {
+				if len(screen.currentPath) > i && pth[i] != screen.currentPath[i] {
 					startJump = false
 				}
 			}
@@ -467,26 +431,26 @@ func (screen *BrowserScreen) jumpCursorUp(distance int) bool {
 		}
 		isCurPath := true
 		for i := range screen.currentPath {
-			if !bytes.Equal(screen.currentPath[i].name, findPath[i].name) {
+			if screen.currentPath[i] != findPath[i] {
 				isCurPath = false
 				break
 			}
 		}
 		if isCurPath {
-			screen.currentPath = screen.db.getNextVisiblePath(nil)
+			screen.currentPath = screen.db.getNextVisiblePath(nil, screen.filter)
 		}
 	}
 	return true
 }
 func (screen *BrowserScreen) jumpCursorDown(distance int) bool {
-	visPaths, err := screen.db.buildVisiblePathSlice()
+	visPaths, err := screen.db.buildVisiblePathSlice(screen.filter)
 	if err == nil {
 		findPath := screen.currentPath
 		for idx, pth := range visPaths {
 			startJump := true

 			for i := range pth {
-				if len(screen.currentPath) > i && !bytes.Equal(pth[i].name, screen.currentPath[i].name) {
+				if len(screen.currentPath) > i && pth[i] != screen.currentPath[i] {
 					startJump = false
 				}
 			}
@@ -500,20 +464,20 @@ func (screen *BrowserScreen) jumpCursorDown(distance int) bool {
 		}
 		isCurPath := true
 		for i := range screen.currentPath {
-			if !bytes.Equal(screen.currentPath[i].name, findPath[i].name) {
+			if screen.currentPath[i] != findPath[i] {
 				isCurPath = false
 				break
 			}
 		}
 		if isCurPath {
-			screen.currentPath = screen.db.getNextVisiblePath(nil)
+			screen.currentPath = screen.db.getNextVisiblePath(nil, screen.filter)
 		}
 	}
 	return true
 }

 func (screen *BrowserScreen) moveCursorUp() bool {
-	newPath := screen.db.getPrevVisiblePath(screen.currentPath)
+	newPath := screen.db.getPrevVisiblePath(screen.currentPath, screen.filter)
 	if newPath != nil {
 		screen.currentPath = newPath
 		return true
@@ -521,7 +485,7 @@ func (screen *BrowserScreen) moveCursorUp() bool {
 	return false
 }
 func (screen *BrowserScreen) moveCursorDown() bool {
-	newPath := screen.db.getNextVisiblePath(screen.currentPath)
+	newPath := screen.db.getNextVisiblePath(screen.currentPath, screen.filter)
 	if newPath != nil {
 		screen.currentPath = newPath
 		return true
@@ -571,10 +535,22 @@ func (screen *BrowserScreen) drawScreen(style Style) {

 func (screen *BrowserScreen) drawHeader(style Style) {
 	width, _ := termbox.Size()
-	headerString := ProgramName + ": " + currentFilename
-	spaces := strings.Repeat(" ", ((width-len(headerString))/2)+1)
+	headerStringLen := func(fileName string) int {
+		return len(ProgramName) + len(fileName) + 1
+	}
+	headerFileName := currentFilename
+	if headerStringLen(headerFileName) > width {
+		headerFileName = filepath.Base(headerFileName)
+	}
+	headerString := ProgramName + ": " + headerFileName
+	count := ((width - len(headerString)) / 2) + 1
+	if count < 0 {
+		count = 0
+	}
+	spaces := strings.Repeat(" ", count)
 	termboxUtil.DrawStringAtPoint(fmt.Sprintf("%s%s%s", spaces, headerString, spaces), 0, 0, style.titleFg, style.titleBg)
 }
+
 func (screen *BrowserScreen) drawFooter(style Style) {
 	if screen.messageTimeout > 0 && time.Since(screen.messageTime) > screen.messageTimeout {
 		screen.clearMessage()
@@ -586,7 +562,7 @@ func (screen *BrowserScreen) drawFooter(style Style) {
 func (screen *BrowserScreen) buildLeftPane(style Style) {
 	screen.leftPaneBuffer = nil
 	if len(screen.currentPath) == 0 {
-		screen.currentPath = screen.db.getNextVisiblePath(nil)
+		screen.currentPath = screen.db.getNextVisiblePath(nil, screen.filter)
 	}
 	for i := range screen.db.buckets {
 		screen.leftPaneBuffer = append(screen.leftPaneBuffer, screen.bucketToLines(&screen.db.buckets[i], style)...)
@@ -626,29 +602,25 @@ func (screen *BrowserScreen) drawLeftPane(style Style) {

 func (screen *BrowserScreen) buildRightPane(style Style) {
 	screen.rightPaneBuffer = nil
-
-	b, p, err := screen.db.getGenericFromStringPath(screen.currentPath)
+	b, p, err := screen.db.getGenericFromPath(screen.currentPath)
 	if err == nil {
 		if b != nil {
 			screen.rightPaneBuffer = append(screen.rightPaneBuffer,
-				Line{fmt.Sprintf("Path: %s", strings.Join(nodePathToStringPath(b.GetPath()), " → ")), style.defaultFg, style.defaultBg})
+				Line{fmt.Sprintf("Path: %s", strings.Join(stringifyPath(b.GetPath()), " → ")), style.defaultFg, style.defaultBg})
 			screen.rightPaneBuffer = append(screen.rightPaneBuffer,
 				Line{fmt.Sprintf("Buckets: %d", len(b.buckets)), style.defaultFg, style.defaultBg})
 			screen.rightPaneBuffer = append(screen.rightPaneBuffer,
 				Line{fmt.Sprintf("Pairs: %d", len(b.pairs)), style.defaultFg, style.defaultBg})
-      screen.rightPaneBuffer = append(screen.rightPaneBuffer,
-        Line{fmt.Sprintf("Name Datatype: %s", b.nameDatatype.Name()), style.defaultFg, style.defaultBg})
-
 		} else if p != nil {
 			screen.rightPaneBuffer = append(screen.rightPaneBuffer,
-				Line{fmt.Sprintf("Path: %s", strings.Join(nodePathToStringPath(p.GetPath()), " → ")), style.defaultFg, style.defaultBg})
+				Line{fmt.Sprintf("Path: %s", strings.Join(stringifyPath(p.GetPath()), " → ")), style.defaultFg, style.defaultBg})
 			screen.rightPaneBuffer = append(screen.rightPaneBuffer,
-				Line{fmt.Sprintf("Key (%s): %s", p.keyDatatype.Name(), p.GetStringKey()), style.defaultFg, style.defaultBg})
+				Line{fmt.Sprintf("Key: %s", stringify([]byte(p.key))), style.defaultFg, style.defaultBg})

 			value := strings.Split(string(formatValue([]byte(p.val))), "\n")
 			if len(value) == 1 {
 				screen.rightPaneBuffer = append(screen.rightPaneBuffer,
-					Line{fmt.Sprintf("Value (%s): %s", p.valDatatype.Name(), value[0]), style.defaultFg, style.defaultBg})
+					Line{fmt.Sprintf("Value: %s", value[0]), style.defaultFg, style.defaultBg})
 			} else {
 				screen.rightPaneBuffer = append(screen.rightPaneBuffer,
 					Line{"Value:", style.defaultFg, style.defaultBg})
@@ -660,12 +632,10 @@ func (screen *BrowserScreen) buildRightPane(style Style) {
 		}
 	} else {
 		screen.rightPaneBuffer = append(screen.rightPaneBuffer,
-			Line{fmt.Sprintf("Path: %s", strings.Join(nodePathToStringPath(screen.currentPath), " → ")), style.defaultFg, style.defaultBg})
+			Line{fmt.Sprintf("Path: %s", strings.Join(stringifyPath(screen.currentPath), " → ")), style.defaultFg, style.defaultBg})
 		screen.rightPaneBuffer = append(screen.rightPaneBuffer,
 			Line{err.Error(), termbox.ColorRed, termbox.ColorBlack})
 	}
-	screen.rightPaneBuffer = append(screen.rightPaneBuffer,
-		Line{"", style.defaultFg, style.defaultBg})
 }

 func (screen *BrowserScreen) drawRightPane(style Style) {
@@ -727,27 +697,35 @@ func (screen *BrowserScreen) bucketToLines(bkt *BoltBucket, style Style) []Line
 	}
 	bktPrefix := strings.Repeat(" ", len(bkt.GetPath())*2)
 	if bkt.expanded {
-		ret = append(ret, Line{bktPrefix + "- " + bkt.GetStringName(), bfg, bbg})
+		ret = append(ret, Line{bktPrefix + "- " + stringify([]byte(bkt.name)), bfg, bbg})
 		for i := range bkt.buckets {
 			ret = append(ret, screen.bucketToLines(&bkt.buckets[i], style)...)
 		}
 		for _, bp := range bkt.pairs {
+			if screen.filter != "" && !strings.Contains(bp.key, screen.filter) {
+				continue
+			}
 			pfg, pbg := style.defaultFg, style.defaultBg
 			if comparePaths(screen.currentPath, bp.GetPath()) {
 				pfg, pbg = style.cursorFg, style.cursorBg
 			}
 			prPrefix := strings.Repeat(" ", len(bp.GetPath())*2)
-			pairString := fmt.Sprintf("%s%s: %s", prPrefix, bp.GetStringKey(), bp.GetStringVal())
+			var pairString string
+			if AppArgs.NoValue {
+				pairString = fmt.Sprintf("%s%s", prPrefix, stringify([]byte(bp.key)))
+			} else {
+				pairString = fmt.Sprintf("%s%s: %s", prPrefix, stringify([]byte(bp.key)), stringify([]byte(bp.val)))
+			}
 			ret = append(ret, Line{pairString, pfg, pbg})
 		}
 	} else {
-		ret = append(ret, Line{bktPrefix + "+ " + bkt.GetStringName(), bfg, bbg})
+		ret = append(ret, Line{bktPrefix + "+ " + stringify([]byte(bkt.name)), bfg, bbg})
 	}
 	return ret
 }

 func (screen *BrowserScreen) startDeleteItem() bool {
-	b, p, e := screen.db.getGenericFromStringPath(screen.currentPath)
+	b, p, e := screen.db.getGenericFromPath(screen.currentPath)
 	if e == nil {
 		w, h := termbox.Size()
 		inpW, inpH := (w / 2), 6
@@ -767,8 +745,25 @@ func (screen *BrowserScreen) startDeleteItem() bool {
 	return false
 }

+func (screen *BrowserScreen) startFilter() bool {
+	_, _, e := screen.db.getGenericFromPath(screen.currentPath)
+	if e == nil {
+		w, h := termbox.Size()
+		inpW, inpH := (w / 2), 6
+		inpX, inpY := ((w / 2) - (inpW / 2)), ((h / 2) - inpH)
+		mod := termboxUtil.CreateInputModal("", inpX, inpY, inpW, inpH, termbox.ColorWhite, termbox.ColorBlack)
+		mod.SetTitle(termboxUtil.AlignText("Filter", inpW, termboxUtil.AlignCenter))
+		mod.SetValue(screen.filter)
+		mod.Show()
+		screen.inputModal = mod
+		screen.mode = modeFilter
+		return true
+	}
+	return false
+}
+
 func (screen *BrowserScreen) startEditItem() bool {
-	_, p, e := screen.db.getGenericFromStringPath(screen.currentPath)
+	_, p, e := screen.db.getGenericFromPath(screen.currentPath)
 	if e == nil {
 		w, h := termbox.Size()
 		inpW, inpH := (w / 2), 6
@@ -776,7 +771,7 @@ func (screen *BrowserScreen) startEditItem() bool {
 		mod := termboxUtil.CreateInputModal("", inpX, inpY, inpW, inpH, termbox.ColorWhite, termbox.ColorBlack)
 		if p != nil {
 			mod.SetTitle(termboxUtil.AlignText(fmt.Sprintf("Input new value for '%s'", p.key), inpW, termboxUtil.AlignCenter))
-			mod.SetValue(p.GetStringVal())
+			mod.SetValue(p.val)
 		}
 		mod.Show()
 		screen.inputModal = mod
@@ -787,18 +782,18 @@ func (screen *BrowserScreen) startEditItem() bool {
 }

 func (screen *BrowserScreen) startRenameItem() bool {
-	b, p, e := screen.db.getGenericFromStringPath(screen.currentPath)
+	b, p, e := screen.db.getGenericFromPath(screen.currentPath)
 	if e == nil {
 		w, h := termbox.Size()
 		inpW, inpH := (w / 2), 6
 		inpX, inpY := ((w / 2) - (inpW / 2)), ((h / 2) - inpH)
 		mod := termboxUtil.CreateInputModal("", inpX, inpY, inpW, inpH, termbox.ColorWhite, termbox.ColorBlack)
 		if b != nil {
-			mod.SetTitle(termboxUtil.AlignText(fmt.Sprintf("Rename Bucket '%s' to:", b.GetStringName()), inpW, termboxUtil.AlignCenter))
-			mod.SetValue(b.GetStringName())
+			mod.SetTitle(termboxUtil.AlignText(fmt.Sprintf("Rename Bucket '%s' to:", b.name), inpW, termboxUtil.AlignCenter))
+			mod.SetValue(b.name)
 		} else if p != nil {
-			mod.SetTitle(termboxUtil.AlignText(fmt.Sprintf("Rename Key '%s' to:", p.GetStringKey()), inpW, termboxUtil.AlignCenter))
-			mod.SetValue(p.GetStringKey())
+			mod.SetTitle(termboxUtil.AlignText(fmt.Sprintf("Rename Key '%s' to:", p.key), inpW, termboxUtil.AlignCenter))
+			mod.SetValue(p.key)
 		}
 		mod.Show()
 		screen.inputModal = mod
@@ -827,12 +822,11 @@ func (screen *BrowserScreen) startInsertItemAtParent(tp BoltType) bool {
 		}
 	} else {
 		var insPath string
-		_, p, e := screen.db.getGenericFromStringPath(screen.currentPath[:len(screen.currentPath)-1])
-		stringPath := nodePathToStringPath(screen.currentPath)
+		_, p, e := screen.db.getGenericFromPath(screen.currentPath[:len(screen.currentPath)-1])
 		if e == nil && p != nil {
-			insPath = strings.Join(stringPath[:len(stringPath)-2], " → ") + " → "
+			insPath = strings.Join(screen.currentPath[:len(screen.currentPath)-2], " → ") + " → "
 		} else {
-			insPath = strings.Join(stringPath[:len(stringPath)-1], " → ") + " → "
+			insPath = strings.Join(screen.currentPath[:len(screen.currentPath)-1], " → ") + " → "
 		}
 		titlePrfx := ""
 		if tp == typeBucket {
@@ -871,12 +865,11 @@ func (screen *BrowserScreen) startInsertItem(tp BoltType) bool {
 	//mod.SetInputWrap(true)
 	screen.inputModal = mod
 	var insPath string
-	_, p, e := screen.db.getGenericFromStringPath(screen.currentPath)
-	strPath := nodePathToStringPath(screen.currentPath)
+	_, p, e := screen.db.getGenericFromPath(screen.currentPath)
 	if e == nil && p != nil {
-		insPath = strings.Join(strPath[:len(strPath)-1], " → ") + " → "
+		insPath = strings.Join(screen.currentPath[:len(screen.currentPath)-1], " → ") + " → "
 	} else {
-		insPath = strings.Join(strPath, " → ") + " → "
+		insPath = strings.Join(screen.currentPath, " → ") + " → "
 	}
 	titlePrfx := ""
 	if tp == typeBucket {
@@ -904,7 +897,7 @@ func (screen *BrowserScreen) startInsertItem(tp BoltType) bool {
 }

 func (screen *BrowserScreen) startExportValue() bool {
-	_, p, e := screen.db.getGenericFromStringPath(screen.currentPath)
+	_, p, e := screen.db.getGenericFromPath(screen.currentPath)
 	if e == nil && p != nil {
 		w, h := termbox.Size()
 		inpW, inpH := (w / 2), 6
@@ -917,17 +910,12 @@ func (screen *BrowserScreen) startExportValue() bool {
 		screen.mode = modeExportValue
 		return true
 	}
-	expNode := screen.currentPath[len(screen.currentPath)-1]
-	strVal, err := expNode.dataType.ToString(expNode.name)
-	if err != nil {
-		strVal = "ERROR"
-	}
-	screen.setMessage("Couldn't do string export on " + strVal + " (did you mean 'X'?)")
+	screen.setMessage("Couldn't do string export on " + screen.currentPath[len(screen.currentPath)-1] + "(did you mean 'X'?)")
 	return false
 }

 func (screen *BrowserScreen) startExportJSON() bool {
-	b, p, e := screen.db.getGenericFromStringPath(screen.currentPath)
+	b, p, e := screen.db.getGenericFromPath(screen.currentPath)
 	if e == nil {
 		w, h := termbox.Size()
 		inpW, inpH := (w / 2), 6
@@ -974,31 +962,6 @@ func (screen *BrowserScreen) refreshDatabase() {
 	screen.db.syncOpenBuckets(shadowDB)
 }

-func findNextDatatype(curr string) Datatype {
-	var first Datatype
-	var found bool
-	for k, v := range datatypes {
-		if first == nil {
-			first = v
-		}
-		if found {
-			return v
-		}
-		if k == curr {
-			found = true
-		}
-	}
-	return first
-}
-
-func comparePaths(p1, p2 []PathNode) bool {
-	if len(p1) != len(p2) {
-		return false
-	}
-	for k := range p1 {
-		if !bytes.Equal(p1[k].name, p2[k].name) {
-			return false
-		}
-	}
-	return true
+func comparePaths(p1, p2 []string) bool {
+	return strings.Join(p1, " → ") == strings.Join(p2, " → ")
 }
--- a/stringify.go
+++ b/stringify.go
@@ -31,14 +31,9 @@ func stringify(v []byte) string {
 	return fmt.Sprintf("%x", v)
 }

-func stringifyStringPath(path []string) []string {
-	return stringifyPath(stringPathToBytePath(path))
-}
-
-func stringifyPath(path [][]byte) []string {
-	var ret []string
-	for _, v := range path {
-		ret = append(ret, stringify(v))
+func stringifyPath(path []string) []string {
+	for k, v := range path {
+		path[k] = stringify([]byte(v))
 	}
-	return ret
+	return path
 }
Author	SHA1	Message	Date
Brian Buller	bbe5e92c9c	Read/Edit DBs with key/value pairs in root Not sure how 'good' this is, but apparently some people do it, so we may as well support it.	2021-05-31 09:29:09 -05:00
Brian Buller	14bd1cdd41	Merge pull request #43 from sp0cket/master fix drawHeader strings.Repeat crash	2020-04-08 15:29:24 -05:00
Aaron	10e63ac072	fix drawHeader strings.Repeat crash	2020-04-08 16:09:44 +08:00
Brian Buller	19bf4d25d2	Merge pull request #41 from knqyf263/filter add filter	2020-03-30 16:24:09 -05:00
Brian Buller	eacd685531	Merge pull request #39 from knqyf263/no_value add -no-value option	2020-03-30 16:20:48 -05:00
knqyf263	12b395ae2a	add filter	2019-12-23 16:57:25 +02:00
knqyf263	59a4e49fa4	add -no-value option	2019-12-23 13:26:45 +02:00