Blocks is inserting the wrong text in the wrong node

[Kanaye]

Blocks is updating inserting into the wrong text-node in an each data-query in the reset()- function of array-observables, when these get reset the first time.
To be clear: http://jsfiddle.net/bpkvse3r/1/ click the reset button at least 3 times.
Will look into this this tomorrow.

[edit:]
Correcting myself: The update is on the right node. The initial insert is on the wrong one.

[Kanaye]

Short update:
This one is more complicated then I thought.
Found the some reasons for this behaivor but there are more cases (e.g. this) where similar stuff occurs.
Could take a bit longer untill I can fix this in a clean way.

[astoilkov]

Let me guess. This is caused from the VirtualElement.sync method which can't find the correct order in which to sync the elements?

[Kanaye]

The main reasons is that observables are inserting a comment when rendered with an expression.
So this:

some text
{{myExpression}}

will get rendered to something like:

some text
<!--5:blocks-->
observable content

That are 3 nodes.
We are skipping the first node if it's a coment-node.
But here we are inserting into the first node (as seen in the first fiddle) as its not a comment node.
In the second jsfiddle we are inserting all nodes again but only removing the first one.
So we are having a problem with the number of nodes a rendered expression can have.

Unfortunatly I've been busy and felt a little bit sick the last days and didn't came around to work on this.
Will look into this again later today.

[astoilkov]

Yeah. I have seen this. The main challenge is to find out how many elements to skip and which to update. There should be a mechanism which detects what type of expression is the element.

[Kanaye]

Okay. I have a solution or at least some parts of it.
An Expression is getting it's node-length when getting rendered first time with Expression.Html and storing it, so we can remove all nodes that are related to that expression.
I added an Expression.NodeWise rendering type which will result in an array with the relative index of the node that should have that value and the rendered value.
Example:
original expression:

test:{{someObservable}}|some static

Rendered with Expression.Html:

test:
<!--5:blocks-->
test-observable|some static

will result in:

['test:', 
  null, /* maybe the comment content here as it's (most likely) an other observable in case of Observable([]).reset() */,
'test-observable|some static']

with Expression.NodeWise.

[edit:]
Forget the part with the comments content as it's not related to the dom-comment.
It's been (too) late at night as I wrote that.
[/edit]

I have to speed up some stuff and some cacheing mechanisms aren't working currently.
I also have to work around some edge cases e.g. rendering an expression where a "normal" variable is replaced in second rendering with an observable.

blocks.query({
  test: 'normal string'
});

blocks.query({ // In this case I would not have the right node value
  test: blocks.observable('and now I have a problem')
});

And I may have some other cases where the new rendering fails.

[edit: typos and brought some words in the right order]