From bca06f1ec361537c4c7f1368ca8838be2940dafe Mon Sep 17 00:00:00 2001 From: murphy Date: Fri, 7 Nov 2008 11:46:58 +0000 Subject: Improved YAML Scanner (ticket #34). * Added more YAML example files (website, database). * Minor code cleanup in Scanner. --- test/scanners/yaml/basic.expected.raydebug | 710 ++++++++++----------- test/scanners/yaml/database.expected.raydebug | 52 ++ test/scanners/yaml/database.in.yml | 52 ++ test/scanners/yaml/faq.expected.raydebug | 496 +++++++------- test/scanners/yaml/gemspec.expected.raydebug | 12 +- .../scanners/yaml/latex_entities.expected.raydebug | 62 +- test/scanners/yaml/threshold.expected.raydebug | 490 +++++++------- test/scanners/yaml/website.expected.raydebug | 70 ++ test/scanners/yaml/website.in.yml | 70 ++ 9 files changed, 1129 insertions(+), 885 deletions(-) create mode 100644 test/scanners/yaml/database.expected.raydebug create mode 100644 test/scanners/yaml/database.in.yml create mode 100644 test/scanners/yaml/website.expected.raydebug create mode 100644 test/scanners/yaml/website.in.yml (limited to 'test') diff --git a/test/scanners/yaml/basic.expected.raydebug b/test/scanners/yaml/basic.expected.raydebug index b4f776b..6ffde52 100644 --- a/test/scanners/yaml/basic.expected.raydebug +++ b/test/scanners/yaml/basic.expected.raydebug @@ -1,435 +1,435 @@ -tag(---) +head key(name)operator(:) string(paragraphs) key(desc)operator(:) string(Textile looks for paragraphs in your text. Paragraphs are separated by one blank line. Every paragraph is translated as an HTML paragraph.) key(in)operator(:) string(|-) - string(A) string(single) string(paragraph.) + string(A single paragraph.) - string(Followed) string(by) string(another.) + string(Followed by another.) key(html)operator(:) string(|-) - string(

A) string(single) string(paragraph.

) - string(

Followed) string(by) string(another.

) -tag(---) + string(

A single paragraph.

) + string(

Followed by another.

) +head key(name)operator(:) string(block containing block start) key(in)operator(:) string(|-) - string(I) string(saw) string(a) string(ship.) string(It) string(ate) string(my) string(elephant.) + string(I saw a ship. It ate my elephant.) key(html)operator(:) string(|-) - string(

I) string(saw) string(a) string(ship.) string(It) string(ate) string(my) string(elephant.

) -tag(---) + string(

I saw a ship. It ate my elephant.

) +head key(name)operator(:) string(extended block containing block start) key(in)operator(:) string(|-) - string(p..) string(I) string(saw) string(a) string(ship.) string(It) string(ate) string(my) string(elephant.) + string(p.. I saw a ship. It ate my elephant.) - string(When) string(the) string(elephant) string(comes) string(to) string(take) string(a) string(p.) string(you...) + string(When the elephant comes to take a p. you...) key(html)operator(:) string(|-) - string(

I) string(saw) string(a) string(ship.) string(It) string(ate) string(my) string(elephant.

) - string(

When) string(the) string(elephant) string(comes) string(to) string(take) string(a) string(p.) string(you…

) -tag(---) + string(

I saw a ship. It ate my elephant.

) + string(

When the elephant comes to take a p. you…

) +head key(name)operator(:) string(blockquote containing block start) key(in)operator(:) string(|-) - string(bq.) string(I) string(saw) string(a) string(ship.) string(It) string(ate) string(my) string(elephant.) + string(bq. I saw a ship. It ate my elephant.) key(html)operator(:) string(|-) string(
) - string(

I) string(saw) string(a) string(ship.) string(It) string(ate) string(my) string(elephant.

) + string(

I saw a ship. It ate my elephant.

) string(
) -tag(---) +head key(name)operator(:) string(extended blockquote containing block start) key(in)operator(:) string(|-) - string(bq..) string(I) string(saw) string(a) string(ship.) string(It) string(ate) string(my) string(elephant.) + string(bq.. I saw a ship. It ate my elephant.) - string(When) string(the) string(elephant) string(comes) string(to) string(take) string(a) string(p.) string(you...) + string(When the elephant comes to take a p. you...) key(html)operator(:) string(|-) string(
) - string(

I) string(saw) string(a) string(ship.) string(It) string(ate) string(my) string(elephant.

) - string(

When) string(the) string(elephant) string(comes) string(to) string(take) string(a) string(p.) string(you…

) + string(

I saw a ship. It ate my elephant.

) + string(

When the elephant comes to take a p. you…

) string(
) -tag(---) +head key(name)operator(:) string(notextile block containing block start) key(in)operator(:) string(|-) - string(notextile.) string(I) string(saw) string(a) string(ship.) string(It) string(ate) string(my) string(elephant.) + string(notextile. I saw a ship. It ate my elephant.) key(html)operator(:) string(|-) - string(I) string(saw) string(a) string(ship.) string(It) string(ate) string(my) string(elephant.) + string(I saw a ship. It ate my elephant.) key(valid_html)operator(:) string(false) -tag(---) +head key(name)operator(:) string(extended notextile block containing block start) key(in)operator(:) string(|-) - string(notextile..) string(I) string(saw) string(a) string(ship.) string(It) string(ate) string(my) string(elephant.) + string(notextile.. I saw a ship. It ate my elephant.) - string(When) string(the) string(elephant) string(comes) string(to) string(take) string(a) string(p.) string(you...) + string(When the elephant comes to take a p. you...) key(html)operator(:) string(|-) - string(I) string(saw) string(a) string(ship.) string(It) string(ate) string(my) string(elephant.) + string(I saw a ship. It ate my elephant.) - string(When) string(the) string(elephant) string(comes) string(to) string(take) string(a) string(p.) string(you...) + string(When the elephant comes to take a p. you...) key(valid_html)operator(:) string(false) -tag(---) +head key(name)operator(:) string(pre block containing block start) key(in)operator(:) string(|-) - string(pre.) string(I) string(saw) string(a) string(ship.) string(It) string(ate) string(my) string(elephant.) + string(pre. I saw a ship. It ate my elephant.) key(html)operator(:) string(|-) - string(
I) string(saw) string(a) string(ship.) string(It) string(ate) string(my) string(elephant.
) -tag(---) + string(
I saw a ship. It ate my elephant.
) +head key(name)operator(:) string(extended pre block containing block start) key(in)operator(:) string(|-) - string(pre..) string(I) string(saw) string(a) string(ship.) string(It) string(ate) string(my) string(elephant.) + string(pre.. I saw a ship. It ate my elephant.) - string(When) string(the) string(elephant) string(comes) string(to) string(take) string(a) string(p.) string(you...) + string(When the elephant comes to take a p. you...) key(html)operator(:) string(|-) - string(
I) string(saw) string(a) string(ship.) string(It) string(ate) string(my) string(elephant.
) + string(
I saw a ship. It ate my elephant.
) - string(
When) string(the) string(elephant) string(comes) string(to) string(take) string(a) string(p.) string(you…
) - string(---) + string(
When the elephant comes to take a p. you…
) + string(--- ) key(name)operator(:) string(html tags) key(desc)operator(:) string(You can certainly use HTML tags inside your Textile documents. HTML will only be escaped if it’s found in a pre or code block.) key(in)operator(:) string(|-) - string(I) string(am) string(very) string(serious.) + string(I am very serious.) string(
)
-    string(I) string(am) string(very) string(serious.)
+    string(I am very serious.)
   string(
) key(html)operator(:) string(|-) - string(

I) string(am) string(very) string(serious.

) + string(

I am very serious.

) string(
)
-    string(I) string(am) variable(<b>very</b>) string(serious.)
+    string(I am <b>very</b> serious.)
   string(
) -tag(---) +head key(name)operator(:) string(line breaks) key(desc)operator(:) string(Line breaks are converted to HTML breaks.) key(in)operator(:) string(|-) - string(I) string(spoke.) - string(And) string(none) string(replied.) + string(I spoke.) + string(And none replied.) key(html)operator(:) string(|-) - string(

I) string(spoke.) - string(And) string(none) string(replied.

) + string(

I spoke.
) + string(And none replied.

) key(html_no_breaks)operator(:) string(|-) - string(

I) string(spoke.) - string(And) string(none) string(replied.

) + string(

I spoke.) + string(And none replied.

) key(lite_mode_html)operator(:) string(|-) - string(I) string(spoke.) - string(And) string(none) string(replied.) -tag(---) + string(I spoke.
) + string(And none replied.) +head key(name)operator(:) string(curly quotes) key(desc)operator(:) string(Single- and double-quotes around words or phrases are converted to curly quotations, much easier on the eye.) -key(in)operator(:) string("\\"Observe!\\"") +key(in)operator(:) string key(html)operator(:) string(

“Observe!”

) -tag(---) +head key(name)operator(:) string(quotes contained in multi-paragraph quotes) key(in)operator(:) string(|-) - string("I) string(first) string(learned) string(about) string(this) string(thing) string(called) string("Redcloth") string(several) string(years) string(ago.) + string("I first learned about this thing called "Redcloth" several years ago.) - string("It's) string(wonderful.") + string("It's wonderful.") key(html)operator(:) string(|-) - string(

“I) string(first) string(learned) string(about) string(this) string(thing) string(called) variable(“Redcloth”) string(several) string(years) string(ago.

) - string(

“It’s) string(wonderful.”

) -tag(---) + string(

“I first learned about this thing called “Redcloth” several years ago.

) + string(

“It’s wonderful.”

) +head key(name)operator(:) string(double hyphens) key(desc)operator(:) string(Double hyphens are replaced with an em-dash.) key(in)operator(:) string(Observe--very nice!) key(html)operator(:) string(

Observe—very nice!

) -key(latex)operator(:) string("Observe---very nice!\\n\\n") -tag(---) +key(latex)operator(:) string +head key(name)operator(:) string(double hyphens with spaces) key(desc)operator(:) string(Double hyphens are replaced with an em-dash and surrounding spaces are preserved.) key(in)operator(:) string(Observe -- very nice!) key(html)operator(:) string(

Observe — very nice!

) -key(latex)operator(:) string("Observe --- very nice!\\n\\n") -tag(---) +key(latex)operator(:) string +head key(name)operator(:) string(parenthetical phrase set off with em dashes) key(desc)operator(:) string(Sentences with two em dashes should not turn them into strikethroughs) key(in)operator(:) string(An emdash indicates a parenthetical thought--like this one--which is set apart from the rest of a sentence.) -key(html)operator(:) string("

An emdash indicates a parenthetical thought—like this one—which is set apart from the rest of a sentence.

") -key(latex)operator(:) string("An emdash indicates a parenthetical thought---like this one---which is set apart from the rest of a sentence.\\n\\n") -tag(---) +key(html)operator(:) stringAn emdash indicates a parenthetical thought—like this one—which is set apart from the rest of a sentence.

)delimiter(")> +key(latex)operator(:) string +head key(name)operator(:) string(parenthetical phrase set off with em dashes surrounded by spaces) key(desc)operator(:) string(Sentences with two em dashes should not turn them into strikethroughs) key(in)operator(:) string(An emdash indicates a parenthetical thought -- like this one -- which is set apart from the rest of a sentence.) -key(html)operator(:) string("

An emdash indicates a parenthetical thought — like this one — which is set apart from the rest of a sentence.

") -key(latex)operator(:) string("An emdash indicates a parenthetical thought --- like this one --- which is set apart from the rest of a sentence.\\n\\n") -tag(---) +key(html)operator(:) stringAn emdash indicates a parenthetical thought — like this one — which is set apart from the rest of a sentence.

)delimiter(")> +key(latex)operator(:) string +head key(name)operator(:) string(single hyphens with spaces) key(desc)operator(:) string(Single hyphens are replaced with en-dashes if they are surrounded by spaces.) key(in)operator(:) string(Observe - tiny and brief.) key(html)operator(:) string(

Observe – tiny and brief.

) -key(latex)operator(:) string("Observe--tiny and brief.\\n\\n") -tag(---) +key(latex)operator(:) string +head key(name)operator(:) string(midword hyphens ) key(desc)operator(:) string(Single hyphens are left alone if not surrounded by spaces.) key(in)operator(:) string(Observe the nicely-done hyphen.) key(html)operator(:) string(

Observe the nicely-done hyphen.

) -tag(---) +head key(name)operator(:) string(ellipses) key(desc)operator(:) string(Triplets of periods become an ellipsis.) key(in)operator(:) string(Observe...) key(html)operator(:) string(

Observe…

) key(lite_mode_html)operator(:) string(Observe…) -tag(---) +head key(name)operator(:) string(dimension sign) key(desc)operator(:) string(The letter 'x' becomes a dimension sign when used between digits.) -key(in)operator(:) string("Observe: 2x3.") -key(html)operator(:) string("

Observe: 2×3.

") -tag(---) +key(in)operator(:) string +key(html)operator(:) stringObserve: 2×3.

)delimiter(")> +head key(name)operator(:) string(dimension sign with space after) -key(in)operator(:) string("The room is 2x3 inches big.") -key(html)operator(:) string("

The room is 2×3 inches big.

") -tag(---) +key(in)operator(:) string +key(html)operator(:) stringThe room is 2×3 inches big.

)delimiter(")> +head key(name)operator(:) string(dimension sign with spaces) -key(in)operator(:) string("Observe: 2 x 4.") -key(html)operator(:) string("

Observe: 2 × 4.

") -tag(---) +key(in)operator(:) string +key(html)operator(:) stringObserve: 2 × 4.

)delimiter(")> +head key(name)operator(:) string(dimension signs chained) -key(in)operator(:) string("Observe: 2x3x4.") -key(html)operator(:) string("

Observe: 2×3×4.

") -key(lite_mode_html)operator(:) string("Observe: 2×3×4.") -tag(---) +key(in)operator(:) string +key(html)operator(:) stringObserve: 2×3×4.

)delimiter(")> +key(lite_mode_html)operator(:) string +head key(name)operator(:) string(dimension signs with double primes) key(in)operator(:) string('My mouse: 2.5" x 4".') key(html)operator(:) string('

My mouse: 2.5″ × 4″.

') -tag(---) +head key(name)operator(:) string(dimension signs with single primes) -key(in)operator(:) string("My office: 5' x 4.5'.") -key(html)operator(:) string("

My office: 5′ × 4.5′.

") -tag(---) +key(in)operator(:) string +key(html)operator(:) stringMy office: 5′ × 4.5′.

)delimiter(")> +head key(name)operator(:) string(trademark and copyright) key(desc)operator(:) string(Conversion of trademark and copyright symbols.) key(in)operator(:) string(one(TM\), two(R\), three(C\).) key(html)operator(:) string(

one™, two®, three©.

) key(lite_mode_html)operator(:) string(one™, two®, three©.) -tag(---) +head key(name)operator(:) string(headers) key(desc)operator(:) string(To make an entire paragraph into a Header, place “hn.” at its beginning, where n is a number from 1-6.) key(in)operator(:) string(h3. Header 3) key(html)operator(:) string(

Header 3

) -tag(---) +head key(name)operator(:) string(blockquote) key(desc)operator(:) string(To make an entire paragraph into a block quotation, place “bq.” before it.) key(in)operator(:) string(|-) - string(Any) string(old) string(text) + string(Any old text) - string(bq.) string(A) string(block) string(quotation.) + string(bq. A block quotation.) - string(Any) string(old) string(text) + string(Any old text) key(html)operator(:) string(|-) - string(

Any) string(old) string(text

) + string(

Any old text

) string(
) - string(

A) string(block) string(quotation.

) + string(

A block quotation.

) string(
) - string(

Any) string(old) string(text

) -tag(---) + string(

Any old text

) +head key(name)operator(:) string(footnote reference) key(desc)operator(:) string(Numeric references within text to footnotes appear between square brackets.) key(in)operator(:) string(This is covered elsewhere[1].) key(html)operator(:) string(

This is covered elsewhere1.

) -tag(---) +head key(name)operator(:) string(footnote) key(desc)operator(:) string(To create the footnote that corresponds to its reference within the text, begin a new paragraph with fn and the footnote’s number, followed by a dot and a space.) key(in)operator(:) string(fn1. Down here, in fact.) key(html)operator(:) string(

1 Down here, in fact.

) -tag(---) +head key(name)operator(:) string(em) key(desc)operator(:) string(Emphasis to text is added by surrounding a phrase with underscores. In HTML, this often appears as italics.) key(in)operator(:) string(I _believe_ every word.) key(html)operator(:) string(

I believe every word.

) -key(lite_mode_html)operator(:) string("I believe every word.") -tag(---) +key(lite_mode_html)operator(:) stringbelieve every word.)delimiter(")> +head key(name)operator(:) string(strong) key(desc)operator(:) string(Strength can be give to text by surrounding with asterisks. In HTML, this strength appears as bold.) key(in)operator(:) string(And then? She *fell*!) key(html)operator(:) string(

And then? She fell!

) -key(lite_mode_html)operator(:) string("And then? She fell!") -tag(---) +key(lite_mode_html)operator(:) stringfell!)delimiter(")> +head key(name)operator(:) string(strong phrase beginning with a number) key(desc)operator(:) string(A strong phrase at the beginning of a line that begins with a number should not be recognized as a ul with a start value (no such thing\)) -key(in)operator(:) string("*10 times as many*") -key(html)operator(:) string("

10 times as many

") -tag(---) +key(in)operator(:) string +key(html)operator(:) string10 times as many

)delimiter(")> +head key(name)operator(:) string(force bold italics) key(desc)operator(:) string(Both italics and bold can be forced by doubling the underscores or asterisks.) key(in)operator(:) string(|-) - string(I) string(__know__.) - string(I) string(**really**) string(__know__.) + string(I __know__.) + string(I **really** __know__.) key(html)operator(:) string(|-) - string(

I) string(know.) - string(I) string(really) string(know.

) -tag(---) + string(

I know.
) + string(I really know.

) +head key(name)operator(:) string(citation) key(desc)operator(:) string(Use double question marks to indicate citation. The title of a book, for instance.) key(in)operator(:) string(??Cat's Cradle?? by Vonnegut) key(html)operator(:) string(

Cat’s Cradle by Vonnegut

) -tag(---) +head key(name)operator(:) string(code phrases) key(desc)operator(:) string(Code phrases can be surrounded by at-symbols.) key(in)operator(:) string(Convert with @r.to_html@) key(html)operator(:) string(

Convert with r.to_html

) key(lite_mode_html)operator(:) string(Convert with r.to_html) -tag(---) +head key(name)operator(:) string(code phrases not created with multiple email addresses) key(in)operator(:) string(Please email why@domain.com or jason@domain.com.) key(html)operator(:) string(

Please email why@domain.com or jason@domain.com.

) -tag(---) +head key(name)operator(:) string(del) key(desc)operator(:) string(To indicate a passage which has been deleted, surround the passage with hypens.) key(in)operator(:) string(I'm -sure- not sure.) key(html)operator(:) string(

I’m sure not sure.

) -tag(---) +head key(name)operator(:) string(ins) key(desc)operator(:) string(Pluses around a passage indicate its insertion.) key(in)operator(:) string(You are a +pleasant+ child.) key(html)operator(:) string(

You are a pleasant child.

) -tag(---) +head key(name)operator(:) string(superscript) key(desc)operator(:) string(To superscript a phrase, surround with carets.) key(in)operator(:) string(a ^2^ + b ^2^ = c ^2^) key(html)operator(:) string(

a 2 + b 2 = c 2

) -tag(---) +head key(name)operator(:) string(parenthetical superscript phrase) key(in)operator(:) string('^(image courtesy NASA\)^') key(html)operator(:) string('

(image courtesy NASA\)

') -tag(---) +head key(name)operator(:) string(subscript) key(desc)operator(:) string(To subscript, surround with tildes.) key(in)operator(:) string(log ~2~ x) key(html)operator(:) string(

log 2 x

) -tag(---) +head key(name)operator(:) string(parenthetical subscript phrase) key(in)operator(:) string('~(image courtesy NASA\)~') key(html)operator(:) string('

(image courtesy NASA\)

') -tag(---) +head key(name)operator(:) string(tight superscript and subscript) key(desc)operator(:) string(if you want your superscript or subscript to not be surrounded by spaces, you must use square brackets) key(in)operator(:) string(f(x, n\) = log[~4~]x[^n^]) key(html)operator(:) string('

f(x, n\) = log4xn

') -tag(---) +head key(name)operator(:) string(span) key(desc)operator(:) string(Lastly, if you find yourself needing to customize the style of a passage, use percent symbols to translate the passage as an HTML span.) key(in)operator(:) string(I'm %unaware% of most soft drinks.) key(html)operator(:) string(

I’m unaware of most soft drinks.

) -tag(---) +head key(name)operator(:) string(style span) key(desc)operator(:) string(This way, you can apply style settings, as described in the next section to arbitrary phrases.) key(in)operator(:) string(|-) - string(I'm) string(%{color)symbol(:red)operator(})string(unaware%) - string(of) string(most) string(soft) string(drinks.) + string(I'm %{color:red}unaware%) + string(of most soft drinks.) key(html)operator(:) string(|-) - string(

I’m) string(unaware) - string(of) string(most) string(soft) string(drinks.

) + string(

I’m unaware
) + string(of most soft drinks.

) key(lite_mode_html)operator(:) string(|-) - string(I’m) string(unaware) - string(of) string(most) string(soft) string(drinks.) -tag(---) + string(I’m unaware
) + string(of most soft drinks.) +head key(name)operator(:) string(percent sign) key(desc)operator(:) string(though percent signs indicate a span, they shouldn't be overly greedy.) key(in)operator(:) string(|-) - key(http)error(:)string(//blah.com/one%20two%20three) + string(http://blah.com/one%20two%20three) string((min\)5%-95%(max\)) key(html)operator(:) string(|-) - string(

http)error(:)string(//blah.com/one%20two%20three) + string(

http://blah.com/one%20two%20three
) string((min\)5%-95%(max\)

) -tag(---) +head key(name)operator(:) string(css class) key(desc)operator(:) string(A block can be tagged with a CSS class by circling the class in parentheses and placing it just before the period which marks the block.) key(in)operator(:) string(p(example1\). An example) key(html)operator(:) string(

An example

) -tag(---) +head key(name)operator(:) string(css id) key(desc)operator(:) string(An element ID can be given by prefixing the ID with a pound symbol and using it in place of the class.) key(in)operator(:) string(p(#big-red\). Red here) key(html)operator(:) string(

Red here

) -tag(---) +head key(name)operator(:) string(class and id combined) key(desc)operator(:) string(Class and ID can be combined by placing the class first.) key(in)operator(:) string(p(example1#big-red2\). Red here) key(html)operator(:) string(

Red here

) -tag(---) +head key(name)operator(:) string(css style) key(desc)operator(:) string(Style settings can be provided directly by surrounding them in curly braces.) key(in)operator(:) string(p{color:blue;margin:30px}. Spacey blue) key(html)operator(:) string(

Spacey blue

) -tag(---) +head key(name)operator(:) string(language designations) key(desc)operator(:) string(Language designations can be given between angel brackets.) key(in)operator(:) string(p[fr]. rouge) key(html)operator(:) string(

rouge

) -tag(---) +head key(name)operator(:) string(block attributes on phrase modifiers) key(desc)operator(:) string(All block attributes can be applied to phrases as well by placing them just inside the opening modifier.) key(in)operator(:) string(|-) - string(I) string(seriously) string(*{color)symbol(:red)operator(})string(blushed*) - string(when) string(I) string(_(big\)sprouted_) string(that) - string(corn) string(stalk) string(from) string(my) + string(I seriously *{color:red}blushed*) + string(when I _(big\)sprouted_ that) + string(corn stalk from my) string(%[es]cabeza%.) key(html)operator(:) string(|-) - string(

I) string(seriously) string(blushed) - string(when) string(I) string(sprouted) string(that) - string(corn) string(stalk) string(from) string(my) - string(cabeza.

) -tag(---) + string(

I seriously blushed
) + string(when I sprouted that
) + string(corn stalk from my
) + string(cabeza.

) +head key(name)operator(:) string(inline attributes preceded by text are treated as literal) key(desc)operator(:) string(modifiers must come first, without anything before them) key(in)operator(:) string(|-) - string(I) global_variable(*seriously) operator({)key(color)symbol(:red)operator(})string(blushed*) - string(when) string(I) string(_first) string((big\)sprouted_) string(that) - string(corn) string(stalk) string(from) string(my) - string(%grande) operator([)string(es]cabeza%.) + string(I *seriously {color:red}blushed*) + string(when I _first (big\)sprouted_ that) + string(corn stalk from my) + string(%grande [es]cabeza%.) key(html)operator(:) string(|-) - string(

I) string(seriously) operator({)key(color)symbol(:red)operator(})string(blushed) - string(when) string(I) string(first) string((big\)sprouted) string(that) - string(corn) string(stalk) string(from) string(my) - string(grande) operator([)string(es]cabeza.

) -tag(---) + string(

I seriously {color:red}blushed
) + string(when I first (big\)sprouted that
) + string(corn stalk from my
) + string(grande [es]cabeza.

) +head key(name)operator(:) string(align justified) key(desc)operator(:) string(Text inside blocks can be aligned in four basic ways.) key(in)operator(:) string(p<>. justified) key(html)operator(:) string(

justified

) -tag(---) +head key(name)operator(:) string(indentation) key(desc)operator(:) string(Indentation can also be specified by provide a single left paren for every 1em to the left. A single right paren for every 1em to the right.) key(in)operator(:) string(p\)\)\). right ident 3em) key(html)operator(:) string(

right ident 3em

) -tag(---) +head key(name)operator(:) string(indentation and alignment) key(desc)operator(:) string(Identation may be coupled with alignment.) key(in)operator(:) string(h2(\)>. Bingo.) key(html)operator(:) string(

Bingo.

) -tag(---) +head key(name)operator(:) string(many modifiers combined) key(desc)operator(:) string(And, furthermore, coupled with language settings and CSS styles.) key(in)operator(:) string(h3(\)>[no]{color:red}. Bingo) key(html)operator(:) string(

Bingo

) -tag(---) +head key(name)operator(:) string(code blocks) key(desc)operator(:) string(For example, long code blocks belong between pre and code tags. Please also indent your code inside the tags to be sure that all Textile processors out there will ignore the contents.) key(in)operator(:) string(|) string(
)
   string()
