World: r3wp

what's textile ?  A type of fabric ?

http://hobix.com/textile/

A structured text variant ...

yep

I like some of the different structured text formatting systems

Volker thank you it works great now and the code rule is tiny ;)

:)

Any parse suggestions for trying to find #"(" without a matching 
#")" in text that might also have proper pairs of parens?

you probably need to count them and see where you end up after finding 
all parens. I'm not sure if it can be used to see which are missing...

That would probably work fine. This if for the textile parser, where 
a declaration like "p(." means a paragraph with left margin of 1em, 
repeated for additional ems of margin. Counting will be quite useful.

count one up on #"(" and one down on #")". If correct, the end result 
is zero.

thanks

Perfect, Henrik. That took me exactly where I needed to go for this 
feature.

Gonna have to work on my test-simple.r script soon to provide better 
summaries. The number of tests that are passing in this thing is 
getting rather large!

Any tips on how to convert " *text* " to " <strong>text</strong>"?

One way:
   replace text "*" <strong>
   replace text "*" </strong>

If there are multiple pairs of "*", repeat in a loop until the length 
no longer changes

You should look at make-doc text to see how it parses stuff.  I believe 
it's a similar problem.

source not text.

Brian, you can look at my NicomDoc format http://home.tiscali.dk/john.niclasen/nicomdoc/

Look for the 'magic' in "nicomdoc.r", where you'll find rules for 
such things. (I guess, you have to handle multiple ****.

ah, thanks. Sunanda, that solution won't quite work if a #"*" appears 
without a match. I'll go look at NicomDoc

parse/all data [any [to "*" a: skip b: to "*" c: skip d: :a (change/part 
a rejoin ["<strong>" copy/part b c "</strong>"] d)] to end]

You can make it a little more complicated to add more markup types, 
but the basic structure is the same. The trick is the :a before the 
paren - otherwise it won't work, and you can crash older versions 
of REBOL.

something along the lines of   (untested)

;;; make the word set more restrictive if no space etc
;;; but this is most permissive for your example
word: complement charset "*"
rule: [
	skip to "*" 
	[copy item some word "*"(append output join[<tag> item </tag>])]
	| skip

That works nicely too! I'll look more at NicomDoc later, but BrianH's 
tip makes tests for "*test*" and "*test" pass

I'll have to explore Tomc's solution when I get back from my meeting. 
Thanks, folks

markup-chars: charset "*~"
non-markup: complement markup-chars
tag1: ["*" "<strong>" "~" "<i>"]
tag2: ["*" "</strong>" "~" "</i>"]
parse/all data [
    any non-markup
    any [

        ["*" a: skip b: to "*" c: skip d: | "~" a: skip b: to "~" c: skip 
        d: ] :a (
            change/part a rejoin [
                select tag1 copy/part a b
                copy/part b c
                select tag2 copy/part c d
            ] d
        ) any non-markup
    ]
    to end
]

No nesting, but with a little recursion and different start and end 
tags, this can be adapted to handle that too.

If you want to determine whether there have been any replacements, 
change the second any to some and parse will return true only when 
replacements have been made. Be careful to avois use of the markup 
characters in your replacement text.

avios: avoid

Whoops, an error. Change:

        ["*" a: skip b: to "*" c: skip d: | "~" a: skip b: to "~" c: skip 
        d: ] :a (
to:

        [a: "*" b: to "*" c: skip d: | a: "~" b: to "~" c: skip d: ] :a (

Silly me :(

w: complement charset "*"
rule: [	
	to "*" here: "*"
	opt[ 
		copy item some w "*" there:
		(change/part :here join "" [<strong> item </strong>] :there)
	]
]
parse/all str [some rule]

Tomc, that will crash older versions of REBOL, and not work on newer 
versions. You need to reset the parse position to before the change, 
before the paren where you make the change. Otherwise parse will 
be referencing a point off the end of the string at the end of the 
paren, before you can reset it. This used to crash REBOL so bad the 
interpreter disappeared.

brianh   please supply a str that fails on current versions, so I 
can see what you mean

To fix your example, put a :here after the first there: in your rule.

still havent found a string that fails , trying all the combos of 
*'s at the beginning end , middle ...

In your case you might not have a crash, because you are replacing 
a short text with a longer one. Still, it's good to remember that 
bug for future reference. It really tripped me up when I first came 
across it, back when it still used to crash REBOL.

yes, shortening the string you are parsing would pull the rug out 
from under the interperter,
(and I was aware that the string was being lengthened) 

note: setting the parse pointer back to :here will position you before 
the "*"  

you may be better off  with :here skip to gaurentee progress in the 
case the change fails

OK, I tried this: parse "abc" [to "bc" a: "bc" (change/part a "b" 
2)]

It returns true on View 1.3 and Core 2.6, but false on View 1.2 and 
Core 2.5.0.

If the change fails it will throw an error. The trick is to put off 
the paren performing the change until you have gone through enough 
rules to ensure that the paren contents will succeed.

Remember, for many platforms, Core 2.5.0 is the current version.

Here's a simplified version of my example that can handle multiple 
instances of multiple markup types and be adapted to different end 
tags (thanks Tomc for the idea!):

markup-chars: charset "*~"
non-markup: complement markup-chars
tag1: ["*" "<strong>" "~" "<i>"]
tag2: ["*" "</strong>" "~" "</i>"]
parse/all data [
    any non-markup
    any [

        ; This next block can be generated if you have many markup types...

        [a: copy b "*" copy c to "*" copy d "*" e: | a: copy b "~" copy c 
        to "~" copy d "~" e: ]
        :a (change/part a rejoin [tag1/:b c tag2/:d] e)
        any non-markup
    ]
    to end
]

Tomc: "you may be better off  with :here skip to gaurentee progress"


Put the skip after the paren and I may agree with you there. Of course 
you would skip the number of chars in the replacement text then.

Wow, I'm off getting bored at meetings, come back and you've been 
working hard! Thanks, folks.

Here's what I have right now:

		markup-chars: charset "*_@"
		non-markup: complement markup-chars
		inline-tags: [
			"*" "strong"
			"_" "em"
			"@" "code"
		]

		markup-rule: [
			any non-markup
			any [
				[ a: "*" b: to "*" c: skip d: |
				  a: "_" b: to "_" c: skip d: | 
				  a: "@" b: to "@" c: skip d: ] :a (
					change/part a rejoin [ 
						"<" select inline-tags copy/part a b ">"
						copy/part b c 
						"</" select inline-tags copy/part a b ">"
					] d
				) any non-markup
			]
			to end
		]
		parse text markup-rule

you almost certinly want parse/all

whoops

If you want to guarantee progress with my and your examples (and 
better support multichar markup tags) change the last
  any non-markup
to
  any non-markup | skip
and that would do it.

okay, here's a slightly tweaked version that uses a multichar markup 
tag:

        markup-chars: charset "[*_-:---]"
        non-markup: complement markup-chars
        inline-tags: [
            "*" "strong"
            "_" "em"
            "@" "code"
            "--" "small"
        ]

        markup-rule: [
            any non-markup
            any [
                [ a: "*" b: to "*" c: skip d: |
                  a: "_" b: to "_" c: skip d: | 
                  a: "@" b: to "@" c: skip d: |
                  a: "--" b: to "--" c: skip skip d: ] :a (
                    change/part a rejoin [ 
                        "<" select inline-tags copy/part a b ">"
                        copy/part b c 
                        "</" select inline-tags copy/part a b ">"
                    ] d
                ) any non-markup | skip
            ]
            to end
        ]
        parse/all text markup-rule

Your first charset only needs one -