Traversing and parsing/inserting of a document at the block element level?

Hi guys, I've been investigating Asciidoctor as a new standard for a large documentation set. I'm impressed by the syntax and platform but I still have many outstanding questions. I'm proficient in Java but not in Ruby, so I've looked at AsciidoctorJ in detail (including writing lots of sample code) to determine if needed functionality is currently available. It doesn't appear to be, so I've also been reading through the Ruby API docs (especially the AST) to get a better idea of the low-level API and what's possible.

With or without helper libraries that may not exist yet, is it possible using AsciidoctorJ to traverse an existing document's block elements, parse the elements, and then optionally modify the element? Think Jsoup but for an Asciidoctor file. If this functionality exists in the API I haven't been able to find it.

To use a simple example, this is the Java code I would envision writing to check all links in a block and/or modify them as necessary (maybe not the best code but you get the idea):

Sample pseudocode:
--------------------

Asciidoctor asciidoctor = Asciidoctor.Factory.create();
Document doc = asciidoctor.load(asciidocFile, options);
List<Block> blocks = doc.getBlocks();
for(Block block : blocks) {
  if(block.hasLinks) {
    List<Link> links = block.getLinks();
    for(Link link : links) {
      if(!link.isValid) {
        link.value = "http://asciidoctor.org";
      }
    }
  }
}
doc.saveChanges();

--------------------

It probably goes without saying, but there are many situations where parsing/manipulating block-level objects would be required functionality if your goal is to maintain the integrity of the source doc, rather than merely checking the HTML output using Jsoup or some other library. Other examples: mass updates of attributes, enforcing consistent styles for the Asciidoc content (Setext vs. ATX header styles), injecting conditional blocks (such as for pre-release documentation), etc.

Is this kind of processing possible, either using the AST or other libraries? What about in Ruby?

Thanks!
Sean

EDIT:

To make it crystal clear what I'm trying to accomplish and to demonstrate some problems I've been having with the Java library, here is some test code that I wrote and have tried on fairly long .ad files:

Code that traverses each block layer:
--------------------

    private void printBlockLayersInDocument(Document doc) {
        for(AbstractBlock block : doc.blocks()) {
            writeLineToLog("* " + block.context());
            getBlockLayers(block, 1);
        }
    }

    private void getBlockLayers(AbstractBlock block, int count) {
        for (AbstractBlock b : block.blocks()) {
            for(int i = 0; i < count; i++) {
                writeToLog("  ");
            }
            writeLineToLog("* " + b.context());
            getBlockLayers(b, count + 1);
        }
    }

---------------------

The output of this code looks like the following. I've added notes with [note:] for certain lines to indicate what kind of element actually exists in the source .ad file:

Output on a test Asciidoc file:
--------------------

* preamble
  * paragraph
* section
  * paragraph
* section
  * paragraph
* section
  * paragraph
  * paragraph
  * paragraph      [note: this is actually a link]
  * paragraph
* section
  * paragraph
  * paragraph      [note: this is actually an image]
  * paragraph      [note: this is actually a link]
  * paragraph
  * paragraph
  * paragraph      [note: this is actually a list item]
  * paragraph      [note: this is actually a list item]
  * paragraph      [note: this is actually a list item]
  * paragraph      [note: this is actually an image]
  * paragraph
  * paragraph
  * paragraph
  * paragraph
  * paragraph
  * paragraph
* section
  * paragraph
* section
  * paragraph
* section
  * paragraph

So the question remains: how can I get programmatic access to the underlying image/link/list/etc?