World: r3wp

More consistent, I feel.  The result is now of the format: some [thing 
value]

Where 'thing is <tag> /attribute or # for text.  And value is [container] 
"text" or none

>> load-xml {<some xml="to">Try</some>}
==  [
	<some>
		/xml "to"
		# "Try"
	]
]

Hmm, missing bracket.

I thought about the # convention.  # can be used in parse literally. 
 It may have no semantic meaning, but is a very concise anchor.

Also, a tag with no attributes containing only text will only contain 
text:

>> load-xml "<try>This</try>"
== [
    <try> "This"
]

response: context [
	status: name: value: none
]

example: {<rsp>
	<status>Good</status>
	<payload>
		<value name="one">two</value>
	</payload>
</rsp>}

probe make response [
	parse load-xml example [
		<rsp> into [
			<status> set status ["Good" | "Bad"]
			<payload> into [
				<value> into [
					/name set name string! # set value string!
				]
			]
		]
	]
]

All the 'into values are a bit of a pain, but work can be broken 
up...

Note, this parser is destructive - ie. flattening will only provide 
an approximation of the original xml string.

So ymmv depending on need.

; Next, Quick DOM:

do http://www.ross-gill.com/r/qdom.r

Only one method at the moment - get-by-tagname


Note, this is not an attempt to implement W3 DOM.  Just a quick approximation 
for fast manipulation (hence the name).  It's object happy, not sure 
of the weight considerations as such.

do http://www.ross-gill.com/r/qdom.r

doc: load-dom {<some><xml>to try</xml></some>}
values: doc/get-by-tagname <xml>
values/1/value = "to try"

; You can still parse the tree too:
parse doc/tree [<some> into [<xml> "to try"]]

This is not an exercise in bloat, I plan to implement only a few 
key methods.  Though if anyone has any requests?

Ok, another revision.  This has a few more methods, I may strip them 
down to read-only, as I don't need to manipulate the object though 
I left them in for completeness.

>> do http://www.ross-gill.com/r/qdom.r
connecting to: www.ross-gill.com
Script: "QuickDOM" (none)
>> doc: load-dom {<some><xml id="foo">to try</xml></some>}
>> foo: doc/get-by-id "foo"
>> foo/name
== <xml>
>> foo/value
== [
    /id "foo" 
    # "to try"
]
>> kids: foo/children
== [make object! [
        name: #
        value: "to try"
        tree: [
            # "to try"
        ]
        position: [
   ...
>> kids/1/value
== "to try"
>> doc/tree/<some>/<xml>/(#)           
== "to try"

RebXML spec: http://www.fys.ku.dk/~niclasen/rebxml/rebxml-spec.html
Scripts are in the Library: http://www.rebol.org

Has anyone written anything to format/index XML documents?

/indent .. not index

No matter .. it was easy enough.

Now has anyone written a recursive routine to turn a rebol object 
into XML?  I couldn't find anything like this on rebol.org yet it 
doesn't sound hard to do ...

There must be something, but I don't have anything here that turned 
up, and I don't remember doing one myself. If it helps, you could 
use the JSON converter in %json.r as a starting point.

This seems to work for me ...

obj2xml: func [ obj [object!] out [string!]
	/local o 
][
	foreach element next first obj [
		repend out [ to-tag element newline ]
		either object? o: get in obj element [
			obj2xml o out
		][
			repend out [ o newline ]
		]		
		repend out [ to-tag join "/" element newline ]
	]
]

using this 

obj2xml: func [ obj [object!] out [string!]
	/local o 
][
	foreach element next first obj [
		repend out [ to-tag element newline ]
		either object? o: get in obj element [
			obj2xml o out
		][
			repend out [ o newline ]
		]		
		repend out [ to-tag join "/" element newline ]
	]
]

crap ... clipboard bug

>> probe obj
make object! [
    a: "testing"
    b: "again"
    c: make object! [
        d: "testing2"
        e: "again2"
        f: make object! [
            g: "testing3"
            h: "again3"
        ]
    ]
    i: "finished"
]

gives this 

<a>
    testing
</a>
<b>
    again
</b>
<c>
    <d>
        testing2
    </d>
    <e>
        again2
    </e>
    <f>
        <g>
            testing3
        </g>
        <h>
            again3
        </h>
    </f>
</c>
<i>
    finished
</i>

Hmm..
Really, have you the tabulations ?

Yes, separate script does the tabulations

probably should change line 
repend out [ o newline ]
to 
repend out [ any [ o copy "" ] newline ]

then, for NONE! values, it will  add an empty line

format-xml: func [ xml
    /local out space prev
][
    out: copy ""
    spacer: copy ""
    prev: copy </tag>
    foreach tag load/markup xml [
        either tag = find tag "/" [
            ; we have a close tag
            

            ; reduce the spacer by a tab unless the previous was an open tag
            either not tag? prev [
                ; not a tag
                remove/part spacer 4
            ][
                ; is a tag
                if prev = find prev "/" [
                    ; last was a closing tag
                    remove/part spacer 4
                ]
            ]
        ][ 
            either tag? tag [
                ; current is tag
                ; indent only if the prev is not a closing tag
                if not prev = find prev "/" [
                    insert/dup spacer " " 4
                ]
            ][
                ; is data
                insert/dup spacer " " 4 
            ]
        ]
        repend out rejoin [ spacer tag newline ]
        prev: copy tag
    ]
	view layout compose [ area (out) 400x400 ]
]

obj2xml: func [ obj [object!] out [string!]
	/local o 
][
	foreach element next first obj [
		repend out [ to-tag element ]
		either object? o: get in obj element [
			obj2xml o out
		][
			repend out any [ o copy "" ]
		]		
		repend out [ to-tag join "/" element ]
	]
]

remove the newlines to solve that issue :)

I was using rebelxml to construct xml ... but I came across some 
bugs.  So this way of doing it looks easier ....

What are people using to construct large XML documents ... of 100s 
of lines?

a modified version of John's rebXML  tools.  changed the output structure 
to allow rebol's path notation to be used to traverse the loaded 
xml.

I also replaced the use of url for the tag words because they fail 
when using namespaced xml elements.

building output objects instead would be simple, but the RAM/Speed/symbol 
table implications of all the binding involved makes this un-optimal.

(...objects instead of  blocks ....)

So, you used blocks instead of objects?

yes all the time.  accessing is exactly the same as for objects. 
 its actually much more flexible.

cause you have have the same element severall times, which is valid 
xml, but invalid in contexts.

True

and you can easily separate attributes from elements, just by affecting 
them to different types.

Although the XML I'm dealing with doesn't have duplicate elements.

Or name spaces

Have you posted your modifications anywhere??

the most stable engine I built which accepted all xml possibilities 
ended loading xml like so:


[ <element> [<subelement> [#attribute  "attr-value" . "subelement 
content"]]]

the .  is assigned the value of the elements. 

the above would result from the following XML:
<element>
	<subelement attribute="attr-value">
		subelement content
	</subelement>
</element>