Unexpected path behavior

[PsychoLlama]

If you pass a string into path, the decimal will break it into two separate path calls. This is not always the desired behavior, especially when considering floating point numbers:

Gun().get('example').path(0.123).set('data')

set is never called because the float is Stringed, and then it reads as path(0).path(123), where 0 is not defined, leaving the rest of the chain unfulfilled. In instances like this, there should at least be some log message that warns you of using floating point numbers.

[PsychoLlama]

Preferably, there would be some way to escape the value so that decimals aren't split. Javascript's native implementation, object['string value'], would likely be the most intuitive for users, and might look something like this...

gun.path("[0.123]")

Maybe we could have floats coerce into a string like that under the hood, too...

[PsychoLlama]

Note to onlookers: this is a rough summary of a conversation held about what gun should and should not do.

[thoka]

One could pass all keys through https://github.com/deanlandolt/bytewise by default,
which would allow arbitrary complex keys.

[metasean]

@thoka - Thank you so much for all of your pointers and suggestions!

I've added a "Potentially Unexpected Behavior" section to the path documentation and @amark will also be adding a console notification.

The current implementation is the way we want the core to work, but we would love some extensions that provide alternative approaches for gun users. Until extensions are coded, our goal is to ensure users know why the system is behaving the way it is.

[PsychoLlama]

From a conversation with @amark

There is a potentially better solution here, where we normalize everything to an array. If it's not an array and a string, then we split it on periods, turning it into an array. This would mean that only strings are split, preventing the odd behavior with floats or other data types. By consequence, you could have a bracket like syntax by passing an array instead of a string. Since it's wrapped in an array, no implicit string splitting is done, finally allowing you to use dots in your path names.

Normal Javascript

var obj = {
  '10.15.20': 'data'
}
obj['10.15.20'] // 'data'

Gun syntax

var obj = gun.get('obj')
// brackety syntax
obj.path(['10.15.20']) // path('10.15.20')

Whereas if we wanted to split on the period, we could explicitly pass a single string:

// or the usual string split
obj.path('10.15.20') // path(10).path(15).path(20)

Here's the code that could enable that:

var gun = this;

// if it's a string, not an array...
if (typeof input === 'string') {
    // split on dot notation
    input = input.split('.');
}
// otherwise it's not a string,
// but not an array either
if (!(input instanceof Array)) {
    // turn it into an array
    input = [input];
}
// if there's more than one item in
// the array, then call `.path` on each item.
if (input.length > 1) {
    input.forEach(function (path) {
        gun = gun.path([path]);
    });
    return gun;
}
// do normal `.path` things below

I'd really like to see something like this in the next release of gun 😀

[amark]

Path has now become a wrapper for get so get won't cause these problems anymore. It is note in the documentation about path though. And I think Jesse had added several patches fixing it. So closing!