-    string(a.gsub!() string(/)
   string(
) key(html)operator(:) string(|-) string(
)
   string()
-    string(a.gsub!() string(/</,) string('') string(\))
+    string(a.gsub!( /</, '' \))
   string()
   string(
) -tag(---) +head key(name)operator(:) string(div tags) key(desc)operator(:) string(You may also choose to surround sections with div tags to separate your document into sections. Instiki uses this technique to float a sidebar to the right.) key(in)operator(:) string(|) - string() + string(
) - string(h3.) string(Sidebar) + string(h3. Sidebar) - keysymbol(:http)error(:)string(//hobix.com/) - keysymbol(:http)error(:)string(//ruby-lang.org/) + string("Hobix":http://hobix.com/) + string("Ruby":http://ruby-lang.org/) string(
) - string(The) string(main) string(text) string(of) string(the) string(page) string(goes) string(here) string(and) string(will) string(stay) string(to) string(the) string(left) string(of) string(the) string(sidebar.) + string(The main text of the page goes here and will stay to the left of the sidebar.) key(html)operator(:) string(|-) - string() + string(
) string(

Sidebar

) - string(

Hobix) - string(Ruby

) + string(

Hobix
) + string(Ruby

) string(
) - string(

The) string(main) string(text) string(of) string(the) string(page) string(goes) string(here) string(and) string(will) string(stay) string(to) string(the) string(left) string(of) string(the) string(sidebar.

) -tag(---) + string(

The main text of the page goes here and will stay to the left of the sidebar.

) +head key(name)operator(:) string(numbered list) key(desc)operator(:) string(To make a numbered list, place each item in its own paragraph, preceded by ”#”.) key(in)operator(:) string(|-) @@ -438,11 +438,11 @@ key(in)operator(:) string(|-) comment(# A third) key(html)operator(:) string(|-) string(
    ) - string(
  1. A) string(first) string(item
    2. ) - string(
  2. A) string(second) string(item
    3. ) - string(
  3. A) string(third
    4. ) + string(
  4. A first item
    5. ) + string(
  5. A second item
    6. ) + string(
  6. A third
    7. ) string(
) -tag(---) +head key(name)operator(:) string(nested numbered lists) key(desc)operator(:) string(These lists may be nested by increasing the number of pound symbols preceding child entries.) key(in)operator(:) string(|-) @@ -455,262 +455,262 @@ key(in)operator(:) string(|-) comment(## Protein) key(html)operator(:) string(|-) string(
    ) - string(
  1. Fuel) string(could) key(be)error(:) + string(
  2. Fuel could be:) string(
      ) string(
    1. Coal
      2. ) string(
    2. Gasoline
      3. ) string(
    3. Electricity
      4. ) string(
    3. ) - string(
  3. Humans) string(need) key(only)error(:) + string(
  4. Humans need only:) string(
      ) string(
    1. Water
      2. ) string(
    2. Protein
      3. ) string(
    5. ) string(
) -tag(---) +head key(name)operator(:) string(bulleted list) key(desc)operator(:) string(Bulleted lists use an asterisk in place of the pound.) key(in)operator(:) string(|-) - string(*) string(A) string(first) string(item) - string(*) string(A) string(second) string(item) - string(*) string(A) string(third) + string(* A first item) + string(* A second item) + string(* A third) key(html)operator(:) string(|-) string(
    ) - string(
  • A) string(first) string(item
    • ) - string(
  • A) string(second) string(item
    • ) - string(
  • A) string(third
    • ) + string(
  • A first item
    • ) + string(
  • A second item
    • ) + string(
  • A third
    • ) string(
) -tag(---) +head key(name)operator(:) string(nested bulleted lists) key(desc)operator(:) string(These lists may be nested in like manner.) key(in)operator(:) string(|-) - string(*) string(Fuel) string(could) key(be)error(:) - string(**) string(Coal) - string(**) string(Gasoline) - string(**) string(Electricity) - string(*) string(Humans) string(need) key(only)error(:) - string(**) string(Water) - string(**) string(Protein) + string(* Fuel could be:) + string(** Coal) + string(** Gasoline) + string(** Electricity) + string(* Humans need only:) + string(** Water) + string(** Protein) key(html)operator(:) string(|-) string(
    ) - string(
  • Fuel) string(could) key(be)error(:) + string(
  • Fuel could be:) string(
      ) string(
    • Coal
      • ) string(
    • Gasoline
      • ) string(
    • Electricity
      • ) string(
    • ) - string(
  • Humans) string(need) key(only)error(:) + string(
  • Humans need only:) string(
      ) string(
    • Water
      • ) string(
    • Protein
      • ) string(
    • ) string(
) -tag(---) +head key(name)operator(:) string(links) key(desc)operator(:) string(Basic links are comprised of a phrase which is linked to a URL. Place the descriptive phrase in quotation marks. Follow it immediately by a colon and the URL.) key(in)operator(:) string(I searched "Google":http://google.com.) key(html)operator(:) string(

I searched Google.

) key(lite_mode_html)operator(:) string(I searched Google.) -tag(---) +head key(name)operator(:) string(link aliases) key(desc)operator(:) string(If you are using the same link several times in your document, or you’d just like to be a tad more organized, you can use a link alias. Place the URL anywhere in your document, beginning with its alias in square brackets. Then, use the alias in place of the URL, using the link format above.) key(in)operator(:) string(|-) - string(I) string(am) string(crazy) string(about) keysymbol(:hobix) - string(and) keysymbol(:hobix) string("all")symbol(:hobix) string(I) string(ever) - keysymbol(:hobix)string(!) + string(I am crazy about "Hobix":hobix) + string(and "it's":hobix "all":hobix I ever) + string("link to":hobix!) - operator([)string(hobix]http)error(:)string(//hobix.com) + operator([)string(hobix]http://hobix.com) key(html)operator(:) string(|-) - string(

I) string(am) string(crazy) string(about) string(Hobix) - string(and) string(it’s) string(all) string(I) string(ever) - string(link) string(to!

) -tag(---) + string(

I am crazy about Hobix
) + string(and it’s all I ever
) + string(link to!

) +head key(name)operator(:) string(image) key(desc)operator(:) string(You can embed an image in your Textile document by surrounding its URL with exclamation marks.) -key(in)operator(:) string("!http://hobix.com/sample.jpg!") +key(in)operator(:) string key(html)operator(:) string(

) key(lite_mode_html)operator(:) string() -tag(---) +head key(name)operator(:) string(image title) key(desc)operator(:) string(A title for the image can also be provided in parens, just before the closing exclamation.) -key(in)operator(:) string("!openwindow1.gif(Bunny.\)!") +key(in)operator(:) string key(html)operator(:) string(

Bunny.

) -tag(---) +head key(name)operator(:) string(image links) key(desc)operator(:) string(Links can be attached to images with a colon.) -key(in)operator(:) string("!openwindow1.gif!:http://hobix.com/") +key(in)operator(:) string key(html)operator(:) string(

) -tag(---) +head key(name)operator(:) string(image alignments) key(desc)operator(:) string(Alignments can be applied as well to images.) key(in)operator(:) string(|-) string(!>obake.gif!) - string(And) string(others) string(sat) string(all) string(round) string(the) string(small) - string(machine) string(and) string(paid) string(it) string(to) string(sing) string(to) string(them.) + string(And others sat all round the small) + string(machine and paid it to sing to them.) key(html)operator(:) string(|-) - string(

) - string(

And) string(others) string(sat) string(all) string(round) string(the) string(small) - string(machine) string(and) string(paid) string(it) string(to) string(sing) string(to) string(them.

) -tag(---) + string(

) + string(

And others sat all round the small
) + string(machine and paid it to sing to them.

) +head key(name)operator(:) string(acronym definitions) key(desc)operator(:) string(Definitions for acronyms can be provided by following an acronym with its definition in parens.) key(in)operator(:) string(We use CSS(Cascading Style Sheets\).) key(html)operator(:) string(

We use CSS.

) key(lite_mode_html)operator(:) string(We use CSS.) key(no_span_caps_html)operator(:) string(

We use CSS.

) -tag(---) +head key(name)operator(:) string(tables) key(desc)operator(:) string(Simple tables can be built by separating fields with pipe characters) key(in)operator(:) string(|-) - string(|) string(name) string(|) string(age) string(|) string(sex) string(|) - string(|) string(joan) string(|) string(24) string(|) string(f) string(|) - string(|) string(archie) string(|) string(29) string(|) string(m) string(|) - string(|) string(bella) string(|) string(45) string(|) string(f) string(|) + string(| name | age | sex |) + string(| joan | 24 | f |) + string(| archie | 29 | m |) + string(| bella | 45 | f |) key(html)operator(:) string(|-) string() string() - string() - string() - string() + string() + string() + string() string() string() - string() - string() - string() + string() + string() + string() string() string() - string() - string() - string() + string() + string() + string() string() string() - string() - string() - string() + string() + string() + string() string() string(
) string(name) string() string(age) string() string(sex) string( name age sex
) string(joan) string() string(24) string() string(f) string( joan 24 f
) string(archie) string() string(29) string() string(m) string( archie 29 m
) string(bella) string() string(45) string() string(f) string( bella 45 f
) -tag(---) +head key(name)operator(:) string(table headers) key(desc)operator(:) string(Specify header cells by marking them with an underscore and period.) key(in)operator(:) string(|-) - string(|_.) string(name) string(|_.) string(age) string(|_.) string(sex) string(|) - string(|) string(joan) string(|) string(24) string(|) string(f) string(|) - string(|) string(archie) string(|) string(29) string(|) string(m) string(|) - string(|) string(bella) string(|) string(45) string(|) string(f) string(|) + string(|_. name |_. age |_. sex |) + string(| joan | 24 | f |) + string(| archie | 29 | m |) + string(| bella | 45 | f |) key(html)operator(:) string(|-) string() string() - string() - string() - string() + string() + string() + string() string() string() - string() - string() - string() + string() + string() + string() string() string() - string() - string() - string() + string() + string() + string() string() string() - string() - string() - string() + string() + string() + string() string() string(
name) string(age) string(sex) string(name age sex
) string(joan) string() string(24) string() string(f) string( joan 24 f
) string(archie) string() string(29) string() string(m) string( archie 29 m
) string(bella) string() string(45) string() string(f) string( bella 45 f
) -tag(---) +head key(name)operator(:) string(table cell attributes) key(desc)operator(:) string(The period used above marks the end of a cell’s attributes. Other attributes can be applied as well.) key(in)operator(:) string(|-) - string(|_.) string(attribute) string(list) string(|) - string(|<.) string(align) string(left) string(|) - string(|>.) string(align) string(right|) - string(|=.) string(center) string(|) - string(|<>.) string(justify) string(|) - string(|^.) string(valign) string(top) string(|) - string(|~.) string(bottom) string(|) + string(|_. attribute list |) + string(|<. align left |) + string(|>. align right|) + string(|=. center |) + string(|<>. justify |) + string(|^. valign top |) + string(|~. bottom |) key(html)operator(:) string(|-) string() string() - string() + string() string() string() - string(align) string(left) string() + string() string() string() - string(align) string(right) + string() string() string() - string(center) string() + string() string() string() - string(justify) string() + string() string() string() - string(valign) string(top) string() + string() string() string() - string(bottom) string() + string() string() string(
attribute) string(list) string(attribute list
align left
align right
center
justify
valign top
bottom
) -tag(---) +head key(name)operator(:) string(table colspan) key(desc)operator(:) string(You can also specify colspans with a backslash, followed by the cell width.) key(in)operator(:) string(|-) - string(|\\2.) string(spans) string(two) string(cols) string(|) - string(|) string(col) string(1) string(|) string(col) string(2) string(|) + string(|\\2. spans two cols |) + string(| col 1 | col 2 |) key(html)operator(:) string(|-) string() string() - string(spans) string(two) string(cols) string() + string() string() string() - string() - string() + string() + string() string() string(
spans two cols
) string(col) string(1) string() string(col) string(2) string( col 1 col 2
) -tag(---) +head key(name)operator(:) string(table rowspan) key(desc)operator(:) string(Rowspan is specified by a forward slash, followed by the row height.) key(in)operator(:) string(|-) - string(|/3.) string(spans) string(3) string(rows) string(|) string(a) string(|) - string(|) string(b) string(|) - string(|) string(c) string(|) + string(|/3. spans 3 rows | a |) + string(| b |) + string(| c |) key(html)operator(:) string(|-) string() string() - string(spans) string(3) string(rows) string() - string() + string() + string() string() string() - string() + string() string() string() - string() + string() string() string(
) string(a) string(spans 3 rows a
) string(b) string( b
) string(c) string( c
) -tag(---) +head key(name)operator(:) string(block attributes applied to table cells) key(desc)operator(:) string(All block attributes can be applied to table cells as well.) -key(in)operator(:) string("|{background:#ddd}. Grey cell|") +key(in)operator(:) string key(html)operator(:) string(|-) string() string() - string(Grey cell) + string() string() string(
Grey cell
) -tag(---) +head key(name)operator(:) string(black attributes applied to a table) key(desc)operator(:) string(Table-wide attributes can be applied before the first row of the table. On its own line, followed by a period.) key(in)operator(:) string(|-) - string(table{border)symbol(:1px) string(solid) string(black}.) + string(table{border:1px solid black}.) string(|This|is|a|row|) string(|This|is|a|row|) key(html)operator(:) string(|-) - string() + string() string() string() string() @@ -724,12 +724,12 @@ key(html)operator(:) string(|-) string() string() string(
Thisisrow
) -tag(---) +head key(name)operator(:) string(black attributes applied to a table row) key(desc)operator(:) string(Attributes can be applied to a single row by supplying the attribute before the row starts, using a table modifier and following it by a period.) key(in)operator(:) string(|-) string(|This|is|a|row|) - operator({)key(background)error(:)comment(#ddd}. |This|is|grey|row|) + operator({)string(background:#ddd}. |This|is|grey|row|) key(html)operator(:) string(|-) string() string() @@ -738,134 +738,134 @@ key(html)operator(:) string(|-) string() string() string() - string() + string() string() string() string() string() string() string(
arow
Thisisgreyrow
) -tag(---) +head key(name)operator(:) string(extended block followed by pre block) key(in)operator(:) string(|-) - string(div..) string(Just) string(a) string(test.) + string(div.. Just a test.) - string(Second) string(div.) + string(Second div.) - string(pre.) string(A) string(pre) string(block) string(ends) string(it.) + string(pre. A pre block ends it.) key(html)operator(:) string(|-) - string(
Just) string(a) string(test.
) - string(
Second) string(div.
) - string(
A) string(pre) string(block) string(ends) string(it.
) -tag(---) + string(
Just a test.
) + string(
Second div.
) + string(
A pre block ends it.
) +head key(name)operator(:) string(extended block followed by blockquote) key(in)operator(:) string(|-) - string(div..) string(Just) string(a) string(test.) + string(div.. Just a test.) - string(Second) string(div.) + string(Second div.) - string(bq.) string(A) string(blockquote) string(ends) string(it.) + string(bq. A blockquote ends it.) key(html)operator(:) string(|-) - string(
Just) string(a) string(test.
) - string(
Second) string(div.
) + string(
Just a test.
) + string(
Second div.
) string(
) - string(

A) string(blockquote) string(ends) string(it.

) + string(

A blockquote ends it.

) string(
) -tag(---) +head key(name)operator(:) string(extended block followed by block code) key(in)operator(:) string(|-) - string(div..) string(Just) string(a) string(test.) + string(div.. Just a test.) - string(Second) string(div.) + string(Second div.) - string(bc.) string(A) string(blockcode) string(ends) string(it.) + string(bc. A blockcode ends it.) key(html)operator(:) string(|-) - string(
Just) string(a) string(test.
) - string(
Second) string(div.
) - string(
A) string(blockcode) string(ends) string(it.
) -tag(---) + string(
Just a test.
) + string(
Second div.
) + string(
A blockcode ends it.
) +head key(name)operator(:) string(extended block followed by notextile block) key(in)operator(:) string(|-) - string(div..) string(Just) string(a) string(test.) + string(div.. Just a test.) - string(Second) string(div.) + string(Second div.) - string(notextile.) string(A) string(notextile) string(block) string(ends) string(it.) + string(notextile. A notextile block ends it.) key(html)operator(:) string(|-) - string(
Just) string(a) string(test.
) - string(
Second) string(div.
) - string(A) string(notextile) string(block) string(ends) string(it.) + string(
Just a test.
) + string(
Second div.
) + string(A notextile block ends it.) key(valid_html)operator(:) string(false) -tag(---) +head key(name)operator(:) string(simple parentheses) key(in)operator(:) string(|-) - string(before) string((in) string(parens\)) string(after) + string(before (in parens\) after) key(html)operator(:) string(|-) - string(

before) string((in) string(parens\)) string(after

) -tag(---) + string(

before (in parens\) after

) +head key(name)operator(:) string(parentheses in underscores) key(in)operator(:) string(|-) - string(before) string(_(in) string(parens\)_) string(after) + string(before _(in parens\)_ after) key(html)operator(:) string(|-) - string(

before) string((in) string(parens\)) string(after

) -tag(---) + string(

before (in parens\) after

) +head key(name)operator(:) string(parentheses in asterisks) key(in)operator(:) string(|-) - string(before) string(*(in) string(parens\)*) string(after) + string(before *(in parens\)* after) key(html)operator(:) string(|-) - string(

before) string((in) string(parens\)) string(after

) -tag(---) + string(

before (in parens\) after

) +head key(name)operator(:) string(parentheses in underscores in quotes) key(in)operator(:) string(|-) - string("before) string(_(in) string(parens\)_) string(after") + string("before _(in parens\)_ after") key(html)operator(:) string(|-) - string(

“before) string((in) string(parens\)) string(after”

) -tag(---) + string(

“before (in parens\) after”

) +head key(name)operator(:) string(underscores in parentheses) key(in)operator(:) string(|-) - string(one) string(_two) string(three_) string((four) string(_five) string(six_\)) string(seven) + string(one _two three_ (four _five six_\) seven) key(html)operator(:) string(|-) - string(

one) string(two) string(three) string((four) string(five) string(six\)) string(seven

) -tag(---) + string(

one two three (four five six\) seven

) +head key(name)operator(:) string(underscores in parentheses in quotes) key(in)operator(:) string(|-) - string("one) string(_two) string(three_) string((four) string(_five) string(six_\)) string(seven") + string("one _two three_ (four _five six_\) seven") key(html)operator(:) string(|-) - string(

“one) string(two) string(three) string((four) string(five) string(six\)) string(seven”

) -tag(---) + string(

“one two three (four five six\) seven”

) +head key(name)operator(:) string(underscores in parentheses 2) key(in)operator(:) string(|-) - string(one) string((two) string(_three) string(four_\)) string(five) + string(one (two _three four_\) five) key(html)operator(:) string(|-) - string(

one) string((two) string(three) string(four\)) string(five

) -tag(---) + string(

one (two three four\) five

) +head key(name)operator(:) string(underscores in parentheses in quotes 2) key(in)operator(:) string(|-) - string("one) string((two) string(_three) string(four_\)) string(five") + string("one (two _three four_\) five") key(html)operator(:) string(|-) - string(

“one) string((two) string(three) string(four\)) string(five”

) -tag(---) + string(

“one (two three four\) five”

) +head key(name)operator(:) string(caps in parentheses) key(desc)operator(:) string(Uppercase words of three or more characters that are in parentheses should be recognized as well as those not in parentheses.) key(in)operator(:) string(IBM or (HAL\)) key(html)operator(:) string(

IBM or (HAL\)

) key(no_span_caps_html)operator(:) string(

IBM or (HAL\)

) -tag(---) +head key(name)operator(:) string(phrase modifiers in parentheses) key(desc)operator(:) string(Inline modifiers are expected to work in parentheses as well.) key(in)operator(:) string(|-) - string(__Amanita__s) string(are) string(mushrooms.) - string(Lungworts) string((__Lobaria__\)) string(are) string(lichens.) - string(Blah) string(blah) string((normal) string(text) string(**bold**\)) string(blah.) + string(__Amanita__s are mushrooms.) + string(Lungworts (__Lobaria__\) are lichens.) + string(Blah blah (normal text **bold**\) blah.) key(html)operator(:) string(|-) - string(

__Amanita__s) string(are) string(mushrooms.) - string(Lungworts) string((Lobaria\)) string(are) string(lichens.) - string(Blah) string(blah) string((normal) string(text) string(bold\)) string(blah.

) -tag(---) + string(

__Amanita__s are mushrooms.
) + string(Lungworts (Lobaria\) are lichens.
) + string(Blah blah (normal text bold\) blah.

) +head key(name)operator(:) string(square brackets are preserved) key(in)operator(:) string(|-) - string(citation) operator([)string("(Berk.\)) string(Hilton"],) string(see) - operator([)string(Papers) string("blah) string(blah."]) + string(citation ["(Berk.\) Hilton"], see) + operator([)string(Papers "blah blah."]) key(html)operator(:) string(|-) - string(

citation) operator([)variable(“(Berk.\)) string(Hilton”],) string(see) - operator([)string(Papers) variable(“blah) string(blah.”]

) \ No newline at end of file + string(

citation [“(Berk.\) Hilton”], see
) + operator([)string(Papers “blah blah.”]

) \ No newline at end of file diff --git a/test/scanners/yaml/database.expected.raydebug b/test/scanners/yaml/database.expected.raydebug new file mode 100644 index 0000000..3efbba2 --- /dev/null +++ b/test/scanners/yaml/database.expected.raydebug @@ -0,0 +1,52 @@ +key(login)operator(:) variable(&login) + key(adapter)operator(:) string(mysql) + key(host)operator(:) string(localhost) + key(socket)operator(:) string(/Applications/MAMP/tmp/mysql/mysql.sock) + key(username)operator(:) string(rails) + key(password)operator(:) + +comment(# A) +key(development)operator(:) variable(&default) + key(database)operator(:) string(a_development) + class_variable(<<)operator(:) global_variable(*login) + +key(production)operator(:) variable(&production) + class_variable(<<)operator(:) global_variable(*default) + +key(test)operator(:) variable(&test) + key(database)operator(:) string(a_test) + class_variable(<<)operator(:) global_variable(*login) + +comment(# B) +key(b_development)operator(:) variable(&b) + key(database)operator(:) string(b_development) + class_variable(<<)operator(:) global_variable(*login) + +key(b_production)operator(:) global_variable(*b) + +key(b_test)operator(:) + key(database)operator(:) string(b_test) + class_variable(<<)operator(:) global_variable(*login) + +comment(# C) +key(c_development)operator(:) variable(&c) + key(database)operator(:) string(c_development) + class_variable(<<)operator(:) global_variable(*login) + +key(c_production)operator(:) global_variable(*c) + +key(c_test)operator(:) + key(database)operator(:) string(c_test) + class_variable(<<)operator(:) global_variable(*login) + +comment(# D) +key(d_development)operator(:) variable(&d) + key(database)operator(:) string(d_development) + class_variable(<<)operator(:) global_variable(*login) + +key(d_production)operator(:) global_variable(*d) + +key(d_test)operator(:) + key(database)operator(:) string(d_test) + class_variable(<<)operator(:) global_variable(*login) + diff --git a/test/scanners/yaml/database.in.yml b/test/scanners/yaml/database.in.yml new file mode 100644 index 0000000..4f3dc31 --- /dev/null +++ b/test/scanners/yaml/database.in.yml @@ -0,0 +1,52 @@ +login: &login + adapter: mysql + host: localhost + socket: /Applications/MAMP/tmp/mysql/mysql.sock + username: rails + password: + +# A +development: &default + database: a_development + <<: *login + +production: &production + <<: *default + +test: &test + database: a_test + <<: *login + +# B +b_development: &b + database: b_development + <<: *login + +b_production: *b + +b_test: + database: b_test + <<: *login + +# C +c_development: &c + database: c_development + <<: *login + +c_production: *c + +c_test: + database: c_test + <<: *login + +# D +d_development: &d + database: d_development + <<: *login + +d_production: *d + +d_test: + database: d_test + <<: *login + diff --git a/test/scanners/yaml/faq.expected.raydebug b/test/scanners/yaml/faq.expected.raydebug index 491f335..77b9b30 100644 --- a/test/scanners/yaml/faq.expected.raydebug +++ b/test/scanners/yaml/faq.expected.raydebug @@ -1,492 +1,492 @@ -tag(---) -operator(-) keyerror(:) +head +operator(-) keyoperator(:) operator(-) keyoperator(:) string(>-) - string(A) string(_container_) string(is) string(collection) string(of) string(service) string(points) string(and) string(other) string(containers.) string(It) - string(is) string(used) string(to) string(organize) string(services.) string(Each) string(container) string(has) string(access) string(to) string(all) string(of) string(the) - string(service) string(points) string(in) string(its) string(ancestor) string(containers.) + string(A _container_ is collection of service points and other containers. It) + string(is used to organize services. Each container has access to all of the) + string(service points in its ancestor containers.) operator(-) keyoperator(:) string(>-) - string(A) string(_registry_) string(is) string(a) string(special) string(kind) string(of) string(container) string(that) string(has) string(no) string(parent) string(container.) - string(It) string(also) string(defines) string(a) string(few) string(services) string((such) string(as) string(the) string(LoggingInterceptor,) string(and) - string(the) string(various) string(service) string(models) string(and) string(pipeline) string(elements\),) string(so) string(that) string(they) string(are) - string(available) string(by) string(default) string(to) string(all) string(of) string(the) string(services) string(it) string(contains.) + string(A _registry_ is a special kind of container that has no parent container.) + string(It also defines a few services (such as the LoggingInterceptor, and) + string(the various service models and pipeline elements\), so that they are) + string(available by default to all of the services it contains.) operator(-) keyoperator(:) string(>-) - string(A) string(_service) string(point_) string(is) string(the) string(definition) string(of) string(a) string(service.) string(Just) string(as) string(a) string(class) string(is) string(the) - string(definition) string(of) string(an) string(object,) string(and) string(you) string(instantiate) string(an) string(object) string(from) string(a) string(class,) string(so) - string(do) string(you) string(instantiate) string(services) string(from) string(service) string(points.) + string(A _service point_ is the definition of a service. Just as a class is the) + string(definition of an object, and you instantiate an object from a class, so) + string(do you instantiate services from service points.) operator(-) keyoperator(:) string(>-) - string(A) string(_service_) string(is) string(the) string(instantiation) string(of) string(a) string(service) string(point.) + string(A _service_ is the instantiation of a service point.) operator(-) keyoperator(:) string(>-) - string(A) string(_parameterized_) string(service) string(is) string(a) string(service) string(that) string(allows) string(contextual) string(parameters) - string(to) string(be) string(passed) string(to) string(the) string(service) string(when) string(it) string(is) string(created.) string(Such) string(services) string(are) - string(typically) string(used) string(in) string(conjunction) string(with) string(the) string(@multiton@) string(service) string(model,) string(but) - string(the) string(only) string(real) string(requirement) string(is) string(that) string(they) string(_not_) string(be) string(used) string(with) string(a) string(service) string(model) - string(that) string(does) string(not) string(support) string(multiple) string(parameters) string((like) string(@singleton@) string(or) + string(A _parameterized_ service is a service that allows contextual parameters) + string(to be passed to the service when it is created. Such services are) + string(typically used in conjunction with the @multiton@ service model, but) + string(the only real requirement is that they _not_ be used with a service model) + string(that does not support multiple parameters (like @singleton@ or) string(@threaded@\).) operator(-) keyoperator(:) string(>-) - string(A) string(_service) string(model_) string(is) string(a) string(description) string(of) string(the) string(lifecycle) string(of) string(a) string(service.) string(By) - string(default,) string(all) string(services) string(are) string(_singletons_,) string(meaning) string(that) string(every) string(time) string(you) string(ask) - string(a) string(container) string(for) string(a) string(particular) string(service,) string(you'll) string(get) string(the) string(same) string(object) - string(instance) string(back.) + string(A _service model_ is a description of the lifecycle of a service. By) + string(default, all services are _singletons_, meaning that every time you ask) + string(a container for a particular service, you'll get the same object) + string(instance back.) - string(There) string(are) string(other) string(service) string(models) string(available,) string(though,) string(including) string("prototype") - string((which) string(returns) string(a) string(new) string(instance) string(for) string(each) string(request) string(of) string(a) string(service\)) string(and) - string("deferred") string((which) string(returns) string(a) string(proxy,) string(deferring) string(the) string(instatiation) string(of) string(the) - string(service) string(itself) string(until) string(a) string(method) string(is) string(invoked) string(on) string(the) string(service\).) + string(There are other service models available, though, including "prototype") + string((which returns a new instance for each request of a service\) and) + string("deferred" (which returns a proxy, deferring the instatiation of the) + string(service itself until a method is invoked on the service\). ) operator(-) keyoperator(:) string(>-) - string(An) string(_interceptor_) string(is) string(an) string(object) string(that) string(may) string(be) string(placed) string(between) string(the) string(client) string(and) - string(a) string(service.) string(Every) string(request) string(to) string(the) string(service) string(is) string(thus) string(_intercepted_) string(by) string(that) - string(object,) string(which) string(can) string(do) string(operations) string(on) string(the) string(request) string((such) string(as) string(logging\)) string(and) string(may) - string(even) string(reroute) string(or) string(ignore) string(the) string(request) string(altogether.) string(This) string(provides) string(a) string(kind) string(of) - string("poor) string(man's) string(AOP",) string(since) string(you) string(can) string(do) string("before",) string("after",) string(and) string("around") string(advice) - string(on) string(the) string(methods) string(of) string(a) string(service.) + string(An _interceptor_ is an object that may be placed between the client and) + string(a service. Every request to the service is thus _intercepted_ by that) + string(object, which can do operations on the request (such as logging\) and may) + string(even reroute or ignore the request altogether. This provides a kind of) + string("poor man's AOP", since you can do "before", "after", and "around" advice) + string(on the methods of a service.) - string(Needle) string(comes) string(with) string(one) string(standard) string(interceptor,) string(the) string(LoggingInterceptor.) string(It) - string(will) string(log) string(a) string(message) string(on) string(method) string(entry) string(and) string(exit,) string(and) string(also) string(when) string(an) string(exception) - string(is) string(raised.) + string(Needle comes with one standard interceptor, the LoggingInterceptor. It) + string(will log a message on method entry and exit, and also when an exception) + string(is raised.) operator(-) keyoperator(:) string(>-) - string(In) string(Needle,) string(the) string(_instantiation) string(pipeline_) string(is) string(used) string(to) string(control) string(how) string(and) string(when) - string(services) string(are) string(instantiated.) string(The) string(_service) string(models_) string(are) string(implemented) string(as) + string(In Needle, the _instantiation pipeline_ is used to control how and when) + string(services are instantiated. The _service models_ are implemented as) string(pipelines.) - string(Just) string(as) string(the) string(_interceptors_) string(are) string(for) string(hooking) string(into) string(method) string(invocations,) string(the) - string(pipelines) string(are) string(for) string(hooking) string(into) string(service) string(instantiations.) string(Every) string(time) string(a) - string(service) string(is) string(requested,) string(it's) string(instantiation) string(pipeline) string(is) string(executed.) string(By) - string(choosing) string(the) string(appropriate) string(kinds) string(of) string(pipeline) string(elements,) string(all) string(of) string(the) string(available) - string(service) string(models) string(can) string(be) string(implemented) string((prototype,) string(prototype_deferred,) - string(singleton,) string(singleton_deferred,) string(etc.\).) + string(Just as the _interceptors_ are for hooking into method invocations, the) + string(pipelines are for hooking into service instantiations. Every time a) + string(service is requested, it's instantiation pipeline is executed. By) + string(choosing the appropriate kinds of pipeline elements, all of the available) + string(service models can be implemented (prototype, prototype_deferred,) + string(singleton, singleton_deferred, etc.\).) -operator(-) keyerror(:) +operator(-) keyoperator(:) operator(-) keyoperator(:) string(>-) - string(There) string(are) string(several) string(ways) string(to) string(create) string(a) string(new) string(registry.) string(The) string(simplist) string(is) string(just) string(to) - string(invoke) string(Registry#new.) + string(There are several ways to create a new registry. The simplist is just to) + string(invoke Registry#new.) string(
)
-        string(reg) string(=) key(Needle)error(:)symbol(:Registry)string(.new)
+        string(reg = Needle::Registry.new)
       string(
) - string(This) string(will) string(create) string(a) string(new) string(Registry) string(instance.) string(You) string(can) string(also) string(send) string(a) string(block) string(to) + string(This will create a new Registry instance. You can also send a block to) comment(#new, in which case the new registry will be yielded to it:) string(
)
-        string(reg) string(=) key(Needle)error(:)symbol(:Registry)string(.new) string(do) string(|r|)
+        string(reg = Needle::Registry.new do |r|)
           string(...)
         string(end)
       string(
) - string(There) string(are) string(two) string(other) string(factory) string(methods) string(you) string(can) string(use) string(for) string(creating) string(a) string(Registry) - string(instance.) string(Both) string(require) string(a) string(block.) + string(There are two other factory methods you can use for creating a Registry) + string(instance. Both require a block.) string(
)
-        string(r1) string(=) key(Needle)error(:)symbol(:Registry)string(.define) string(do) string(|builder|)
+        string(r1 = Needle::Registry.define do |builder|)
           string(...)
         string(end)
 
-        string(r2) string(=) key(Needle)error(:)symbol(:Registry)string(.define!) string(do)
+        string(r2 = Needle::Registry.define! do)
           string(...)
         string(end)
       string(
) - string(Registry#define) string(creates) string(a) string("builder") string(object) string(that) string(you) string(can) string(use) string(define) - string(services) string(more) string(conveniently.) string(Register#define!) string((with) string(a) string(bang\)) string(does) string(the) string(same) - string(thing,) string(but) string(evaluates) string(the) string(block) string(within) string(the) string(context) string(of) string(the) string(builder.) + string(Registry#define creates a "builder" object that you can use define) + string(services more conveniently. Register#define! (with a bang\) does the same) + string(thing, but evaluates the block within the context of the builder.) operator(-) keyoperator(:) string(>-) - string(The) string(first) string(way) string(to) string(register) string(a) string(service) string(is) string(by) string(calling) comment(#register on the) - string(registry) string((or) string(a) string(namespace\))error(:) + string(The first way to register a service is by calling #register on the) + key(registry (or a namespace\))operator(:) string(
)
-        string(reg.register() symbol(:foo) string(\)) operator({) string(Foo.new) operator(})
+        string(reg.register( :foo \) { Foo.new })
       string(
) - string(The) string((first\)) string(parameter) string(to) comment(#register is the name of the service, and the) - string(block) string(should) string(return) string(the) string(implementation) string(of) string(the) string(service.) string(If) string(needed,) string(the) - string(block) string(can) string(accept) string(two) string(parameters--the) string(container) string(that) string(the) string(service) string(is) string(being) - string(registered) string(with,) string(and) string(an) string(object) string(that) string(represents) string(the) string(service) string(being) string(defined) - string((called) string(a) string("service) string(point"\))error(:) + string(The (first\) parameter to #register is the name of the service, and the) + string(block should return the implementation of the service. If needed, the) + string(block can accept two parameters--the container that the service is being) + string(registered with, and an object that represents the service being defined) + string((called a "service point"\):) string(
)
-        string(reg.register() symbol(:foo) string(\)) string(do) string(|container,point|)
-          string(Foo.new() string(container[)symbol(:bar)operator(])operator(,) string(point.fullname) string(\))
+        string(reg.register( :foo \) do |container,point|)
+          string(Foo.new( container[:bar], point.fullname \))
         string(end)
       string(
) - string(You) string(can) string(also) string(use) string(Container#define) string(and) string(Container#define!) string(to) string(register) - string(services.) string(These) string(approaches) string(are) string(friendlier) string(if) string(you) string(are) string(needing) string(to) string(register) - string(several) string(services) string(at) string(once.) + string(You can also use Container#define and Container#define! to register) + string(services. These approaches are friendlier if you are needing to register) + string(several services at once.) string(
)
-        string(reg.define) string(do) string(|builder|)
-          string(builder.foo) operator({) string(Foo.new) operator(})
-          string(builder.bar) operator({) string(|c,p|) string(Bar.new() string(c[)symbol(:foo)operator(])operator(,) string(p.name) string(\)) operator(})
+        string(reg.define do |builder|)
+          string(builder.foo { Foo.new })
+          string(builder.bar { |c,p| Bar.new( c[:foo], p.name \) })
         string(end)
 
-        string(reg.define!) string(do)
-          string(baz) operator({) string(|c,p|) string(Baz.new() string(c[)symbol(:bar)operator(])operator(,) string(p.name) string(\)) operator(})
-          string(zoom) operator({) string(Buggy.new) operator(})
+        string(reg.define! do)
+          string(baz { |c,p| Baz.new( c[:bar], p.name \) })
+          string(zoom { Buggy.new })
         string(end)
       string(
) - string(Container#define) string(yields) string(a) string(new) string("builder") string(object) string(to) string(the) string(block.) string(Messages) - string(sent) string(to) string(the) string(builder) string(are) string(interpreted) string(as) string(service) string(names,) string(and) string(if) string(a) string(block) string(is) - string(sent) string(with) string(the) string(message,) string(a) string(new) string(service) string(is) string(registered) string(under) string(that) string(name.) + string(Container#define yields a new "builder" object to the block. Messages) + string(sent to the builder are interpreted as service names, and if a block is) + string(sent with the message, a new service is registered under that name.) - string(Container#define!) string(does) string(likewise,) string(except) string(it) string(evaluates) string(the) string(block) string(within) string(the) - string(context) string(of) string(the) string(builder) string(object.) + string(Container#define! does likewise, except it evaluates the block within the) + string(context of the builder object.) - string(If) string(you) string(do) string(not) string(pass) string(a) string(block) string(to) comment(#define, it will return the builder object,) - string(so) string(you) string(could) string(do) string(something) string(like) string(the) string(following) string(if) string(you) string(only) string(need) string(to) string(define) - string(one) string(or) string(two) key(services)error(:) + string(If you do not pass a block to #define, it will return the builder object,) + string(so you could do something like the following if you only need to define) + key(one or two services)operator(:) string(
)
-        string(reg.define.foo) operator({) string(...) operator(})
+        string(reg.define.foo { ... })
       string(
) - string(Lastly,) string(you) string(can) string(get) string(the) string(builder) string(directly) string(and) string(add) string(services) string(using) key(it)error(:) + string(Lastly, you can get the builder directly and add services using it:) string(
)
-        string(builder) string(=) string(reg.builder)
-        string(builder.baz) operator({) string(...) operator(})
-        string(builder.bar) operator({) string(...) operator(})
+        string(builder = reg.builder)
+        string(builder.baz { ... })
+        string(builder.bar { ... })
       string(
) - string((This) string(last) string(is) string(the) string(same) string(as) string(calling) comment(#define without arguments, but is more) - string(readable) string(if) string(you) string(intend) string(to) string(use) string(the) string(builder) string(object) string(multiple) string(times.\)) + string((This last is the same as calling #define without arguments, but is more) + string(readable if you intend to use the builder object multiple times.\)) operator(-) keyoperator(:) string(>-) - string(Referencing) string(a) string(service) string(can) string(be) string(done) string(in) string(either) string(of) string(two) string(ways.) string(The) string(first) string(is) string(to) - string(treat) string(the) string(container) string((i.e.,) string(registry\)) string(as) string(a) string(hash,) string(passing) string(the) string(name) string(of) string(the) - string(service) string(as) string(an) string(argument) string(to) string(Container#[])error(:) + string(Referencing a service can be done in either of two ways. The first is to) + string(treat the container (i.e., registry\) as a hash, passing the name of the) + string(service as an argument to Container#[]:) string(
)
-        string(svc) string(=) string(registry[)symbol(:foo)operator(])
+        string(svc = registry[:foo])
         string(svc.do_something_interesting)
       string(
) - string(A) string(more) string(convenient) string((but) string(slightly) string(more) string(peril-fraught\)) string(approach) string(is) string(to) string(send) - string(the) string(name) string(of) string(the) string(method) string(to) string(the) string(registry) string(as) string(a) key(message)error(:) + string(A more convenient (but slightly more peril-fraught\) approach is to send) + key(the name of the method to the registry as a message)operator(:) string(
)
-        string(svc) string(=) string(registry.foo)
+        string(svc = registry.foo)
       string(
) - string(Be) string(aware) string(that) string(this) string(latter) string(approach) string(will) string(only) string(work) string(when) string(the) string(service) string(name) - string(does) string(not) string(conflict) string(with) string(the) string(name) string(of) string(an) string(existing) string(method) string(on) string(the) string(container.) - string(For) string(example,) string(if) string(you) string(were) string(to) key(do)error(:) + string(Be aware that this latter approach will only work when the service name) + string(does not conflict with the name of an existing method on the container.) + string(For example, if you were to do:) string(
)
-        string(registry.register() symbol(:hash) string(\)) operator({) string("hello,) string(world") operator(})
-        string(p) string(registry.hash)
+        string(registry.register( :hash \) { "hello, world" })
+        string(p registry.hash)
       string(
) - string(You) string(would) string(get) string(the) string(hash) string(value) string(of) string(the) string(registry) string(object,) string(instead) string(of) string(the) string(value) - string(value) string(of) string(the) string(service) string((which) string(would) string(be) string("hello,) string(world"\).) + string(You would get the hash value of the registry object, instead of the value) + string(value of the service (which would be "hello, world"\).) operator(-) keyoperator(:) string(>-) - string(By) string(default,) string(a) string(service) string(will) string(be) string(managed) string(as) string(a) string(singleton,) string(i.e.,) string(every) string(request) - string(of) string(that) string(service) string(will) string(return) string(the) string(same) string(object) string(instance.) string(This) string(is) string(the) - string(_singleton_) string(service) string(model.) + string(By default, a service will be managed as a singleton, i.e., every request) + string(of that service will return the same object instance. This is the) + string(_singleton_ service model.) - string(To) string(select) string(a) string(different) string(service) string(model,) string(pass) string(it) string(as) string(an) string(option) string(when) string(you) - string(register) string(the) key(service)error(:) + string(To select a different service model, pass it as an option when you) + key(register the service)operator(:) string(
)
-        string(registry.register() symbol(:foo)operator(,) symbol(:model) string(=>) symbol(:prototype) string(\)) operator({)string(...})
-        string(registry.define.bar() symbol(:model) string(=>) symbol(:threaded) string(\)) operator({)string(...})
-        string(registry.define!) string(do)
-          string(baz() symbol(:model) string(=>) symbol(:singleton_deferred) string(\)) operator({)string(...})
+        string(registry.register( :foo, :model => :prototype \) {...})
+        string(registry.define.bar( :model => :threaded \) {...})
+        string(registry.define! do)
+          string(baz( :model => :singleton_deferred \) {...})
           string(...)
         string(end)
         string(...)
       string(
) operator(-) keyoperator(:) string(>-) - string(Namespaces) string(allow) string(you) string(to) string(organize) string(your) string(services) string(into) string(hierarchical) - string(packages.) string(You) string(can) string(create) string(namespaces) string(in) string(a) string(few) string(ways.) string(The) string(first) string((and) - string(simplest\)) string(is) string(to) string(just) string(call) string(Container#namespace)error(:) + string(Namespaces allow you to organize your services into hierarchical) + string(packages. You can create namespaces in a few ways. The first (and) + string(simplest\) is to just call Container#namespace:) string(
)
-        string(registry.namespace() symbol(:stuff) string(\))
+        string(registry.namespace( :stuff \))
       string(
) - string(This) string(will) string(create) string(a) string(namespace) string(in) string(the) string(registry,) string(called) string(stuff.) string(If) string(you) string(send) string(a) - string(block) string(as) string(well,) string(the) string(block) string(will) string(be) string(invoked) string((with) string(the) string(new) string(namespace) string(yielded) - string(to) string(it\)) string(the) string(first) string(time) string(the) string(namespace) string(is) key(requested)error(:) + string(This will create a namespace in the registry, called stuff. If you send a) + string(block as well, the block will be invoked (with the new namespace yielded) + key(to it\) the first time the namespace is requested)operator(:) string(
)
-        string(registry.namespace() symbol(:stuff) string(\)) string(do) string(|ns|)
-          string(ns.register() symbol(:foo) string(\)) operator({)string(...})
-          string(ns.define.bar) operator({)string(...})
-          string(ns.define!) string(do)
-            string(baz) operator({)string(...})
-            string(buf) operator({)string(...})
+        string(registry.namespace( :stuff \) do |ns|)
+          string(ns.register( :foo \) {...})
+          string(ns.define.bar {...})
+          string(ns.define! do)
+            string(baz {...})
+            string(buf {...})
           string(end)
         string(end)
       string(
) - string(Because) string(it) string(is) string(so) string(common) string(to) string(immediately) string(define) string(services) string(on) string(the) string(new) - string(namespace,) string(there) string(are) string(some) string(convenience) string(methods) string(to) string(make) string(this) string(more...) + string(Because it is so common to immediately define services on the new) + string(namespace, there are some convenience methods to make this more...) string(convenient.) string(
)
-        string(registry.namespace_define!() symbol(:stuff) string(\)) string(do)
-          string(foo) operator({)string(...})
-          string(bar) operator({)string(...})
-          string(baz) operator({)string(...})
+        string(registry.namespace_define!( :stuff \) do)
+          string(foo {...})
+          string(bar {...})
+          string(baz {...})
         string(end)
 
-        string(registry.namespace_define() symbol(:more_stuff) string(\)) string(do) string(|b|)
-          string(b.blah) operator({)string(...})
-          string(b.argh) operator({)string(...})
-          string(b.hack) operator({)string(...})
+        string(registry.namespace_define( :more_stuff \) do |b|)
+          string(b.blah {...})
+          string(b.argh {...})
+          string(b.hack {...})
         string(end)
       string(
) - string(The) string(first) string(one,) string(above,) string(creates) string(the) string(namespace) string(and) string(calls) string(Container#define!.) - string(The) string(second) string(creates) string(the) string(namespace) string(and) string(calls) string(Container#define.) string(In) string(both) - string(cases,) string(_the) string(namespace) string(is) string(created) string(immediately_,) string(unlike) string(Container#namespace) - string(which) string(only) string(creates) string(the) string(namespace) string(when) string(it) string(is) string(first) string(requested.) + string(The first one, above, creates the namespace and calls Container#define!.) + string(The second creates the namespace and calls Container#define. In both) + string(cases, _the namespace is created immediately_, unlike Container#namespace) + string(which only creates the namespace when it is first requested.) - string(Lastly,) string(note) string(that) string(namespace's) string(are) string(just) string(special) string(services.) string(Thus,) string(you) string(can) - string(pass) string(options) string(to) string(the) string(namespace) string(methods) string(just) string(as) string(you) string(can) string(with) - string(Container#register) string(and) string(friends.) + string(Lastly, note that namespace's are just special services. Thus, you can) + string(pass options to the namespace methods just as you can with) + string(Container#register and friends.) operator(-) keyoperator(:) string(>-) - string(You) string(can) string(obtain) string(a) string(new) string(logger) string(instance) string(from) string(the) string(@)symbol(:logs)string(@) string(and) string(@)symbol(:log_for)string(@) - string(services.) string(Once) string(you) string(have) string(a) string(logger) string(instance,) string(you) string(can) string(invoke) string(the) comment(#debug,) + string(You can obtain a new logger instance from the @:logs@ and @:log_for@) + string(services. Once you have a logger instance, you can invoke the #debug,) comment(#info, #warn, #error, and #fatal methods on the instance to log messages) - string(of) string(the) string(corresponding) string(severity.) + string(of the corresponding severity.) string(
)
-        string(logger) string(=) string(registry.logs.get() string("a) string(name) string(for) string(my) string(logger") string(\))
-        string(logger.debug) string("This) string(is) string(a) string(debug) string(message")
-        string(logger.info) string("This) string(is) string(an) string(informational) string(message")
+        string(logger = registry.logs.get( "a name for my logger" \))
+        string(logger.debug "This is a debug message")
+        string(logger.info "This is an informational message")
         string(...)
-        string(logger2) string(=) string(registry.log_for() string("another) string(logger) string(name") string(\))
+        string(logger2 = registry.log_for( "another logger name" \))
         string(...)
       string(
) - string(The) string(two) string(approaches) string(shown) string(above) string(are) string(identical--the) string(second) string(approach) string((using) - string(the) string(@log_for@) string(service\)) string(is) string(just) string(a) string(convenience) string(for) string(@logs.get@.) + string(The two approaches shown above are identical--the second approach (using) + string(the @log_for@ service\) is just a convenience for @logs.get@.) - string(Log) string(messages) string(are) string(written,) string(by) string(default,) string(to) string(a) string(file) string(called) string("needle.log",) string(in) - string(the) string(same) string(directory) string(that) string(the) string(application) string(was) string(invoked) string(from.) + string(Log messages are written, by default, to a file called "needle.log", in) + string(the same directory that the application was invoked from.) - string(You) string(can) string(also) string(use) string(a) string(logging) string(interceptor) string(to) string(automatically) string(log) string(all) string(external) - string(method) string(invocations) string(on) string(a) string(service.) string(This) string(includes) string(method) string(entry) string(and) string(exit,) string(as) - string(well) string(as) string(any) string(exceptions) string(that) string(are) string(raised) string(inside) string(the) string(method.) + string(You can also use a logging interceptor to automatically log all external) + string(method invocations on a service. This includes method entry and exit, as) + string(well as any exceptions that are raised inside the method.) string(
)
-        string(registry.register() symbol(:foo) string(\)) operator({) string(...) operator(})
-        string(registry.intercept() symbol(:foo) string(\).with) operator({) string(|r|) string(r.logging_interceptor) operator(})
+        string(registry.register( :foo \) { ... })
+        string(registry.intercept( :foo \).with { |r| r.logging_interceptor })
 
         string(foo.something)
-        string(foo.another_method() string(1,) string(2,) string(3) string(\))
+        string(foo.another_method( 1, 2, 3 \))
       string(
) - string(See) string(the) string(chapter) string(in) string(the) keysymbol(:http)error(:)string(//needle.rubyforge.org) string(about) - string(logging) string(for) string(more) string(information) string(on) string(how) string(to) string(use) string(and) string(configure) string(loggers.) + string(See the chapter in the "User's Manual":http://needle.rubyforge.org about) + string(logging for more information on how to use and configure loggers.) operator(-) keyoperator(:) string(>-) - string(Only) string(interceptors) string(that) string(explicitly) string(support) string(exclusion) string(of) string(methods) string(can) string(help) - string(you) string(here.) string(Fortunately,) string(the) string(LoggingInterceptor) string(is) string(one) string(of) string(them.) string((If) string(you) - string(write) string(your) string(own) string(interceptor) string(and) string(would) string(like) string(similar) string(functionality,) string(see) string(the) - string(IncludeExclude) string(module.\)) + string(Only interceptors that explicitly support exclusion of methods can help) + string(you here. Fortunately, the LoggingInterceptor is one of them. (If you) + string(write your own interceptor and would like similar functionality, see the) + string(IncludeExclude module.\)) - string(In) string(the) string(case) string(of) string(the) string(LoggingInterceptor,) string(just) string(pass) string(an) string(array) string(of) string(patterns) - string((matching) string(method) string(names) string(and/or) string(arities\)) string(as) string(the) string("exclude") string(option,) string(when) - string(declaring) string(the) key(interceptor)error(:) + string(In the case of the LoggingInterceptor, just pass an array of patterns) + string((matching method names and/or arities\) as the "exclude" option, when) + key(declaring the interceptor)operator(:) string(
)
-        string(registry.register() symbol(:foo) string(\)) operator({) string(...) operator(})
-        string(registry.intercept() symbol(:foo) string(\).)
-          string(with) operator({) string(|r|) string(r.logging_interceptor) operator(})string(.)
-          string(with_options) symbol(:exclude) string(=>) operator([) string('foo',) string('bar(>4\)',) string('*(<2\)') operator(])
+        string(registry.register( :foo \) { ... })
+        string(registry.intercept( :foo \).)
+          string(with { |r| r.logging_interceptor }.)
+          string(with_options :exclude => [ 'foo', 'bar(>4\)', '*(<2\)' ])
       string(
) - string(The) string(above) string(will) string(exclude) string(from) string(interception) string(any) string(method) string(named) string('foo',) string(or) string(any) - string(invocation) string(of) string('bar') string(with) string(more) string(than) string(4) string(arguments,) string(or) string(any) string(method) string(invocation) - string(with) string(fewer) string(than) string(two) string(arguments.) + string(The above will exclude from interception any method named 'foo', or any) + string(invocation of 'bar' with more than 4 arguments, or any method invocation) + string(with fewer than two arguments.) - string(You) string(can) string(also) string(give) string(an) string(array) string(of) string(patterns) string(to) string(_include_.) string(These) string(cause) string(methods) - string(to) string(be) string(explicitly) string(intercepted) string(even) string(if) string(they) string(match) string(an) string(exclude) key(pattern)error(:) + string(You can also give an array of patterns to _include_. These cause methods) + key(to be explicitly intercepted even if they match an exclude pattern)operator(:) string(
)
-        string(registry.register() symbol(:foo) string(\)) operator({) string(...) operator(})
-        string(registry.intercept() symbol(:foo) string(\).)
-          string(with) operator({) string(|r|) string(r.logging_interceptor) operator(})string(.)
-          string(with_options) symbol(:exclude) string(=>) operator([) string('foo',) string('bar(>4\)',) string('*(<2\)') operator(])operator(,)
-                       symbol(:include) string(=>) operator([) string('baz') operator(])
+        string(registry.register( :foo \) { ... })
+        string(registry.intercept( :foo \).)
+          string(with { |r| r.logging_interceptor }.)
+          string(with_options :exclude => [ 'foo', 'bar(>4\)', '*(<2\)' ],)
+                       symbol(:include) string(=> [ 'baz' ])
 
-        string(foo) string(=) string(registry.foo)
+        string(foo = registry.foo)
         string(foo.baz)
       string(
) - string(This) string(would) string(result) string(in) string(the) string(call) string(to) comment(#baz being intercepted, even though it) - string(matches) string(an) string(exclude) string(pattern) string((@*(<2\)@\).) + string(This would result in the call to #baz being intercepted, even though it) + string(matches an exclude pattern (@*(<2\)@\).) operator(-) keyoperator(:) string(>-) - string(This) string(requires) string(that) string(the) string(other) string(library) string(be) string(implemented) string(in) string(such) string(a) string(way) string(that) string(it) - string(expects) string(to) string(be) string("included") string(by) string(other) string(libraries/applications.) string(For) string(example,) - string(Needle) string(encourages) string(the) string(use) string(of) string(a) string(method) string(called) string(@register_services@,) string(which) - string(accepts) string(a) string(container) string(as) string(a) key(parameter)error(:) + string(This requires that the other library be implemented in such a way that it) + string(expects to be "included" by other libraries/applications. For example,) + string(Needle encourages the use of a method called @register_services@, which) + key(accepts a container as a parameter)operator(:) string(
)
-        string(module) string(A)
-          string(module) string(B)
-            string(def) string(register_services() string(container) string(\))
+        string(module A)
+          string(module B)
+            string(def register_services( container \))
               string(...)
             string(end)
-            string(module_function) symbol(:register_services)
+            string(module_function :register_services)
           string(end)
         string(end)
       string(
) - string(If) string(the) string(library) string(has) string(been) string(implemented) string(in) string(this) string(way,) string(you) string(can) string(simply) string(do) string(a) - string(require) string(of) string(the) string(library) string(and) string(then) string(invoke) string(the) string(@register_services@) string(method.) + string(If the library has been implemented in this way, you can simply do a) + string(require of the library and then invoke the @register_services@ method.) - string(There) string(is) string(a) string(convenience) string(method) string(in) string(Container) string(for) string(doing) string(this.) string(Just) string(call) - string(Container#require,) string(passing) string(the) string(file) string(to) string(require) string(and) string(a) string(string) string((or) string(symbol\)) - string(identifying) string(the) string(name) string(of) string(the) string(module) string(that) string(contains) string(the) string(registration) string(method.) - string(You) string(can) string(also) string(pass) string(a) string(symbol) string(as) string(the) string(third) string(parameter) string(naming) string(the) string(registration) - string(method,) string(but) string(it) string(defaults) string(to) string(@)symbol(:register_services)string(@.) + string(There is a convenience method in Container for doing this. Just call) + string(Container#require, passing the file to require and a string (or symbol\)) + string(identifying the name of the module that contains the registration method.) + string(You can also pass a symbol as the third parameter naming the registration) + string(method, but it defaults to @:register_services@.) string(
)
-        string(require) string('a/b')
-        key(A)error(:)symbol(:B)string(.register_services() string(container) string(\))
+        string(require 'a/b')
+        string(A::B.register_services( container \))
 
         comment(# or)
 
-        string(container.require() string('a/b',) string("A)error(:)symbol(:B)string(") string(\))
+        string(container.require( 'a/b', "A::B" \))
       string(
) - string(The) string(definition) string(context) string((i.e.,) string(the) string("builder") string(object\)) string(also) string(supports) string(the) - string(require) string(method,) string(so) string(you) string(can) key(do)error(:) + string(The definition context (i.e., the "builder" object\) also supports the) + string(require method, so you can do:) string(
)
-        string(container.define) string(do) string(|b|)
-          string(b.require) string("a/b",) string("A)error(:)symbol(:B)string(")
-          string(b.foo) operator({) string(...) operator(})
+        string(container.define do |b|)
+          string(b.require "a/b", "A::B")
+          string(b.foo { ... })
           string(...)
         string(end)
       string(
) -operator(-) keyerror(:) - operator(-) keyerror(:) +operator(-) keyoperator(:) + operator(-) keyoperator(:) operator(-) keyoperator(:) string(>-) - string(The) string(prototype) string(service) string(model) string(is) string(appropriate) string(when) string(the) key(service)error(:) + key(The prototype service model is appropriate when the service)operator(:) - string(*) string(has) string(internal) string(state) + string(* has internal state) - string(*) string(will) string(be) string(used) string(multiple) string(times) string(for) string(different) string(situations) + string(* will be used multiple times for different situations) - string(For) string(example,) string(if) string(you) string(have) string(a) string(GUI) string(library,) string(a) string("button") string(service) string(could) string(be) string(a) - string(prototype,) string(because) string(you) string(will) string(likely) string(have) string(many) string(buttons) string(in) string(an) string(application,) - string(with) string(each) string(button) string(being) string(an) string(independent) string(instance.) + string(For example, if you have a GUI library, a "button" service could be a) + string(prototype, because you will likely have many buttons in an application,) + string(with each button being an independent instance.) operator(-) keyoperator(:) string(>-) - string(The) string(singleton) string(service) string(model) string(is) string(the) string(default,) string(so) string(you) string(should) string(rarely) string(need) - string(to) string(explicitly) string(specify) string(it) string(as) string(a) string(model.) string(It) string(is) string(appropriate) string(for) string(services) - key(that)error(:) + string(The singleton service model is the default, so you should rarely need) + string(to explicitly specify it as a model. It is appropriate for services) + key(that)operator(:) - string(*) string(guard) string(some) string(specific) string(functionality) + string(* guard some specific functionality) - string(*) string(represent) string(state) string(that) string(is) string(global) string(across) string(an) string(application) + string(* represent state that is global across an application) operator(-) keyoperator(:) string(>-) - string(Threaded) string(is) string(similar) string(to) string(singleton,) string(but) string(it) string(allows) string(one) string(unique) string(instance) string(of) - string(the) string(service) string(_per) string(thread_.) string(Thus,) string(it) string(is) string(appropriate) string(to) string(the) string(same) - string(situations) string(as) string(singleton,) string(but) string(specific) string(to) string(a) string(thread,) string(instead) string(of) string(an) - string(application.) string(This) string(is) string(useful) string(for) string(web) string(applications) string(that) string(are) string(run) string(in) string(a) - string(single) string(virtual) string(machine,) string(and) string(which) string(share) string(a) string(single) string(registry.) + string(Threaded is similar to singleton, but it allows one unique instance of) + string(the service _per thread_. Thus, it is appropriate to the same) + string(situations as singleton, but specific to a thread, instead of an) + string(application. This is useful for web applications that are run in a) + string(single virtual machine, and which share a single registry.) operator(-) keyoperator(:) string(>-) - string(Deferred) string(models) string(use) string(a) string(proxy) string(to) string(enforce) string(lazy) string(initialization) string(of) string(the) - string(service.) string(A) string(service) string(using) string(a) string(deferred) string(service) string(model) string((ie,) - string(@)symbol(:prototype_deferred)string(@,) string(@)symbol(:multiton_deferred)string(@,) string(@)symbol(:singleton_deferred)string(@,) string(or) - string(@)symbol(:threaded_deferred)string(@\)) string(will) string(not) string(be) string(instantiated) string(until) string(the) string(first) string(time) string(a) - string(method) string(is) string(invoked) string(on) string(the) string(service.) + string(Deferred models use a proxy to enforce lazy initialization of the) + string(service. A service using a deferred service model (ie,) + string(@:prototype_deferred@, @:multiton_deferred@, @:singleton_deferred@, or) + string(@:threaded_deferred@\) will not be instantiated until the first time a) + string(method is invoked on the service.) - string(This) string(makes) string(a) string(deferred) string(model) string(appropriate) string(when) string(a) string(service) string(is) string(expensive) string(to) - string(instantiate,) string(since) string(you) string(can) string(wait) string(to) string(do) string(the) string(expensive) string(initialization) - string(until) string(it) string(is) string(really) string(needed.) string(Applications) string(will) string(start) string(up) string(faster) string(when) string(their) - string(dependences) string(use) string(deferred) string(instantiation.) + string(This makes a deferred model appropriate when a service is expensive to) + string(instantiate, since you can wait to do the expensive initialization) + string(until it is really needed. Applications will start up faster when their) + string(dependences use deferred instantiation.) operator(-) keyoperator(:) string(>-) - string(This) string(is) string(useful) string(when) string(you) string(have) string(a) string(method) string(that) string(you) string(want) string(to) string(be) string(invoked) - string(automatically) string(after) string(a) string(service) string(has) string(been) string(instantiated.) string(Consider) string(the) string(case) - string(where) string(a) string(service) string(is) string(initialized) string(primarily) string(using) string(setters,) string(but) string(requires) - string(some) string(logic) string(to) string(be) string(executed) string(to) string(complete) string(the) string(initialization) string(phase.) string(In) string(this) - string(case,) string(you) string(could) string(always) string(explicitly) string(invoke) string(the) string(initialization) string(method(s\)) - string(in) string(the) string(constructor) string(block,) string(but) string(if) string(many) string(services) string(use) string(the) string(same) - string(initialization) string(method,) string(it) string(can) string(be) string(more) string(convenient) string(to) string(use) string(an) string("initialize") - string(service) string(model.) + string(This is useful when you have a method that you want to be invoked) + string(automatically after a service has been instantiated. Consider the case) + string(where a service is initialized primarily using setters, but requires) + string(some logic to be executed to complete the initialization phase. In this) + string(case, you could always explicitly invoke the initialization method(s\)) + string(in the constructor block, but if many services use the same) + string(initialization method, it can be more convenient to use an "initialize") + string(service model.) operator(-) keyoperator(:) string(>-) - string(Multitons) string(are) string(useful) string(for) string(factories,) string(where) string(you) string(have) string(a) string(class) string(that) - string(differentiates) string(its) string(instances) string(based) string(on) string(some) string(construction) string(parameters) string(that) - string(need) string(to) string(be) string(determined) string(at) string(runtime.) string(Thus,) string(multitons) string(are) string(always) string(used) string(with) - string(parameterized) string(services.) + string(Multitons are useful for factories, where you have a class that) + string(differentiates its instances based on some construction parameters that) + string(need to be determined at runtime. Thus, multitons are always used with) + string(parameterized services.) diff --git a/test/scanners/yaml/gemspec.expected.raydebug b/test/scanners/yaml/gemspec.expected.raydebug index 11cf53f..ec76cf9 100644 --- a/test/scanners/yaml/gemspec.expected.raydebug +++ b/test/scanners/yaml/gemspec.expected.raydebug @@ -1,4 +1,4 @@ -tag(---) type(!ruby/object)operator(:)class(Gem::Specification) +head type(!ruby/object)operator(:)class(Gem::Specification) key(name)operator(:) string(coderay) key(version)operator(:) type(!ruby/object)operator(:)class(Gem::Version) key(version)operator(:) string(0.7.9.257) @@ -13,7 +13,7 @@ key(date)operator(:) string(2008-09-24 00:00:00 +02:00) key(default_executable)operator(:) key(dependencies)operator(:) string([]) -key(description)operator(:) string("CodeRay is a Ruby library for syntax highlighting. I try to make CodeRay easy to use and intuitive, but at the same time fully featured, complete, fast and efficient. Usage is simple: require 'coderay' code = 'some %q(weird (Ruby\) can't shock\) me!' puts CodeRay.scan(code, :ruby\).html") +key(description)operator(:) string key(email)operator(:) string(murphy@cYcnus.de) key(executables)operator(:) operator(-) string(coderay) @@ -84,20 +84,20 @@ key(rdoc_options)operator(:) operator(-) string(-SNw2) operator(-) string(-mREADME) operator(-) string(-a) -operator(-) string(-t) string(CodeRay) string(Documentation) +operator(-) string(-t CodeRay Documentation) key(require_paths)operator(:) operator(-) string(lib) key(required_ruby_version)operator(:) type(!ruby/object)operator(:)class(Gem::Requirement) key(requirements)operator(:) - operator(-) operator(-) string(">=") + operator(-) string(- ">=") operator(-) type(!ruby/object)operator(:)class(Gem::Version) key(version)operator(:) string(1.8.2) key(version)operator(:) key(required_rubygems_version)operator(:) type(!ruby/object)operator(:)class(Gem::Requirement) key(requirements)operator(:) - operator(-) operator(-) string(">=") + operator(-) string(- ">=") operator(-) type(!ruby/object)operator(:)class(Gem::Version) - key(version)operator(:) string("0") + key(version)operator(:) string key(version)operator(:) key(requirements)operator(:) operator(-) string(strscan) diff --git a/test/scanners/yaml/latex_entities.expected.raydebug b/test/scanners/yaml/latex_entities.expected.raydebug index 9e4ffd2..5533c54 100644 --- a/test/scanners/yaml/latex_entities.expected.raydebug +++ b/test/scanners/yaml/latex_entities.expected.raydebug @@ -1,6 +1,6 @@ comment(# based on "SGML/XML character entity reference" at http://www.bitjungle.com/isoent/) comment(#) -tag(---) +head comment(#EM SPACE) key(emsp)operator(:) string(\\hspace{1em}) comment(#EM SPACE) @@ -32,7 +32,7 @@ key(ndash)operator(:) string(--) comment(#EN DASH) keyoperator(:) string(--) comment(#HYPHEN) -keyoperator(:) string("-") +keyoperator(:) string comment(#OPEN BOX) keyoperator(:) string(\\textvisiblespace{}) comment(#HORIZONTAL ELLIPSIS) @@ -58,7 +58,7 @@ keyoperator(:) string(\\sfrac{1}{6}) comment(#VULGAR FRACTION FIVE SIXTHS) keyoperator(:) string(\\sfrac{5}{6}) comment(#CARE OF) -keyoperator(:) string("{^c\\\\!/\\\\!_o}") +keyoperator(:) string comment(#FULL BLOCK) keyoperator(:) string(\\block{}) comment(#UPPER HALF BLOCK) @@ -174,10 +174,10 @@ comment(#CARET) keyoperator(:) string(\\mathchar"1356) comment(#SINGLE LOW-9 QUOTATION MARK) comment(#requires fontenc:T1) -key(lsquor)operator(:) string(",") +key(lsquor)operator(:) string comment(#SINGLE LOW-9 QUOTATION MARK) comment(#requires fontenc:T1) -keyoperator(:) string(",") +keyoperator(:) string comment(#DOUBLE LOW-9 QUOTATION MARK) comment(#requires fontenc:T1) key(ldquor)operator(:) string(,,) @@ -283,7 +283,7 @@ key(lt)operator(:) string(\\textless{}) comment(#LESS-THAN SIGN) keyoperator(:) string(\\textless{}) comment(#EQUALS SIGN) -keyoperator(:) string("=") +keyoperator(:) string comment(#GREATER-THAN SIGN) key(gt)operator(:) string(\\textgreater{}) comment(#GREATER-THAN SIGN) @@ -335,13 +335,13 @@ keyoperator(:) string(\\&) comment(#ASTERISK) keyoperator(:) string(\\ast{}) comment(#COMMERCIAL AT) -keyoperator(:) string("@") +keyoperator(:) string comment(#LEFT SQUARE BRACKET) -keyoperator(:) string("[") +keyoperator(:) string comment(#REVERSE SOLIDUS) keyoperator(:) string(\\textbackslash{}) comment(#RIGHT SQUARE BRACKET) -keyoperator(:) string("]") +keyoperator(:) string comment(#LEFT CURLY BRACKET) keyoperator(:) string(\\{) comment(#HORIZONTAL BAR) @@ -451,40 +451,40 @@ comment(#EIGHTH NOTE) comment(#requires wasysym) keyoperator(:) string(\\textmusicalnote{}) comment(#EXCLAMATION MARK) -keyoperator(:) string("!") +keyoperator(:) string comment(#INVERTED EXCLAMATION MARK) -key(iexcl)operator(:) string("!`") +key(iexcl)operator(:) string comment(#INVERTED EXCLAMATION MARK) -keyoperator(:) string("!`") +keyoperator(:) string comment(#QUOTATION MARK) comment(#requires fontenc:T1) -key(quot)operator(:) string("\\"") +key(quot)operator(:) string comment(#QUOTATION MARK) comment(#requires fontenc:T1) -keyoperator(:) string("\\"") +keyoperator(:) string comment(#APOSTROPHE) comment(#requires textcomp) -keyoperator(:) string("'") +keyoperator(:) string comment(#LEFT PARENTHESIS) keyoperator(:) string(() comment(#RIGHT PARENTHESIS) keyoperator(:) string(\)) comment(#COMMA) -keyoperator(:) string(",") +keyoperator(:) string comment(#LOW LINE) keyoperator(:) string(\\_) comment(#HYPHEN-MINUS) -keyoperator(:) string("-") +keyoperator(:) string comment(#FULL STOP) keyoperator(:) string(.) comment(#SOLIDUS) keyoperator(:) string(/) comment(#COLON) -keyoperator(:) string(":") +keyoperator(:) string comment(#SEMICOLON) keyoperator(:) string(;) comment(#QUESTION MARK) -keyoperator(:) string("?") +keyoperator(:) string comment(#INVERTED QUESTION MARK) key(iquest)operator(:) string(?`) comment(#INVERTED QUESTION MARK) @@ -506,21 +506,21 @@ key(lsquo)operator(:) string(`) comment(#LEFT SINGLE QUOTATION MARK) keyoperator(:) string(`) comment(#RIGHT SINGLE QUOTATION MARK) -key(rsquo)operator(:) string("'") +key(rsquo)operator(:) string comment(#RIGHT SINGLE QUOTATION MARK) -keyoperator(:) string("'") +keyoperator(:) string comment(#LEFT DOUBLE QUOTATION MARK) key(ldquo)operator(:) string(``) comment(#LEFT DOUBLE QUOTATION MARK) keyoperator(:) string(``) comment(#RIGHT DOUBLE QUOTATION MARK) -key(rdquo)operator(:) string("''") +key(rdquo)operator(:) string comment(#RIGHT DOUBLE QUOTATION MARK) -keyoperator(:) string("''") +keyoperator(:) string comment(#NO-BREAK SPACE) -key(nbsp)operator(:) string("~") +key(nbsp)operator(:) string comment(#NO-BREAK SPACE) -keyoperator(:) string("~") +keyoperator(:) string comment(#SOFT HYPHEN) key(shy)operator(:) string(\\-) comment(#SOFT HYPHEN) @@ -732,9 +732,9 @@ key(prime)operator(:) string(^\\prime) comment(#PRIME) keyoperator(:) string(^\\prime) comment(#DOUBLE PRIME) -key(Prime)operator(:) string("{''}") +key(Prime)operator(:) string comment(#DOUBLE PRIME) -keyoperator(:) string("{''}") +keyoperator(:) string comment(#PROPORTIONAL TO) key(prop)operator(:) string(\\propto{}) comment(#PROPORTIONAL TO) @@ -822,7 +822,7 @@ keyoperator(:) string(M) comment(#COMBINING THREE DOTS ABOVE) keyoperator(:) string(\\ddot{}\\kern 3pt\\dot{ }) comment(#TRIPLE PRIME) -keyoperator(:) string("{'''}") +keyoperator(:) string comment(#ESTIMATES) keyoperator(:) string(\\stackrel{\\wedge}{=}) comment(#GREEK SMALL LETTER ALPHA) @@ -1309,7 +1309,7 @@ comment(#RING EQUAL TO) comment(#requires amssymb) keyoperator(:) string(\\circeq{}) comment(#COLON EQUALS) -keyoperator(:) string(":=") +keyoperator(:) string comment(#EQUAL TO OR PRECEDES) comment(#requires amssymb) keyoperator(:) string(\\curlyeqprec{}) @@ -1325,7 +1325,7 @@ comment(#RING IN EQUAL TO) comment(#requires amssymb) keyoperator(:) string(\\eqcirc{}) comment(#EQUALS COLON) -keyoperator(:) string("=:") +keyoperator(:) string comment(#GEOMETRICALLY EQUAL TO) comment(#requires amssymb) keyoperator(:) string(\\doteqdot{}) @@ -2393,7 +2393,7 @@ comment(#INVERTED OHM SIGN) comment(#requires amssymb) keyoperator(:) string(\\textmho{}) comment(#PROPORTION) -keyoperator(:) string("::") +keyoperator(:) string comment(#LEFT WHITE SQUARE BRACKET) comment(#requires stmaryrd) keyoperator(:) string(\\textlbrackdbl{}) diff --git a/test/scanners/yaml/threshold.expected.raydebug b/test/scanners/yaml/threshold.expected.raydebug index 8d3c8f5..55a33e4 100644 --- a/test/scanners/yaml/threshold.expected.raydebug +++ b/test/scanners/yaml/threshold.expected.raydebug @@ -1,582 +1,582 @@ -tag(---) comment(# From http://thresholdstate.com/articles/4312/the-textile-reference-manual) +head comment(# From http://thresholdstate.com/articles/4312/the-textile-reference-manual) key(name)operator(:) string(paragraph) key(desc)operator(:) string(Paragraphs are separated by blank lines. Each paragraph of text is transformed into a XHTML

paragraph block.) key(in)operator(:) string(|-) - string(A) string(paragraph.) + string(A paragraph.) - string(Another) string(paragraph.) + string(Another paragraph.) key(html)operator(:) string(|-) - string(

A) string(paragraph.

) - string(

Another) string(paragraph.

) -tag(---) + string(

A paragraph.

) + string(

Another paragraph.

) +head key(name)operator(:) string(line breaks) key(desc)operator(:) string(Line breaks within paragraphs are transformed into XHTML line breaks.) key(in)operator(:) string(|-) - string(A) string(paragraph) string(with) - string(a) string(line) string(break.) + string(A paragraph with) + string(a line break.) key(html)operator(:) string(|-) - string(

A) string(paragraph) string(with) - string(a) string(line) string(break.

) -tag(---) + string(

A paragraph with
) + string(a line break.

) +head key(name)operator(:) string(xhtml tags) key(desc)operator(:) string(Simple XHTML tags may be included in a paragraph.) key(in)operator(:) string(Here's some bold text.) key(html)operator(:) string(

Here’s some bold text.

) -tag(---) +head key(name)operator(:) string(no paragraph tags) key(desc)operator(:) string(A line beginning with a space will be left untouched, and not wrapped in

tags.) -key(in)operator(:) string(" No paragraph tags here.") -key(html)operator(:) string("No paragraph tags here.") +key(in)operator(:) string +key(html)operator(:) string key(valid_html)operator(:) string(false) -tag(---) +head key(name)operator(:) string(smart quotes) key(desc)operator(:) string(Single and double typewriter quotation marks ' and " are transformed into typographically correct “curly” quote marks.) key(in)operator(:) string('"Proceed!" said he to the host.') key(html)operator(:) string('

“Proceed!” said he to the host.

') -tag(---) +head key(name)operator(:) string(smart quotes 2) -key(in)operator(:) string("'Proceed!' said he to the host.") -key(html)operator(:) string("

‘Proceed!’ said he to the host.

") -tag(---) +key(in)operator(:) string +key(html)operator(:) string‘Proceed!’ said he to the host.

)delimiter(")> +head key(name)operator(:) string(nested quotation marks) key(desc)operator(:) string(Single and double quotation marks may be nested one inside the other.) key(in)operator(:) string(|-) - string("'I) string(swear,) string(captain,') string(replied) string(I.") + string("'I swear, captain,' replied I.") key(html)operator(:) string(|-) - string(

“‘I) string(swear,) string(captain,’) string(replied) string(I.”

) -tag(---) + string(

“‘I swear, captain,’ replied I.”

) +head key(name)operator(:) string(nested quotation marks 2) key(in)operator(:) string(|-) - string('"I) string(swear,) string(captain,") string(replied) string(I.') + string('"I swear, captain," replied I.') key(html)operator(:) string(|-) - string(

‘“I) string(swear,) string(captain,”) string(replied) string(I.’

) -tag(---) + string(

‘“I swear, captain,” replied I.’

) +head key(name)operator(:) string(apostrophe glyphs) key(desc)operator(:) string(Single quotation marks ' will be turned into apostrophe glyphs when used as such.) key(in)operator(:) string(Greengrocers' apostrophe's.) key(html)operator(:) string(

Greengrocers’ apostrophe’s.

) -tag(---) +head key(name)operator(:) string(em-dash glyphs) key(desc)operator(:) string(Double -- dashes become an em-dash glyph.) key(in)operator(:) string(You know the Italian proverb -- Chi ha compagno ha padrone.) key(html)operator(:) string(

You know the Italian proverb — Chi ha compagno ha padrone.

) -tag(---) +head key(name)operator(:) string(em-dash glyphs 2) key(in)operator(:) string(You know the Italian proverb--Chi ha compagno ha padrone.) key(html)operator(:) string(

You know the Italian proverb—Chi ha compagno ha padrone.

) -tag(---) +head key(name)operator(:) string(en-dash glyphs) key(desc)operator(:) string(Single - dashes are replaced with en-dashes.) key(in)operator(:) string(You know the Italian proverb - Chi ha compagno ha padrone.) key(html)operator(:) string(

You know the Italian proverb – Chi ha compagno ha padrone.

) -tag(---) +head key(name)operator(:) string(ellipsis character) key(desc)operator(:) string(Three period marks become an ellipsis character.) key(in)operator(:) string(Meanwhile...) key(html)operator(:) string(

Meanwhile…

) -tag(---) +head key(name)operator(:) string(dimension character) key(desc)operator(:) string(An “x” is replaced with the dimension character when used between numbers.) key(in)operator(:) string(1 x 2 x 3 = 6) key(html)operator(:) string(

1 × 2 × 3 = 6

) -tag(---) +head key(name)operator(:) string(dimension character 2) key(in)operator(:) string(1x2x3 = 6) key(html)operator(:) string(

1×2×3 = 6

) -tag(---) +head key(name)operator(:) string(trademark register copyright) key(desc)operator(:) string(Trademark, Registered and Copyright symbols are represented by their common plain text equivalents.) key(in)operator(:) string(Registered(r\) Trademark(tm\) Copyright (c\).) key(html)operator(:) string(

Registered® Trademark™ Copyright ©.

) -tag(---) +head key(name)operator(:) string(acronyms) key(desc)operator(:) string(Acronyms consist of three or more uppercase characters, followed immediately by words in parentheses.) key(in)operator(:) string(ABC(Always Be Closing\)) key(html)operator(:) string(

ABC

) key(no_span_caps_html)operator(:) string(

ABC

) -tag(---) +head key(name)operator(:) string(uppercase) key(desc)operator(:) string(Uppercase words of three or more characters are enclosed with a special span element.) key(in)operator(:) string(IBM or HAL) key(html)operator(:) string(

IBM or HAL

) key(no_span_caps_html)operator(:) string(

IBM or HAL

) -tag(---) +head key(name)operator(:) string(emphasis) key(desc)operator(:) string(Emphasis is added with _ underscores.) key(in)operator(:) string(The _underlying_ cause.) key(html)operator(:) string(

The underlying cause.

) -tag(---) +head key(name)operator(:) string(strong text) key(desc)operator(:) string(Strong text is indicated by * asterisks.) key(in)operator(:) string(The *underlying* cause.) key(html)operator(:) string(

The underlying cause.

) -tag(---) +head key(name)operator(:) string(italic text) key(desc)operator(:) string(em is a semantic tag, usually represented by browsers as italic text. To produce italic tags instead, use double underscores.) key(in)operator(:) string(The __underlying__ cause.) key(html)operator(:) string(

The underlying cause.

) -tag(---) +head key(name)operator(:) string(bold text) key(desc)operator(:) string(strong is a semantic tag, usually represented by browsers as bold text. To produce bold tags instead, use double asterisks.) key(in)operator(:) string(The **underlying** cause.) key(html)operator(:) string(

The underlying cause.

) -tag(---) +head key(name)operator(:) string(citation) key(desc)operator(:) string(Double question marks represent a citation, like the title of a book.) key(in)operator(:) string(??The Count of Monte Cristo??, by Dumas.) key(html)operator(:) string(

The Count of Monte Cristo, by Dumas.

) -tag(---) +head key(name)operator(:) string(inserted and deleted text) key(desc)operator(:) string(Inserted and deleted text is represented by + plus and - minus symbols.) key(in)operator(:) string(Scratch -that-, replace with +this+.) key(html)operator(:) string(

Scratch that, replace with this.

) -tag(---) +head key(name)operator(:) string(subscript) key(desc)operator(:) string(Subscript text is indicated by ~ tilde characters.) key(in)operator(:) string(log ~2~ n) key(html)operator(:) string(

log 2 n

) -tag(---) +head key(name)operator(:) string(superscript) key(desc)operator(:) string(Superscript text is indicated by ^ caret characters.) key(in)operator(:) string(2 ^x^) key(html)operator(:) string(

2 x

) -tag(---) +head key(name)operator(:) string(span tag) key(desc)operator(:) string(Percentage marks will enclose text with a XHTML span tag.) key(in)operator(:) string(The %underlying% cause.) key(html)operator(:) string(

The underlying cause.

) -tag(---) +head key(name)operator(:) string(code) key(desc)operator(:) string(To include a short snippet of code such as XHTML or Javascript, surround it with @ “at” symbols. XHTML significant characters within a code phrase will be escaped for display to the reader.) key(in)operator(:) string(About the @
@ tag.) key(html)operator(:) string(

About the <hr /> tag.

) -tag(---) +head key(name)operator(:) string(links) key(desc)operator(:) string(Links are represented by double quotes and a colon.) key(in)operator(:) string('"link text":http://example.com/') key(html)operator(:) string(

link text

) -tag(---) +head key(name)operator(:) string(local links) key(desc)operator(:) string(The host name may be ommitted for local links.) key(in)operator(:) string('"link text":/example') key(html)operator(:) string(

link text

) -tag(---) +head key(name)operator(:) string(link title) key(desc)operator(:) string(A title may be placed in (\) parentheses.) key(in)operator(:) string('"link text(with title\)":http://example.com/') key(html)operator(:) string(

link text

) -tag(---) +head key(name)operator(:) string(link alias) key(desc)operator(:) string(For frequent linking to a single URL, you can specify a link alias with [] square brackets.) key(in)operator(:) string(|-) - string(Here's) keysymbol(:tstate)operator(,) string(and) - keysymbol(:tstate) string(to) string(the) string(same) string(site.) + string(Here's "a link":tstate, and) + string("another link":tstate to the same site.) - operator([)string(tstate]http)error(:)string(//thresholdstate.com/) + operator([)string(tstate]http://thresholdstate.com/) key(html)operator(:) string(|-) - string(

Here’s) string(a) string(link,) string(and) - string(another) string(link) string(to) string(the) string(same) string(site.

) -tag(---) + string(

Here’s a link, and
) + string(another link to the same site.

) +head key(name)operator(:) string(image) key(desc)operator(:) string(Use ! exclamation marks to insert an image tag.) -key(in)operator(:) string("!/img.gif!") +key(in)operator(:) string key(html)operator(:) string(

) -tag(---) +head key(name)operator(:) string(image 2) -key(in)operator(:) string("!http://thresholdstate.com/img.gif!") +key(in)operator(:) string key(html)operator(:) string(

) -tag(---) +head key(name)operator(:) string(image alt) key(desc)operator(:) string(Use (\) parentheses to include “alt” text.) -key(in)operator(:) string("!/img.gif(alt text\)!") +key(in)operator(:) string key(html)operator(:) string(

alt text

) -tag(---) +head key(name)operator(:) string(image links) key(desc)operator(:) string(Images may be combined with links by using an !image! in place of the link text.) -key(in)operator(:) string("!/img.gif!:http://textpattern.com/") +key(in)operator(:) string key(html)operator(:) string(

) -tag(---) +head key(name)operator(:) string(headers) key(desc)operator(:) string(Headers are represented by h1., h2., … h6..) key(in)operator(:) string(h1. Heading 1) key(html)operator(:) string(

Heading 1

) -tag(---) +head key(name)operator(:) string(headers 2) key(in)operator(:) string(h2. Heading 2) key(html)operator(:) string(

Heading 2

) -tag(---) +head key(name)operator(:) string(headers 3) key(in)operator(:) string(h6. Heading 6) key(html)operator(:) string(
Heading 6
) -tag(---) +head key(name)operator(:) string(paragraph text) -key(desc)operator(:) string("Paragraph p text is represented by p.. This is the default block type: any paragraph without a block modifier will automatically be enclosed with p tags.") +key(desc)operator(:) string key(in)operator(:) string(|-) - string(p.) string(A) string(paragraph.) + string(p. A paragraph.) string(Continued.) - string(Also) string(a) string(paragraph.) + string(Also a paragraph.) key(html)operator(:) string(|-) - string(

A) string(paragraph.) + string(

A paragraph.
) string(Continued.

) - string(

Also) string(a) string(paragraph.

) -tag(---) + string(

Also a paragraph.

) +head key(name)operator(:) string(block quote) key(desc)operator(:) string(bq. indicates a quoted block of text.) key(in)operator(:) string(|-) - string(bq.) string(A) string(quotation.) + string(bq. A quotation.) string(Continued.) - string(Regular) string(paragraph.) + string(Regular paragraph.) key(html)operator(:) string(|-) string(
) - string(

A) string(quotation.) + string(

A quotation.
) string(Continued.

) string(
) - string(

Regular) string(paragraph.

) -tag(---) + string(

Regular paragraph.

) +head key(name)operator(:) string(block quote citation) key(desc)operator(:) string(Block quotes may include a citation URL immediately following the period.) key(in)operator(:) string(bq.:http://thresholdstate.com/ A cited quotation.) key(html)operator(:) string(|-) - string() - string(

A) string(cited) string(quotation.

) + string(
) + string(

A cited quotation.

) string(
) -tag(---) +head key(name)operator(:) string(footnotes) key(desc)operator(:) string(Footnotes are represented by the fn1., fn2., … block modifiers.) key(in)operator(:) string(|-) - string(A) string(footnote) string(reference[1].) + string(A footnote reference[1].) - string(fn1.) string(The) string(footnote.) + string(fn1. The footnote.) key(html)operator(:) string(|-) - string(

A) string(footnote) string(reference1.

) - string(1) string(The) string(footnote.

) + string(

A footnote reference1.

) + string(

1 The footnote.

) comment(# html: |-) comment(#

A footnote reference1.

) comment(#

1 The footnote.

) -tag(---) +head key(name)operator(:) string(block code) key(desc)operator(:) string(Code such as XHTML, Javascript or PHP may be displayed using the bc. “block code” modifier. XHTML significant characters such as < and > will be escaped within code blocks – bc is used for displaying code to the reader, not for executing it.) key(note)operator(:) string(Note that Textile will interpret any blank lines within the code as indicating the end of the code block. See Extended Blocks below for an explanation of how to display longer blocks of code.) key(in)operator(:) string(|-) - string(bc.) string() key(html)operator(:) string(|-) string(
<script>)
-  string(//) string(a) string(Javascript) string(example)
-  string(alert("Hello) string(World"\);)
+  string(// a Javascript example)
+  string(alert("Hello World"\);)
   variable(</script>
) -tag(---) +head key(name)operator(:) string(preformatted text) key(desc)operator(:) string(Use the pre. block modifier for pre-formatted text. XHTML significant characters within the block will be escaped.) key(note)operator(:) string(pre. is almost identical to bc., with the exception that ... tags are not used within the 
 block.)
 key(in)operator(:) string(|-)
-  string(pre.) string(Pre-formatted)
+  string(pre. Pre-formatted)
   string(text)
 key(html)operator(:) string(|-)
   string(
Pre-formatted)
   string(text
)
-tag(---)
+head
 key(name)operator(:) string(notextile)
 key(desc)operator(:) string(The notextile. block modifier applies no Textile processing at all to a block. Raw XHTML characters are passed through untouched, so this may be used to insert explicit XHTML markup, or execute Javascript or PHP code.)
 key(in)operator(:) string(|-)
-  string(notextile.) string()
-  string(document.write("Hello) string(World!"\);)
+  string(notextile. )
-  string()
+  string()
 key(html)operator(:) string(|-)
-  string()
-  string(document.write("Hello) string(World!"\);)
+  string()
-  string()
+  string()
 key(valid_html)operator(:) string(false)
-tag(---)
+head
 key(name)operator(:) string(class attribute)
 key(desc)operator(:) string(CSS classes are specified with (\) parentheses.)
 key(in)operator(:) string(p(myclass\). My classy paragraph.)
 key(html)operator(:) string(
My classy paragraph.
)
-tag(---)
+head
 key(name)operator(:) string(id attribute)
 key(desc)operator(:) string(CSS IDs are specified with (\) parentheses.)
 key(in)operator(:) string(p(#myid\). My ID paragraph.)
 key(html)operator(:) string(
My ID paragraph.
)
-tag(---)
+head
 key(name)operator(:) string(style attribute)
 key(desc)operator(:) string(CSS styles are specified with {} braces.)
 key(in)operator(:) string(p{color:red}. Red rum.)
 key(html)operator(:) string(
Red rum.
)
-tag(---)
+head
 key(name)operator(:) string(lang attribute)
 key(desc)operator(:) string(Languages are specified with [] brackets.)
 key(in)operator(:) string(p[fr-fr]. En français.)
 key(html)operator(:) string(
En français.
)
-tag(---)
+head
 key(name)operator(:) string(phrase modifiers)
 key(desc)operator(:) string(The same syntax may be applied to phrase modifiers.)
 key(in)operator(:) string(A *(myclass\)classy* phrase.)
 key(html)operator(:) string(
A classy phrase.
)
-tag(---)
+head
 key(name)operator(:) string(phrase modifiers 2)
 key(in)operator(:) string(An _(#myid2\)ID_ phrase.)
 key(html)operator(:) string(
An ID phrase.
)
-tag(---)
+head
 key(name)operator(:) string(phrase modifiers 3)
 key(in)operator(:) string(The %{color:blue}blue% room.)
 key(html)operator(:) string(
The blue room.
)
-tag(---)
+head
 key(name)operator(:) string(block and phrase attributes combined)
 key(desc)operator(:) string(Block and phrase attributes may be combined.)
 key(in)operator(:) string(p(myclass#myid3\){color:green}[de-de]. A complex paragraph.)
 key(html)operator(:) string(
A complex paragraph.
)
-tag(---)
+head
 key(name)operator(:) string(block and phrase attributes combined 2)
 key(in)operator(:) string(A ??(myclass#myid4\){color:green}[de-de]complex?? phrase.)
 key(html)operator(:) string(
A complex phrase.
)
-tag(---)
+head
 key(name)operator(:) string(extended blocks)
 key(desc)operator(:) string(Normally a block modifier covers a single block of text, and ends at the first blank line. To extend a block over multiple paragraphs that include blank lines, use a block modifier with two period marks instead of one. To close the extended block, use a different block modifier on the next paragraph.)
 key(in)operator(:) string(|-)
-  string(bq..) string(A) string(quote.)
+  string(bq.. A quote.)
   
-  string(The) string(quote) string(continued.)
+  string(The quote continued.)
   
-  string(p.) string(Back) string(to) string(paragraph) string(text.)
+  string(p. Back to paragraph text.)
 key(html)operator(:) string(|-)
   string(
)
-  string(
A) string(quote.
)
-  string(
The) string(quote) string(continued.
)
+  string(
A quote.
)
+  string(
The quote continued.
)
   string(
)
-  string(
Back) string(to) string(paragraph) string(text.
)
-tag(---)
+  string(
Back to paragraph text.
)
+head
 key(name)operator(:) string(extended block code)
 key(desc)operator(:) string(Extended blocks are useful for displaying longer examples of code that contain blank lines.)
 key(in)operator(:) string(|-)
-  string(A) string(PHP) string(code) string(example.)
+  string(A PHP code example.)
   
-  string(bc..) string()
   
-  string(p.) string(Following) string(paragraph.)
+  string(p. Following paragraph.)
 key(html)operator(:) string(|-)
-  string(
A) string(PHP) string(code) string(example.
)
+  string(
A PHP code example.
)
   string(
<?php)
-  string(function) string(hello(\)) operator({)
-  string(//) string(display) string(a) string(hello) string(message)
+  string(function hello(\) {)
+  string(// display a hello message)
 
-  string(print) string("Hello,) string(World";)
+  string(print "Hello, World";)
   operator(})
   string(?>)
 
   string(
)
-  string(
Following) string(paragraph.
)
-tag(---)
+  string(
Following paragraph.
)
+head
 key(name)operator(:) string(extended block attributes)
 key(desc)operator(:) string(Any block attributes on an extended block will be included on each following block.)
 key(in)operator(:) string(|-)
-  string(p(myclass\)..) string(A) string(classy) string(paragraph.)
+  string(p(myclass\).. A classy paragraph.)
   
-  string(Another) string(classy) string(paragraph.)
+  string(Another classy paragraph.)
   
-  string(p.) string(Not) string(so) string(classy.)
+  string(p. Not so classy.)
 key(html)operator(:) string(|-)
-  string(A) string(classy) string(paragraph.
)
-  string(Another) string(classy) string(paragraph.
)
-  string(
Not) string(so) string(classy.
)
-tag(---)
+  string(
A classy paragraph.
)
+  string(
Another classy paragraph.
)
+  string(
Not so classy.
)
+head
 key(name)operator(:) string(extended block quote attributes)
 key(desc)operator(:) string(Attributes on bq.. extended blocks will be included on both the inner and outer blocks.)
 key(in)operator(:) string(|-)
-  string(bq(myclass\)..) string(Quote) string(paragraph) string(1.)
+  string(bq(myclass\).. Quote paragraph 1.)
 
-  string(Paragraph) string(2.)
+  string(Paragraph 2.)
 key(html)operator(:) string(|-)
-  string()
-  string(Quote) string(paragraph) string(1.
)
-  string(Paragraph) string(2.
)
+  string(
)
+  string(
Quote paragraph 1.
)
+  string(
Paragraph 2.
)
   string(
)
-tag(---)
+head
 key(name)operator(:) string(extended block code attributes)
 key(desc)operator(:) string(Attributes on bc.. extended blocks will be included on both the inner and outer blocks.)
 key(in)operator(:) string(|-)
-  string(bc(myclass\)..) string(Code) string(block) string(1.)
+  string(bc(myclass\).. Code block 1.)
   
-  string(Code) string(block) string(2.)
+  string(Code block 2.)
 key(html)operator(:) string(|-)
-  string(Code) string(block) string(1.)
+  string(
Code block 1.)
 
-  string(Code) string(block) string(2.
)
-tag(---)
+  string(Code block 2.
) +head key(name)operator(:) string(raw xhtml left in tact) key(desc)operator(:) string(Raw XHTML tags are generally left untouched by Textile. Span tags that enclose only part of a block of text will be left intact, while the block itself is treated normally.) key(in)operator(:) string(bold and italic, the hard way.) key(html)operator(:) string(

bold and italic, the hard way.

) -tag(---) +head key(name)operator(:) string(paragraphs entirely raw xhtml) key(desc)operator(:) string(Paragraphs that consist entirely of raw XHTML block tags will not be enclosed in

...

tags.) key(in)operator(:) string(
My div
) key(html)operator(:) string(
My div
) -tag(---) +head key(name)operator(:) string(paragraphs with inline xhtml) key(desc)operator(:) string(Paragraphs that consist only of inline XHTML tags, will be enclosed in

...

tags.) key(in)operator(:) string(image) key(html)operator(:) string(

image

) -tag(---) +head key(name)operator(:) string(paragraphs with inline xhtml 2) key(in)operator(:) string(I'll make my own way.) key(html)operator(:) string('

I’ll make my own way.

') -tag(---) +head key(name)operator(:) string(paragraphs partly enclosed in xhtml block tags) key(desc)operator(:) string(Paragraphs that are only partly enclosed in block tags will be enclosed in

...

tags.) key(in)operator(:) string(
inside
and outside.) key(html)operator(:) string(
inside

and outside.

) comment(# html:

inside
and outside.

) -tag(---) +head key(name)operator(:) string(complex xhtml blocks) key(desc)operator(:) string(Textile can’t always identify the beginning and end of long or complex blocks of XHTML. To prevent Textile from enclosing complex XHTML blocks in paragraph tags, either use a space at the beginning of each line...) -key(in)operator(:) string("
\\n My div\\n
") -key(html)operator(:) string("
\\nMy div\\n
") -tag(---) +key(in)operator(:) string\\n My div\\n )delimiter(")> +key(html)operator(:) string\\nMy div\\n)delimiter(")> +head key(name)operator(:) string(complex xhtml blocks 2) key(desc)operator(:) string(...or a notexile.. extended block.) key(in)operator(:) string(|-) - string(notextile..) string(
) + string(notextile..
) - string(My) string(div) + string(My div) string(
) key(html)operator(:) string(|-) string(
) - string(My) string(div) + string(My div) string(
) -tag(---) +head key(name)operator(:) string(complex xhtml blocks with inline formatting) key(desc)operator(:) string(Textile will not wrap lines that start with a space in paragraph tags, but it should parse inline signatures) -key(in)operator(:) string("
\\n My *div*\\n
") -key(html)operator(:) string("
\\nMy div\\n
") -tag(---) +key(in)operator(:) string\\n My *div*\\n
)delimiter(")> +key(html)operator(:) string\\nMy div\\n)delimiter(")> +head key(name)operator(:) string(explicit pre escapement) key(desc)operator(:) string(The contents of explicit 
...
tags are escaped for display. ) key(in)operator(:) string(|-) string(
)
-  string(A) string(HTML) string(example)
+  string(A HTML example)
   string(
) key(html)operator(:) string(|-) string(
)
-  string(A) string(HTML) variable(<b>example</b>)
+  string(A HTML <b>example</b>)
   string(
) key(note)operator(:) string(This syntax is supported for backwards compatibility only, and doesn’t always work as expected. The block modifier pre. should be used instead.) -tag(---) +head key(name)operator(:) string(explicit code escapement) key(desc)operator(:) string(The contents of explicit ... tags are escaped for display.) key(in)operator(:) string(|-) string() - string(Another) string(HTML) string(example) + string(Another HTML example) string() key(html)operator(:) string(|-) string(

) - string(Another) string(HTML) variable(<b>example</b>) + string(Another HTML <b>example</b>) string(

) key(note)operator(:) string(This syntax is supported for backwards compatibility only, and doesn’t always work as expected. The block modifier bc. should be used instead.) -tag(---) +head key(name)operator(:) string(notextile tags) key(desc)operator(:) string(Blocks enclosed by the pseudo tag ... will be left untouched.) key(in)operator(:) string(|-) string() - string(p.) string(Leave) string(me) string(alone) + string(p. Leave me alone) string() key(html)operator(:) string(|-) - string(p.) string(Leave) string(me) string(alone) + string(p. Leave me alone) comment(# html: |-) comment(#

) comment(# p. Leave me alone) comment(#

) key(note)operator(:) string(This syntax is supported for backwards compatibility only, and doesn’t always work as expected. The block modifier notextile. should be used instead.) key(valid_html)operator(:) string(false) -tag(---) +head key(name)operator(:) string(left aligned text) key(desc)operator(:) string(Left alignment is specified with a < less than symbol.) key(in)operator(:) string(p<. Left-aligned paragraph.) key(html)operator(:) string(

Left-aligned paragraph.

) -tag(---) +head key(name)operator(:) string(right aligned text) key(desc)operator(:) string(Right alignment is specified with a > greater than symbol.) key(in)operator(:) string(h3>. Right-aligned heading.) key(html)operator(:) string(

Right-aligned heading.

) -tag(---) +head key(name)operator(:) string(justified text) key(desc)operator(:) string(Use both <> symbols for justified text.) key(in)operator(:) string(p<>. Justified paragraph.) key(html)operator(:) string(

Justified paragraph.

) -tag(---) +head key(name)operator(:) string(centered text) key(desc)operator(:) string(An = equals symbol represents centered text.) key(in)operator(:) string(h3=. Centered heading.) key(html)operator(:) string(

Centered heading.

) -tag(---) +head key(name)operator(:) string(padding) key(desc)operator(:) string(Use empty ( and \) parentheses to add padding to blocks, in multiples of 1 em.) key(in)operator(:) string(p(. Left pad 1em.) key(html)operator(:) string(

Left pad 1em.

) -tag(---) +head key(name)operator(:) string(padding 2) key(in)operator(:) string(p\)\). Right pad 2em.) key(html)operator(:) string(

Right pad 2em.

) -tag(---) +head key(name)operator(:) string(padding 3) key(in)operator(:) string(p(\). Left and right pad 1em.) key(html)operator(:) string(

Left and right pad 1em.

) -tag(---) +head key(name)operator(:) string(numeric lists) -key(desc)operator(:) string(Numeric lists are represented by lines beginning with #.) +key(desc)operator(:) string(Numeric lists are represented by lines beginning with) comment(#.) key(in)operator(:) string(|-) comment(# Item one) comment(# Item two) comment(# Item three) key(html)operator(:) string(|-) string(
    ) - string(
  1. Item) string(one
    2. ) - string(
  2. Item) string(two
    3. ) - string(
  3. Item) string(three
    4. ) + string(
  4. Item one
    5. ) + string(
  5. Item two
    6. ) + string(
  6. Item three
    7. ) string(
) -tag(---) +head key(name)operator(:) string(bulleted lists) key(desc)operator(:) string(Bulleted lists are represented by lines beginning with *.) key(in)operator(:) string(|-) - string(*) string(Item) string(A) - string(*) string(Item) string(B) - string(*) string(Item) string(C) + string(* Item A) + string(* Item B) + string(* Item C) key(html)operator(:) string(|-) string(
    ) - string(
  • Item) string(A
    • ) - string(
  • Item) string(B
    • ) - string(
  • Item) string(C
    • ) + string(
  • Item A
    • ) + string(
  • Item B
    • ) + string(
  • Item C
    • ) string(
) -tag(---) +head key(name)operator(:) string(list attributes) key(desc)operator(:) string(Attributes applied to the first list item will apply to the list itself.) key(in)operator(:) string(|-) - string(*{color)symbol(:red)operator(}) string(Item) string(one) - string(*) string(Item) string(two) - string(*) string(Item) string(three) -key(html)operator(:) string(|-) - string() - string(
  • Item) string(one
    • ) - string(
  • Item) string(two
    • ) - string(
  • Item) string(three
    • ) + string(*{color:red} Item one) + string(* Item two) + string(* Item three) +key(html)operator(:) string(|-) + string(
      ) + string(
    • Item one
      • ) + string(
    • Item two
      • ) + string(
    • Item three
      • ) string(
    ) -tag(---) +head key(name)operator(:) string(nested lists) -key(desc)operator(:) string(Use multiple # or * symbols to create nested lists.) +key(desc)operator(:) string(Use multiple) comment(# or * symbols to create nested lists.) key(in)operator(:) string(|-) comment(# Item one) comment(## Item one-A) @@ -585,17 +585,17 @@ key(in)operator(:) string(|-) comment(# Item two) key(html)operator(:) string(|-) string(
      ) - string(
    1. Item) string(one) + string(
    2. Item one) string(
        ) - string(
      1. Item) string(one-A
        2. ) - string(
      2. Item) string(one-B) + string(
      3. Item one-A
        4. ) + string(
      4. Item one-B) string(
          ) - string(
        1. Item) string(one-B-a
          2. ) + string(
        2. Item one-B-a
          3. ) string(
        5. ) string(
      3. ) - string(
    3. Item) string(two
      4. ) + string(
    4. Item two
      5. ) string(
    ) -tag(---) +head key(name)operator(:) string(tables) key(desc)operator(:) string(Tables can be constructed using | “pipe” symbols to separate cells.) key(in)operator(:) string(|a|simple|table|) @@ -607,11 +607,11 @@ key(html)operator(:) string(|-) string(table) string() string() -tag(---) +head key(name)operator(:) string(table heading cells) key(desc)operator(:) string(Use _. to indicate table heading cells.) key(in)operator(:) string(|-) - string(|_.) string(a|_.) string(table|_.) string(heading|) + string(|_. a|_. table|_. heading|) string(|a|table|row|) key(html)operator(:) string(|-) string() @@ -626,7 +626,7 @@ key(html)operator(:) string(|-) string() string() string(
    row
    ) -tag(---) +head key(name)operator(:) string(cell attributes) key(desc)operator(:) string(Attributes may be applied separately to individual cells, rows, and entire tables. Cell attributes are placed within each cell.) key(in)operator(:) string(|a|{color:red}. styled|cell|) @@ -634,23 +634,23 @@ key(html)operator(:) string(|-) string() string() string() - string(styled) + string() string() string() string(
    astyledcell
    ) -tag(---) +head key(name)operator(:) string(row attributes) key(desc)operator(:) string(Row attributes are placed at the beginning of a row, followed by a dot and a space.) key(in)operator(:) string((rowclass\). |a|classy|row|) key(html)operator(:) string(|-) string() - string() + string() string() string() string() string() string(
    aclassyrow
    ) -tag(---) +head key(name)operator(:) string(table attributes) key(desc)operator(:) string(Table attributes are specified by placing the special table. block modifier immediately before the table.) key(in)operator(:) string(|-) @@ -658,7 +658,7 @@ key(in)operator(:) string(|-) string(|a|classy|table|) string(|a|classy|table|) key(html)operator(:) string(|-) - string() + string() string() string() string() @@ -670,102 +670,102 @@ key(html)operator(:) string(|-) string() string() string(
    aclassytable
    ) -tag(---) +head key(name)operator(:) string(vertical alignment) key(desc)operator(:) string(Special alignment symbols are available for vertical alignment within table cells.) key(in)operator(:) string(|^. top alignment|) key(html)operator(:) string(|-) string() string() - string(top) string(alignment) + string() string() string(
    top alignment
    ) -tag(---) +head key(name)operator(:) string(vertical alignment 2) key(in)operator(:) string(|-) - string(|-.) string(middle) string(alignment|) + string(|-. middle alignment|) key(html)operator(:) string(|-) string() string() - string(middle) string(alignment) + string() string() string(
    middle alignment
    ) -tag(---) +head key(name)operator(:) string(vertical alignment 3) key(in)operator(:) string(|-) - string(|~.) string(bottom) string(alignment|) + string(|~. bottom alignment|) key(html)operator(:) string(|-) string() string() - string(bottom) string(alignment) + string() string() string(
    bottom alignment
    ) -tag(---) +head key(name)operator(:) string(column span) key(desc)operator(:) string(Use a \\ backslash to indicate a column span.) key(in)operator(:) string(|-) - string(|\\2.) string(spans) string(two) string(cols) string(|) - string(|) string(col) string(1) string(|) string(col) string(2) string(|) + string(|\\2. spans two cols |) + string(| col 1 | col 2 |) key(html)operator(:) string(|-) string() string() - string(spans) string(two) string(cols) string() + string() string() string() - string() - string() + string() + string() string() string(
    spans two cols
    ) string(col) string(1) string() string(col) string(2) string( col 1 col 2
    ) -tag(---) +head key(name)operator(:) string(row span) key(desc)operator(:) string(Use a / forward slash to indicate a row span.) key(in)operator(:) string(|-) - string(|/3.) string(spans) string(3) string(rows) string(|) string(row) string(a) string(|) - string(|) string(row) string(b) string(|) - string(|) string(row) string(c) string(|) + string(|/3. spans 3 rows | row a |) + string(| row b |) + string(| row c |) key(html)operator(:) string(|-) string() string() - string(spans) string(3) string(rows) string() - string() + string() + string() string() string() - string() + string() string() string() - string() + string() string() string(
    ) string(row) string(a) string(spans 3 rows row a
    ) string(row) string(b) string( row b
    ) string(row) string(c) string( row c
    ) -tag(---) +head key(name)operator(:) string(whitespace required) key(desc)operator(:) string(Links, images and phrase modifiers normally require surrounding whitespace.) key(in)operator(:) string(this*won't*work) key(html)operator(:) string(

    this*won’t*work

    ) -tag(---) +head key(name)operator(:) string(modifier without whitespace) key(desc)operator(:) string(To use these without whitespace, surround the modifier with [] square brackets.) key(in)operator(:) string(this[*will*]work) key(html)operator(:) string(

    thiswillwork

    ) -tag(---) +head key(name)operator(:) string(modifier without whitespace 2) key(desc)operator(:) string(This is particularly useful in conjunction with superscript and subscript.) key(in)operator(:) string(1[^st^], 2[^nd^], 3[^rd^].) key(html)operator(:) string(

    1st, 2nd, 3rd.

    ) -tag(---) +head key(name)operator(:) string(modifier without whitespace 3) key(in)operator(:) string(2 log[~n~]) key(html)operator(:) string(

    2 logn

    ) -tag(---) +head key(name)operator(:) string(modifier without whitespace 4) key(desc)operator(:) string(It can also be used to include links and images without surrounding whitespace.) key(in)operator(:) string(|-) - string(A) string(close[!/img.gif!]image.) - string(A) string(tight["text")symbol(:http)error(:)string(//thresholdstate.com/]link.) - string(A) operator([)keysymbol(:http)error(:)string(//thresholdstate.com/][1].) + string(A close[!/img.gif!]image.) + string(A tight["text":http://thresholdstate.com/]link.) + string(A ["footnoted link":http://thresholdstate.com/][1].) key(html)operator(:) string(|-) - string(

    A) string(closeimage.) - string(A) string(tighttextlink.) - string(A) string(footnoted) string(link1.

    ) + string(

    A closeimage.
    ) + string(A tighttextlink.
    ) + string(A footnoted link1.

    ) comment(# html: |-) comment(#

    A closeimage.
    ) comment(# A tighttextlink.
    ) diff --git a/test/scanners/yaml/website.expected.raydebug b/test/scanners/yaml/website.expected.raydebug new file mode 100644 index 0000000..171afa3 --- /dev/null +++ b/test/scanners/yaml/website.expected.raydebug @@ -0,0 +1,70 @@ +string(%YAML 1.2) +head +key(YAML)operator(:) string(YAML Ain't Markup Language) + +key(What It Is)operator(:) string(YAML is a human friendly data serialization) + string(standard for all programming languages.) + +key(YAML Resources)operator(:) + key(YAML 1.2 Specification)operator(:) string(http://yaml.org/spec/1.2/) + key(YAML 1.1 Specification)operator(:) string(http://yaml.org/spec/1.1/) + key(YAML Trac Wiki)operator(:) string(http://trac.yaml.org/) + key(YAML Mailing List)operator(:) string(yaml-core@lists.sourceforge.net) + key(YAML IRC Channel)operator(:) string + key(YAML Cookbook (Ruby\))operator(:) string(http://yaml4r.sourceforge.net/cookbook/) + +key(Projects)operator(:) + operator(-) string(YAML C Libraries:) + operator(-) string(libyaml) comment(# New Fast YAML (1.1\)) + operator(-) string(Syck) comment(# Old Fast YAML (1.0\)) + operator(-) string(PyYaml) comment(# YAML 1.1 Implementation) + operator(-) string(JsYaml) comment(# JavaScript PyYaml port) + operator(-) string(RbYaml) comment(# Ruby port of PyYaml) + operator(-) string(JvYaml) comment(# Java port of PyYaml) + operator(-) string(ocaml-syck) comment(# Syck bindings for OCaml) + operator(-) string(Perl Modules:) + operator(-) string(YAML) comment(# Pure Perl YAML Module) + operator(-) string(YAML::XS) comment(# Binding to libyaml) + operator(-) string(YAML::Syck) comment(# Binding to libsyck) + operator(-) string(YAML::Tiny) comment(# A small YAML subset module) + operator(-) string(PlYaml) comment(# Perl port of PyYaml) + operator(-) string(YamlReference) comment(# Haskell 1.2 reference parser) + operator(-) string(YPaste) comment(# Play with the Haskell 1.2 parser) + operator(-) string(YamlBeans) comment(# De/serialize Java objects to/from YAML) + operator(-) string(Rx) comment(# Simple, Extensible Schemata) + +key(News)operator(:) + operator(-) string(11-MAY-2008 -- Oren Ben-Kiki has released a new YAML 1.2 spec draft.) + operator(-) string(29-NOV-2007 -- Alexey Zakhlestin has updated his Syck (YAML 1.0\) binding for PHP) + operator(-) string(23-NOV-2007 -- Derek Wischusen has release Action Script 3 YAML 1.1) + operator(-) string(01-AUG-2006 -- Kirill Simonov has released libyaml, a parser and emitter in "C") + operator(-) string(06-JUN-2006 -- Ola Bini is at it again, this time with a Java implementation) + operator(-) string(03-JUN-2006 -- Christophe Lambrechts and Jonathan Slenders announced a .NET parser) + operator(-) string(07-MAY-2006 -- Ola Bini released a pure-ruby YAML 1.1 parser and emitter) + operator(-) string(12-APR-2006 -- Kirill's YAML 1.1 parser for Python is now at PyYaml) + operator(-) string(05-FEB-2006 -- Spyc YAML for PHP is now at version 0.3) + operator(-) string(17-DEC-2005 -- Makoto Kuwata has released Kwalify 0.5, YAML/JSON schema validator) + operator(-) string(14-DEC-2005 -- Toby Ho has released Jyaml, a Java library for YAML based on Rolf Veen's work) + operator(-) string(30-AUG-2005 -- Kirill Simonov has produce a wonderful Python binding for Syck) + operator(-) string(08-APR-2005 -- As it turns out, YAML is a superset of the JSON serialization language) + operator(-) string(18-MAY-2005 -- Why has released version 0.55 of Syck) + operator(-) string(28-DEC-2004 -- Announcing YAML 1.1 Working Draft) + operator(-) string(01-OCT-2004 -- YAML for Cocoa was released by Will Thimbley) + operator(-) string(08-FEB-2004 -- Slaven Rezic announced a new version of his Javascript binding) + operator(-) string(29-JAN-2004 -- Ingy, Oren, and Clark spent 4 days hacking on the spec in Portland.) + operator(-) string(10-OCT-2003 -- The Syck implementation with bindings for Ruby, Python,) + string(and PHP is now at version .41) + operator(-) string(26-APR-2003 -- Mike Orr has taken over the Pure Python development.) + operator(-) string(26-APR-2003 -- Brian Ingerson has created a FIT platform for Wiki-like testing.) + operator(-) string(24-JAN-2003 -- Updates to specification.) + operator(-) string(25-JUL-2002 -- Both the Ruby and Python parsers have made significant progress.) + string(There is an article about YAML by Kendall Grant Clark at xml.com.) + string(There is also a draft XML binding.) + operator(-) string(02-JUL-2002 -- Brian Ingerson will be giving a 45 minute presentation on YAML at the) + string(O'Reilly Open Source Conference in San Diego on July 24th 2002.) + operator(-) string(01-FEB-2002 -- Brian's Perl implementation YAML.pm, has been updated with new documentation.) + string(Included in this release is YSH, a test shell for learning how YAML works.) + operator(-) string(03-JAN-2002 -- YAML(tm\) starts the new year with a new name YAML Ain't Markup Language.) + operator(-) string(17-MAY-2001 -- YAML now has a mailing list at SourceForge.) + operator(-) string(15-MAY-2001 -- YAML is started with a first pass specification.) +head diff --git a/test/scanners/yaml/website.in.yml b/test/scanners/yaml/website.in.yml new file mode 100644 index 0000000..75b04e9 --- /dev/null +++ b/test/scanners/yaml/website.in.yml @@ -0,0 +1,70 @@ +%YAML 1.2 +--- +YAML: YAML Ain't Markup Language + +What It Is: YAML is a human friendly data serialization + standard for all programming languages. + +YAML Resources: + YAML 1.2 Specification: http://yaml.org/spec/1.2/ + YAML 1.1 Specification: http://yaml.org/spec/1.1/ + YAML Trac Wiki: http://trac.yaml.org/ + YAML Mailing List: yaml-core@lists.sourceforge.net + YAML IRC Channel: "#yaml on irc.freenode.net" + YAML Cookbook (Ruby): http://yaml4r.sourceforge.net/cookbook/ + +Projects: + - YAML C Libraries: + - libyaml # New Fast YAML (1.1) + - Syck # Old Fast YAML (1.0) + - PyYaml # YAML 1.1 Implementation + - JsYaml # JavaScript PyYaml port + - RbYaml # Ruby port of PyYaml + - JvYaml # Java port of PyYaml + - ocaml-syck # Syck bindings for OCaml + - Perl Modules: + - YAML # Pure Perl YAML Module + - YAML::XS # Binding to libyaml + - YAML::Syck # Binding to libsyck + - YAML::Tiny # A small YAML subset module + - PlYaml # Perl port of PyYaml + - YamlReference # Haskell 1.2 reference parser + - YPaste # Play with the Haskell 1.2 parser + - YamlBeans # De/serialize Java objects to/from YAML + - Rx # Simple, Extensible Schemata + +News: + - 11-MAY-2008 -- Oren Ben-Kiki has released a new YAML 1.2 spec draft. + - 29-NOV-2007 -- Alexey Zakhlestin has updated his Syck (YAML 1.0) binding for PHP + - 23-NOV-2007 -- Derek Wischusen has release Action Script 3 YAML 1.1 + - 01-AUG-2006 -- Kirill Simonov has released libyaml, a parser and emitter in "C" + - 06-JUN-2006 -- Ola Bini is at it again, this time with a Java implementation + - 03-JUN-2006 -- Christophe Lambrechts and Jonathan Slenders announced a .NET parser + - 07-MAY-2006 -- Ola Bini released a pure-ruby YAML 1.1 parser and emitter + - 12-APR-2006 -- Kirill's YAML 1.1 parser for Python is now at PyYaml + - 05-FEB-2006 -- Spyc YAML for PHP is now at version 0.3 + - 17-DEC-2005 -- Makoto Kuwata has released Kwalify 0.5, YAML/JSON schema validator + - 14-DEC-2005 -- Toby Ho has released Jyaml, a Java library for YAML based on Rolf Veen's work + - 30-AUG-2005 -- Kirill Simonov has produce a wonderful Python binding for Syck + - 08-APR-2005 -- As it turns out, YAML is a superset of the JSON serialization language + - 18-MAY-2005 -- Why has released version 0.55 of Syck + - 28-DEC-2004 -- Announcing YAML 1.1 Working Draft + - 01-OCT-2004 -- YAML for Cocoa was released by Will Thimbley + - 08-FEB-2004 -- Slaven Rezic announced a new version of his Javascript binding + - 29-JAN-2004 -- Ingy, Oren, and Clark spent 4 days hacking on the spec in Portland. + - 10-OCT-2003 -- The Syck implementation with bindings for Ruby, Python, + and PHP is now at version .41 + - 26-APR-2003 -- Mike Orr has taken over the Pure Python development. + - 26-APR-2003 -- Brian Ingerson has created a FIT platform for Wiki-like testing. + - 24-JAN-2003 -- Updates to specification. + - 25-JUL-2002 -- Both the Ruby and Python parsers have made significant progress. + There is an article about YAML by Kendall Grant Clark at xml.com. + There is also a draft XML binding. + - 02-JUL-2002 -- Brian Ingerson will be giving a 45 minute presentation on YAML at the + O'Reilly Open Source Conference in San Diego on July 24th 2002. + - 01-FEB-2002 -- Brian's Perl implementation YAML.pm, has been updated with new documentation. + Included in this release is YSH, a test shell for learning how YAML works. + - 03-JAN-2002 -- YAML(tm) starts the new year with a new name YAML Ain't Markup Language. + - 17-MAY-2001 -- YAML now has a mailing list at SourceForge. + - 15-MAY-2001 -- YAML is started with a first pass specification. +... -- cgit v1.2.1