Marble diagram generator java/javascript for documentation using rxjava/rxjs or reactor

Question

I am looking to create documentation for a project created with reactor library.

I searched but did not found any useful tool that generates photo diagrams after running a piece of reactor(or rx in general) code. The only thing i found is a text based syntax like this .Which I guess is a solution follow if i dont find anything else.

libraries found that use this syntax

• https://flames-of-code.netlify.com/blog/rx-marbles/
• https://github.com/cescoffier/rx-marble-docker

Ideally i would like to run a piece of code eg.

Flux.from(f1)
                .bufferTimeout(writeDbBuffer, Duration.ofSeconds(10))
                .parallel()
                .runOn(Schedulers.parallel()).subscribe(photosBatch -> {
                    photoRepository.saveAll(photosBatch);
                });

And generate marble diagram in photo or ever text based. As a solution to the text based syntax mentioned above i could create text generators based on this syntax but this would require a lot of effort and time.

There is any way to generate images with marble diagrams with rxjava, rxjs or preferable reactor library from pieces of code?(I am including rx because is way more popular that reactor)

There is any library generating the above text based syntax from pieces of code?

What other options i have for documentation over these libraries?

also a similar question but not exactly what i am looking for

Answer 1

Something that dynamic is, to my knowledge, not yet available in the Java world. Closest thing I know of is rxfiddle , and to an extent rxmarbles.com (although the later doesn't allow generation from arbitrary pieces of code).

Generating clean and good looking visualization of arbitrary reactive sequences dynamically is no small task, but that's something the Reactor team would love to see at some point (either done officially or by the community).

The text-based solutions are great for simple marbles and simple operators, because you are in essence drawing the marble yourself, using the syntax of each tool (and thus being limited by it).

Higher-order sequences, parallelization, etc... introduce far greater complexity and start to stretch these tools to their limits.