From c9eac585f167788dd590db06776b132923455a93 Mon Sep 17 00:00:00 2001 From: murphy Date: Thu, 1 Jan 2009 03:19:28 +0000 Subject: Completed YAML Scanner (closes #34). YAML Scanner: * Added another example (multiline). * Added multiline string recognition. * This should be enough for most people. Else: * New method: Scanner#column (very useful and fast!) * Added new token type :doctype, used also by HTML scanner. * coderay_suite: minor output tweaks. --- lib/coderay/scanner.rb | 9 +- lib/coderay/scanners/html.rb | 2 +- lib/coderay/scanners/yaml.rb | 53 +- lib/coderay/styles/cycnus.rb | 1 + lib/coderay/token_classes.rb | 1 + test/scanners/coderay_suite.rb | 6 +- .../scanners/html/coderay-output.expected.raydebug | 2 +- test/scanners/html/tolkien.expected.raydebug | 2 +- test/scanners/xml/kate.expected.raydebug | 2 +- test/scanners/yaml/basic.expected.raydebug | 956 ++++++++++----------- test/scanners/yaml/faq.expected.raydebug | 730 ++++++++-------- test/scanners/yaml/multiline.expected.raydebug | 21 + test/scanners/yaml/multiline.in.yml | 21 + test/scanners/yaml/threshold.expected.raydebug | 660 +++++++------- test/scanners/yaml/website.expected.raydebug | 24 +- 15 files changed, 1272 insertions(+), 1218 deletions(-) create mode 100644 test/scanners/yaml/multiline.expected.raydebug create mode 100644 test/scanners/yaml/multiline.in.yml diff --git a/lib/coderay/scanner.rb b/lib/coderay/scanner.rb index 831fc39..371c858 100644 --- a/lib/coderay/scanner.rb +++ b/lib/coderay/scanner.rb @@ -180,6 +180,11 @@ module CodeRay def line string[0..pos].count("\n") + 1 end + + def column pos = self.pos + return 0 if pos <= 0 + pos - (string.rindex(?\n, pos) || 0) + end protected @@ -216,7 +221,7 @@ module CodeRay tokens: %s -current line: %d pos = %d +current line: %d column: %d pos: %d matched: %p state: %p bol? = %p, eos? = %p @@ -231,7 +236,7 @@ surrounding code: msg, tokens.size, tokens.last(10).map { |t| t.inspect }.join("\n"), - line, pos, + line, column, pos, matched, state, bol?, eos?, string[pos - ambit, ambit], string[pos, ambit], diff --git a/lib/coderay/scanners/html.rb b/lib/coderay/scanners/html.rb index bb7ad3a..1f4d8fe 100644 --- a/lib/coderay/scanners/html.rb +++ b/lib/coderay/scanners/html.rb @@ -63,7 +63,7 @@ module Scanners if scan(//m) kind = :comment elsif scan(//m) - kind = :preprocessor + kind = :doctype elsif scan(/<\?xml.*?\?>/m) kind = :preprocessor elsif scan(/<\?.*?\?>|<%.*?%>/m) diff --git a/lib/coderay/scanners/yaml.rb b/lib/coderay/scanners/yaml.rb index 3ecd7e1..d99a38f 100644 --- a/lib/coderay/scanners/yaml.rb +++ b/lib/coderay/scanners/yaml.rb @@ -13,7 +13,7 @@ module Scanners value_expected = nil state = :initial - indent = 0 + key_indent = indent = 0 until eos? @@ -21,8 +21,11 @@ module Scanners match = nil if bol? - indent = matched.size if check(/ +/) - # tokens << [indent.to_s, :debug] + key_indent = nil + if $DEBUG + indent = check(/ +/) ? matched.size : 0 + tokens << [indent.to_s, :debug] + end end if match = scan(/ +[\t ]*/) @@ -41,6 +44,9 @@ module Scanners tokens << [match, :head] tokens << [:close, :head] next + when match = scan(/%.*/) + tokens << [match, :doctype] + next end elsif state == :value and case @@ -51,8 +57,17 @@ module Scanners tokens << [matched, :delimiter] if scan(/"/) tokens << [:close, :string] next - when scan(/(?![!"*&]).+?(?=$|\s+#)/) - kind = :string + when match = scan(/[|>][-+]?/) + tokens << [:open, :string] + tokens << [match, :delimiter] + tokens << [matched, :content] if scan(/(?:\n+ {#{key_indent + 1}}.*)+/) + tokens << [:close, :string] + next + when match = scan(/(?![!"*&]).+?(?=$|\s+#)/) + tokens << [match, :string] + string_indent = key_indent || column(pos - match.size - 1) + tokens << [matched, :string] if scan(/(?:\n+ {#{string_indent + 1}}.*)+/) + next end elsif case @@ -62,15 +77,19 @@ module Scanners kind = :operator when match = scan(/[,{}\[\]]/) kind = :operator - when state == :initial && scan(/[\w.() ]*\S(?=: |:$)/) + when state == :initial && match = scan(/[\w.() ]*\S(?=: |:$)/) kind = :key + key_indent = column(pos - match.size - 1) + # tokens << [key_indent.inspect, :debug] state = :colon - when match = scan(/(?:"[^"]*"|'[^']*')(?=: |:$)/) + when match = scan(/(?:"[^"\n]*"|'[^'\n]*')(?=: |:$)/) tokens << [:open, :key] tokens << [match[0,1], :delimiter] tokens << [match[1..-2], :content] tokens << [match[-1,1], :delimiter] tokens << [:close, :key] + key_indent = column(pos - match.size - 1) + # tokens << [key_indent.inspect, :debug] state = :colon next when scan(/(![\w\/]+)(:([\w:]+))?/) @@ -93,25 +112,9 @@ module Scanners when scan(/:\w+/) kind = :symbol when scan(/[^:\s]+(:(?! |$)[^:\s]*)* .*/) - kind = :string + kind = :error when scan(/[^:\s]+(:(?! |$)[^:\s]*)*/) - kind = :string - # when scan(/>-?/) - # kind = :punct - # kind = :normal, scan(/.*$/) - # append getch until eos? || bol? - # return if eos? - # indent = check(/ */) - # kind = :string - # loop do - # line = check_until(/[\n\r]|\Z/) - # break if line.nil? - # if line.chomp.length > 0 - # this_indent = line.chomp.match( /^\s*/ )[0] - # break if this_indent.length < indent.length - # end - # append scan_until(/[\n\r]|\Z/) - # end + kind = :error end else diff --git a/lib/coderay/styles/cycnus.rb b/lib/coderay/styles/cycnus.rb index 0a1c6f8..8d7c8cd 100644 --- a/lib/coderay/styles/cycnus.rb +++ b/lib/coderay/styles/cycnus.rb @@ -64,6 +64,7 @@ ol.CodeRay li { white-space: pre } .di { color:#088; font-weight:bold } .dl { color:black } .do { color:#970 } +.dt { color:#34b } .ds { color:#D42; font-weight:bold } .e { color:#666; font-weight:bold } .en { color:#800; font-weight:bold } diff --git a/lib/coderay/token_classes.rb b/lib/coderay/token_classes.rb index d85d1af..c71705b 100755 --- a/lib/coderay/token_classes.rb +++ b/lib/coderay/token_classes.rb @@ -21,6 +21,7 @@ module CodeRay :delimiter => 'dl', :directive => 'di', :doc => 'do', + :doctype => 'dt', :doc_string => 'ds', :entity => 'en', :error => 'er', diff --git a/test/scanners/coderay_suite.rb b/test/scanners/coderay_suite.rb index 751b8b7..f5fb7fe 100644 --- a/test/scanners/coderay_suite.rb +++ b/test/scanners/coderay_suite.rb @@ -143,7 +143,7 @@ module CodeRay def test_ALL puts - puts ' >> Testing '.magenta + self.class.name.cyan + + puts ' >> Testing '.magenta + self.class.name[/\w+$/].cyan + ' scanner <<'.magenta puts @@ -230,7 +230,9 @@ module CodeRay begin scanner.tokenize rescue - flunk "Random test failed at #{size} #{RUBY_VERSION < '1.9' ? 'bytes' : 'chars'}" if ENV['assert'] + assert_nothing_raised "Random test failed at #{size} #{RUBY_VERSION < '1.9' ? 'bytes' : 'chars'}" do + raise + end if ENV['assert'] okay = false break end diff --git a/test/scanners/html/coderay-output.expected.raydebug b/test/scanners/html/coderay-output.expected.raydebug index 18b7722..b8dc626 100644 --- a/test/scanners/html/coderay-output.expected.raydebug +++ b/test/scanners/html/coderay-output.expected.raydebug @@ -1,4 +1,4 @@ -preprocessor() tag( attribute_name(xml:lang)operator(=)string attribute_name(lang)operator(=)stringtag(>) tag() diff --git a/test/scanners/html/tolkien.expected.raydebug b/test/scanners/html/tolkien.expected.raydebug index 653ddd0..df61b19 100644 --- a/test/scanners/html/tolkien.expected.raydebug +++ b/test/scanners/html/tolkien.expected.raydebug @@ -1,4 +1,4 @@ -preprocessor() +doctype() tag( attribute_name(xml:lang)operator(=)string attribute_name(lang)operator(=)stringtag(>) tag()tag()plain(Faszination Tolkien - Herr der Ringe )entity(&) plain(Co.)tag() tag( attribute_name(content)operator(=)string tag(/>) diff --git a/test/scanners/xml/kate.expected.raydebug b/test/scanners/xml/kate.expected.raydebug index 01eec5a..2e3204c 100644 --- a/test/scanners/xml/kate.expected.raydebug +++ b/test/scanners/xml/kate.expected.raydebug @@ -1,5 +1,5 @@ preprocessor() -preprocessor() +doctype() tag( attribute_name(version)operator(=)string attribute_name(kateversion)operator(=)string attribute_name(section)operator(=)string attribute_name(extensions)operator(=)string attribute_name(mimetype)operator(=)stringtag(>) tag() tag(tag(>) diff --git a/test/scanners/yaml/basic.expected.raydebug b/test/scanners/yaml/basic.expected.raydebug index 6ffde52..810b400 100644 --- a/test/scanners/yaml/basic.expected.raydebug +++ b/test/scanners/yaml/basic.expected.raydebug @@ -1,110 +1,110 @@ 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 single paragraph.) +key(in)operator(:) stringA single paragraph.

) - string(

Followed by another.

) + Followed by another.)> +key(html)operator(:) stringA single paragraph.

+

Followed by another.

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

I saw a ship. It ate my elephant.

) +key(in)operator(:) string +key(html)operator(:) stringI saw a ship. It ate my elephant.

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

) - string(

When the elephant comes to take a p. you…

) + When the elephant comes to take a p. you...)> +key(html)operator(:) stringI saw a ship. It ate my elephant.

+

When the elephant comes to take a p. you…

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

I saw a ship. It ate my elephant.

) - string(
) +key(in)operator(:) string +key(html)operator(:) string +

I saw a ship. It ate my elephant.

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

I saw a ship. It ate my elephant.

) - string(

When the elephant comes to take a p. you…

) - string() + When the elephant comes to take a p. you...)> +key(html)operator(:) string +

I saw a ship. It ate my elephant.

+

When the elephant comes to take a p. you…

+ )> head key(name)operator(:) string(notextile block containing block start) -key(in)operator(:) string(|-) - string(notextile. I saw a ship. It ate my elephant.) -key(html)operator(:) string(|-) - string(I saw a ship. It ate my elephant.) +key(in)operator(:) string +key(html)operator(:) string key(valid_html)operator(:) string(false) head key(name)operator(:) string(extended notextile block containing block start) -key(in)operator(:) string(|-) - string(notextile.. I saw a ship. It ate my elephant.) +key(in)operator(:) string +key(html)operator(:) string key(valid_html)operator(:) string(false) head key(name)operator(:) string(pre block containing block start) -key(in)operator(:) string(|-) - string(pre. I saw a ship. It ate my elephant.) -key(html)operator(:) string(|-) - string(
I saw a ship. It ate my elephant.
) +key(in)operator(:) string +key(html)operator(:) stringI saw a ship. It ate my elephant.)> head key(name)operator(:) string(extended pre block containing block start) -key(in)operator(:) string(|-) - string(pre.. I saw a ship. It ate my elephant.) +key(in)operator(:) stringI saw a ship. It ate my elephant.) + When the elephant comes to take a p. you...)> +key(html)operator(:) stringI saw a ship. It ate my elephant. - string(
When the elephant comes to take a p. you…
) - string(--- ) + 
When the elephant comes to take a p. you…
+ --- )> 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 am very serious.) +key(in)operator(:) stringvery serious. - string(
)
-    string(I am very serious.)
-  string(
) -key(html)operator(:) string(|-) - string(

I am very serious.

) - string(
)
-    string(I am <b>very</b> serious.)
-  string(
) + 
+    I am very serious.
+
)> +key(html)operator(:) stringI am very serious.

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

I spoke.
) - string(And none replied.

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

I spoke.) - string(And none replied.

) -key(lite_mode_html)operator(:) string(|-) - string(I spoke.
) - string(And none replied.) +key(in)operator(:) string +key(html)operator(:) stringI spoke.
+ And none replied.

)> +key(html_no_breaks)operator(:) stringI spoke. + And none replied.

)> +key(lite_mode_html)operator(:) 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.) @@ -112,13 +112,13 @@ key(in)operator(:) string key(html)operator(:) string(

“Observe!”

) head key(name)operator(:) string(quotes contained in multi-paragraph quotes) -key(in)operator(:) string(|-) - string("I first learned about this thing called "Redcloth" several years ago.) +key(in)operator(:) string“I first learned about this thing called “Redcloth” several years ago.

) - string(

“It’s wonderful.”

) + "It's wonderful.")> +key(html)operator(:) string“I first learned about this thing called “Redcloth” several years ago.

+

“It’s wonderful.”

)> head key(name)operator(:) string(double hyphens) key(desc)operator(:) string(Double hyphens are replaced with an em-dash.) @@ -200,18 +200,18 @@ key(html)operator(:) string(

Header 3

) 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 old text) +key(in)operator(:) stringAny old text

) - string(
) - string(

A block quotation.

) - string(
) - string(

Any old text

) + Any old text)> +key(html)operator(:) stringAny old text

+
+

A block quotation.

+
+

Any old text

)> head key(name)operator(:) string(footnote reference) key(desc)operator(:) string(Numeric references within text to footnotes appear between square brackets.) @@ -242,12 +242,12 @@ key(html)operator(:) string10 times as many 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 __know__.) - string(I **really** __know__.) -key(html)operator(:) string(|-) - string(

I know.
) - string(I really know.

) +key(in)operator(:) string +key(html)operator(:) stringI know.
+ 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.) @@ -304,24 +304,24 @@ key(html)operator(:) string(

I’m unaware of most soft drink 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 %{color:red}unaware%) - string(of most soft drinks.) -key(html)operator(:) string(|-) - string(

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

) -key(lite_mode_html)operator(:) string(|-) - string(I’m unaware
) - string(of most soft drinks.) +key(in)operator(:) string +key(html)operator(:) stringI’m unaware
+ of most soft drinks.

)> +key(lite_mode_html)operator(:) stringunaware
+ 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(|-) - string(http://blah.com/one%20two%20three) - string((min\)5%-95%(max\)) -key(html)operator(:) string(|-) - string(

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

) +key(in)operator(:) string +key(html)operator(:) stringhttp://blah.com/one%20two%20three
+ (min\)5%-95%(max\)

)> 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.) @@ -350,29 +350,29 @@ key(html)operator(:) string(

rouge

) 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 seriously *{color:red}blushed*) - string(when I _(big\)sprouted_ that) - string(corn stalk from my) - string(%[es]cabeza%.) -key(html)operator(:) string(|-) - string(

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

) +key(in)operator(:) string +key(html)operator(:) stringI seriously blushed
+ when I sprouted that
+ corn stalk from my
+ 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 *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 seriously {color:red}blushed
) - string(when I first (big\)sprouted that
) - string(corn stalk from my
) - string(grande [es]cabeza.

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

)> head key(name)operator(:) string(align justified) key(desc)operator(:) string(Text inside blocks can be aligned in four basic ways.) @@ -396,115 +396,115 @@ key(html)operator(:) string(

Instiki uses this technique to float a sidebar to the right.) -key(in)operator(:) string(|) - string(
) +key(in)operator(:) string - string(h3. Sidebar) + h3. Sidebar - string("Hobix":http://hobix.com/) - string("Ruby":http://ruby-lang.org/) + "Hobix":http://hobix.com/ + "Ruby":http://ruby-lang.org/ - string(
) + - string(The main text of the page goes here and will stay to the left of the sidebar.) -key(html)operator(:) string(|-) - string(
) - string(

Sidebar

) - string(

Hobix
) - string(Ruby

) - string(
) - string(

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

) + The main text of the page goes here and will stay to the left of the sidebar.)> +key(html)operator(:) string +

Sidebar

+

Hobix
+ Ruby

+ +

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(|-) - comment(# A first item) - comment(# A second item) - comment(# A third) -key(html)operator(:) string(|-) - string(
    ) - string(
  1. A first item
    2. ) - string(
  2. A second item
    3. ) - string(
  3. A third
    4. ) - string(
) +key(in)operator(:) string +key(html)operator(:) string +
  • A first item
    • +
  • A second item
    • +
  • A third
    • + )> 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(|-) - comment(# Fuel could be:) - comment(## Coal) - comment(## Gasoline) - comment(## Electricity) - comment(# Humans need only:) - comment(## Water) - comment(## Protein) -key(html)operator(:) string(|-) - string(
      ) - string(
    1. Fuel could be:) - string(
        ) - string(
      1. Coal
        2. ) - string(
      2. Gasoline
        3. ) - string(
      3. Electricity
        4. ) - string(
      2. ) - string(
    2. Humans need only:) - string(
        ) - string(
      1. Water
        2. ) - string(
      2. Protein
        3. ) - string(
      3. ) - string(
    ) +key(in)operator(:) string +key(html)operator(:) string +
  • Fuel could be: +
      +
    1. Coal
      2. +
    2. Gasoline
      3. +
    3. Electricity
      4. +
    • +
  • Humans need only: +
      +
    1. Water
      2. +
    2. Protein
      3. +
    • + )> 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(* A first item) - string(* A second item) - string(* A third) -key(html)operator(:) string(|-) - string(
      ) - string(
    • A first item
      • ) - string(
    • A second item
      • ) - string(
    • A third
      • ) - string(
    ) +key(in)operator(:) string +key(html)operator(:) string +
  • A first item
    • +
  • A second item
    • +
  • A third
    • + )> 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(* Fuel could be:) - string(** Coal) - string(** Gasoline) - string(** Electricity) - string(* Humans need only:) - string(** Water) - string(** Protein) -key(html)operator(:) string(|-) - string(
      ) - string(
    • Fuel could be:) - string(
        ) - string(
      • Coal
        • ) - string(
      • Gasoline
        • ) - string(
      • Electricity
        • ) - string(
      • ) - string(
    • Humans need only:) - string(
        ) - string(
      • Water
        • ) - string(
      • Protein
        • ) - string(
      • ) - string(
    ) +key(in)operator(:) string +key(html)operator(:) string +
  • Fuel could be: +
      +
    • Coal
      • +
    • Gasoline
      • +
    • Electricity
      • +
    • +
  • Humans need only: +
      +
    • Water
      • +
    • Protein
      • +
    • + )> 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.) @@ -514,16 +514,16 @@ key(lite_mode_html)operator(:) string(I searched Goo 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 am crazy about "Hobix":hobix) - string(and "it's":hobix "all":hobix I ever) - string("link to":hobix!) +key(in)operator(:) stringI am crazy about Hobix
    ) - string(and it’s all I ever
    ) - string(link to!

    ) + [hobix]http://hobix.com)> +key(html)operator(:) stringI am crazy about Hobix
    + and it’s all I ever
    + 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.) @@ -543,15 +543,15 @@ key(html)operator(:) string(

    ) - string(

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

    ) + And others sat all round the small + machine and paid it to sing to them.)> +key(html)operator(:) string

    +

    And others sat all round the small
    + 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.) @@ -562,288 +562,288 @@ key(no_span_caps_html)operator(:) string(

    We use align left ) - string() - string() - string(align right) - string() - string() - string(center ) - string() - string() - string(justify ) - string() - string() - string(valign top ) - string() - string() - string(bottom ) - string() - string() +key(in)operator(:) string. align right| + |=. center | + |<>. justify | + |^. valign top | + |~. bottom |)> +key(html)operator(:) string + + attribute list + + + align left + + + align right + + + center + + + justify + + + valign top + + + bottom + + )> 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. spans two cols |) - string(| col 1 | col 2 |) -key(html)operator(:) string(|-) - string() - string() - string() - string() - string() - string() - string() - string() - string(
    spans two cols
    col 1 col 2
    ) +key(in)operator(:) string +key(html)operator(:) string + + spans two cols + + + col 1 + col 2 + + )> 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. spans 3 rows | a |) - string(| b |) - string(| c |) -key(html)operator(:) string(|-) - string() - string() - string() - string() - string() - string() - string() - string() - string() - string() - string() - string(
    spans 3 rows a
    b
    c
    ) +key(in)operator(:) string +key(html)operator(:) string + + spans 3 rows + a + + + b + + + c + + )> 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 -key(html)operator(:) string(|-) - string() - string() - string() - string() - string(
    Grey cell
    ) +key(html)operator(:) string + + Grey cell + + )> 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:1px solid black}.) - string(|This|is|a|row|) - string(|This|is|a|row|) -key(html)operator(:) string(|-) - string() - string() - string() - string() - string() - string() - string() - string() - string() - string() - string() - string() - string() - string(
    Thisisarow
    Thisisarow
    ) +key(in)operator(:) string +key(html)operator(:) string + + This + is + a + row + + + This + is + a + row + + )> 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({)string(background:#ddd}. |This|is|grey|row|) -key(html)operator(:) string(|-) - string() - string() - string() - string() - string() - string() - string() - string() - string() - string() - string() - string() - string() - string(
    Thisisarow
    Thisisgreyrow
    ) +key(in)operator(:) string +key(html)operator(:) string + + This + is + a + row + + + This + is + grey + row + + )> head key(name)operator(:) string(extended block followed by pre block) -key(in)operator(:) string(|-) - string(div.. Just a test.) +key(in)operator(:) stringJust a test.) - string(

    Second div.
    ) - string(
    A pre block ends it.
    ) + pre. A pre block ends it.)> +key(html)operator(:) stringJust a test. +
    Second div.
    + 
    A pre block ends it.
    )> head key(name)operator(:) string(extended block followed by blockquote) -key(in)operator(:) string(|-) - string(div.. Just a test.) +key(in)operator(:) stringJust a test.) - string(
    Second div.
    ) - string(
    ) - string(

    A blockquote ends it.

    ) - string(
    ) + bq. A blockquote ends it.)> +key(html)operator(:) stringJust a test. +
    Second div.
    +
    +

    A blockquote ends it.

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

    before (in parens\) after

    ) +key(in)operator(:) string +key(html)operator(:) stringbefore (in parens\) after

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

    before (in parens\) after

    ) +key(in)operator(:) string +key(html)operator(:) stringbefore (in parens\) after

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

    before (in parens\) after

    ) +key(in)operator(:) string +key(html)operator(:) stringbefore (in parens\) after

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

    “before (in parens\) after”

    ) +key(in)operator(:) string +key(html)operator(:) string“before (in parens\) after”

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

    one two three (four five six\) seven

    ) +key(in)operator(:) string +key(html)operator(:) stringone two three (four five six\) seven

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

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

    ) +key(in)operator(:) string +key(html)operator(:) string“one two three (four five six\) seven”

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

    one (two three four\) five

    ) +key(in)operator(:) string +key(html)operator(:) stringone (two three four\) five

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

    “one (two three four\) five”

    ) +key(in)operator(:) string +key(html)operator(:) 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.) @@ -853,19 +853,19 @@ key(no_span_caps_html)operator(:) string(

    IBM or (HAL\)

    ) 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 are mushrooms.) - string(Lungworts (__Lobaria__\) are lichens.) - string(Blah blah (normal text **bold**\) blah.) -key(html)operator(:) string(|-) - string(

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

    ) +key(in)operator(:) string +key(html)operator(:) string__Amanita__s are mushrooms.
    + Lungworts (Lobaria\) are lichens.
    + Blah blah (normal text bold\) blah.

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

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

    ) \ No newline at end of file +key(in)operator(:) string +key(html)operator(:) stringcitation [“(Berk.\) Hilton”], see
    + [Papers “blah blah.”]

    )> \ No newline at end of file diff --git a/test/scanners/yaml/faq.expected.raydebug b/test/scanners/yaml/faq.expected.raydebug index 77b9b30..96af243 100644 --- a/test/scanners/yaml/faq.expected.raydebug +++ b/test/scanners/yaml/faq.expected.raydebug @@ -1,492 +1,492 @@ head operator(-) keyoperator(:) - operator(-) keyoperator(:) string(>-) - 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 _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 _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 _service_ is the instantiation of a service point.) - - operator(-) keyoperator(:) string(>-) - 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 _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 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 _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 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 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 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(-) keyoperator(:) string-)content( + A _container_ is collection of service points and other containers. It + is used to organize services. Each container has access to all of the + service points in its ancestor containers.)> + + operator(-) keyoperator(:) string-)content( + A _registry_ is a special kind of container that has no parent container. + It also defines a few services (such as the LoggingInterceptor, and + the various service models and pipeline elements\), so that they are + available by default to all of the services it contains.)> + + operator(-) keyoperator(:) string-)content( + A _service point_ is the definition of a service. Just as a class is the + definition of an object, and you instantiate an object from a class, so + do you instantiate services from service points.)> + + operator(-) keyoperator(:) string-)content( + A _service_ is the instantiation of a service point.)> + + operator(-) keyoperator(:) string-)content( + A _parameterized_ service is a service that allows contextual parameters + to be passed to the service when it is created. Such services are + typically used in conjunction with the @multiton@ service model, but + the only real requirement is that they _not_ be used with a service model + that does not support multiple parameters (like @singleton@ or + @threaded@\).)> + + operator(-) keyoperator(:) string-)content( + A _service model_ is a description of the lifecycle of a service. By + default, all services are _singletons_, meaning that every time you ask + a container for a particular service, you'll get the same object + instance back. + + + There are other service models available, though, including "prototype" + (which returns a new instance for each request of a service\) and + "deferred" (which returns a proxy, deferring the instatiation of the + service itself until a method is invoked on the service\). )> + + operator(-) keyoperator(:) string-)content( + An _interceptor_ is an object that may be placed between the client and + a service. Every request to the service is thus _intercepted_ by that + object, which can do operations on the request (such as logging\) and may + even reroute or ignore the request altogether. This provides a kind of + "poor man's AOP", since you can do "before", "after", and "around" advice + on the methods of a service. + + + Needle comes with one standard interceptor, the LoggingInterceptor. It + will log a message on method entry and exit, and also when an exception + is raised.)> + + operator(-) keyoperator(:) string-)content( + In Needle, the _instantiation pipeline_ is used to control how and when + services are instantiated. The _service models_ are implemented as + pipelines. + + + Just as the _interceptors_ are for hooking into method invocations, the + pipelines are for hooking into service instantiations. Every time a + service is requested, it's instantiation pipeline is executed. By + choosing the appropriate kinds of pipeline elements, all of the available + service models can be implemented (prototype, prototype_deferred, + singleton, singleton_deferred, etc.\).)> operator(-) keyoperator(:) - operator(-) keyoperator(:) string(>-) - string(There are several ways to create a new registry. The simplist is just to) - string(invoke Registry#new.) + operator(-) keyoperator(:) string-)content( + There are several ways to create a new registry. The simplist is just to + invoke Registry#new. - string(
    )
-        string(reg = Needle::Registry.new)
-      string(
    ) + 
    +        reg = Needle::Registry.new
+
    - 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:) + This will create a new Registry instance. You can also send a block to + #new, in which case the new registry will be yielded to it: - string(
    )
-        string(reg = Needle::Registry.new do |r|)
-          string(...)
-        string(end)
-      string(
    ) + 
    +        reg = Needle::Registry.new do |r|
+          ...
+        end
+
    - string(There are two other factory methods you can use for creating a Registry) - string(instance. Both require a block.) + There are two other factory methods you can use for creating a Registry + instance. Both require a block. - string(
    )
-        string(r1 = Needle::Registry.define do |builder|)
-          string(...)
-        string(end)
+      
    +        r1 = Needle::Registry.define do |builder|
+          ...
+        end
 
-        string(r2 = Needle::Registry.define! do)
-          string(...)
-        string(end)
-      string(
    )
+        r2 = Needle::Registry.define! do
+          ...
+        end
+
    - 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.) + Registry#define creates a "builder" object that you can use define + services more conveniently. Register#define! (with a bang\) does the same + thing, but evaluates the block within the context of the builder.)> - operator(-) keyoperator(:) string(>-) - string(The first way to register a service is by calling #register on the) - key(registry (or a namespace\))operator(:) + operator(-) keyoperator(:) string-)content( + The first way to register a service is by calling #register on the + registry (or a namespace\): - string(
    )
-        string(reg.register( :foo \) { Foo.new })
-      string(
    ) + 
    +        reg.register( :foo \) { Foo.new }
+
    - 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"\):) + The (first\) parameter to #register is the name of the service, and the + block should return the implementation of the service. If needed, the + block can accept two parameters--the container that the service is being + registered with, and an object that represents the service being defined + (called a "service point"\): - string(
    )
-        string(reg.register( :foo \) do |container,point|)
-          string(Foo.new( container[:bar], point.fullname \))
-        string(end)
-      string(
    ) + 
    +        reg.register( :foo \) do |container,point|
+          Foo.new( container[:bar], point.fullname \)
+        end
+
    - 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.) + You can also use Container#define and Container#define! to register + services. These approaches are friendlier if you are needing to register + several services at once. - string(
    )
-        string(reg.define do |builder|)
-          string(builder.foo { Foo.new })
-          string(builder.bar { |c,p| Bar.new( c[:foo], p.name \) })
-        string(end)
+      
    +        reg.define do |builder|
+          builder.foo { Foo.new }
+          builder.bar { |c,p| Bar.new( c[:foo], p.name \) }
+        end
 
-        string(reg.define! do)
-          string(baz { |c,p| Baz.new( c[:bar], p.name \) })
-          string(zoom { Buggy.new })
-        string(end)
-      string(
    )
+        reg.define! do
+          baz { |c,p| Baz.new( c[:bar], p.name \) }
+          zoom { Buggy.new }
+        end
+
    - 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.) + Container#define yields a new "builder" object to the block. Messages + sent to the builder are interpreted as service names, and if a block is + sent with the message, a new service is registered under that name. - string(Container#define! does likewise, except it evaluates the block within the) - string(context of the builder object.) + Container#define! does likewise, except it evaluates the block within the + context of the builder object. - 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(:) + If you do not pass a block to #define, it will return the builder object, + so you could do something like the following if you only need to define + one or two services: - string(
    )
-        string(reg.define.foo { ... })
-      string(
    ) + 
    +        reg.define.foo { ... }
+
    - string(Lastly, you can get the builder directly and add services using it:) + Lastly, you can get the builder directly and add services using it: - string(
    )
-        string(builder = reg.builder)
-        string(builder.baz { ... })
-        string(builder.bar { ... })
-      string(
    ) + 
    +        builder = reg.builder
+        builder.baz { ... }
+        builder.bar { ... }
+
    - 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 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#[]:) + (This last is the same as calling #define without arguments, but is more + readable if you intend to use the builder object multiple times.\) + )> + operator(-) keyoperator(:) string-)content( + Referencing a service can be done in either of two ways. The first is to + treat the container (i.e., registry\) as a hash, passing the name of the + service as an argument to Container#[]: - string(
    )
-        string(svc = registry[:foo])
-        string(svc.do_something_interesting)
-      string(
    ) + 
    +        svc = registry[:foo]
+        svc.do_something_interesting
+
    - 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(:) + A more convenient (but slightly more peril-fraught\) approach is to send + the name of the method to the registry as a message: - string(
    )
-        string(svc = registry.foo)
-      string(
    ) + 
    +        svc = registry.foo
+
    - 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:) + Be aware that this latter approach will only work when the service name + does not conflict with the name of an existing method on the container. + For example, if you were to do: - string(
    )
-        string(registry.register( :hash \) { "hello, world" })
-        string(p registry.hash)
-      string(
    ) + 
    +        registry.register( :hash \) { "hello, world" }
+        p registry.hash
+
    - 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"\).) + You would get the hash value of the registry object, instead of the value + value of the service (which would be "hello, world"\).)> - operator(-) keyoperator(:) string(>-) - 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.) + operator(-) keyoperator(:) string-)content( + By default, a service will be managed as a singleton, i.e., every request + of that service will return the same object instance. This is the + _singleton_ service model. - string(To select a different service model, pass it as an option when you) - key(register the service)operator(:) + To select a different service model, pass it as an option when you + register the service: - 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(
    ) + 
    +        registry.register( :foo, :model => :prototype \) {...}
+        registry.define.bar( :model => :threaded \) {...}
+        registry.define! do
+          baz( :model => :singleton_deferred \) {...}
+          ...
+        end
+        ...
+
    )> - operator(-) keyoperator(:) string(>-) - 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:) + operator(-) keyoperator(:) string-)content( + Namespaces allow you to organize your services into hierarchical + packages. You can create namespaces in a few ways. The first (and + simplest\) is to just call Container#namespace: - string(
    )
-        string(registry.namespace( :stuff \))
-      string(
    ) + 
    +        registry.namespace( :stuff \)
+
    - 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(:) + This will create a namespace in the registry, called stuff. If you send a + block as well, the block will be invoked (with the new namespace yielded + to it\) the first time the namespace is requested: - 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(
    ) + 
    +        registry.namespace( :stuff \) do |ns|
+          ns.register( :foo \) {...}
+          ns.define.bar {...}
+          ns.define! do
+            baz {...}
+            buf {...}
+          end
+        end
+
    - 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.) + Because it is so common to immediately define services on the new + namespace, there are some convenience methods to make this more... + convenient. - string(
    )
-        string(registry.namespace_define!( :stuff \) do)
-          string(foo {...})
-          string(bar {...})
-          string(baz {...})
-        string(end)
+      
    +        registry.namespace_define!( :stuff \) do
+          foo {...}
+          bar {...}
+          baz {...}
+        end
 
-        string(registry.namespace_define( :more_stuff \) do |b|)
-          string(b.blah {...})
-          string(b.argh {...})
-          string(b.hack {...})
-        string(end)
-      string(
    )
+        registry.namespace_define( :more_stuff \) do |b|
+          b.blah {...}
+          b.argh {...}
+          b.hack {...}
+        end
+
    - 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.) + The first one, above, creates the namespace and calls Container#define!. + The second creates the namespace and calls Container#define. In both + cases, _the namespace is created immediately_, unlike Container#namespace + which only creates the namespace when it is first requested. - 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.) + Lastly, note that namespace's are just special services. Thus, you can + pass options to the namespace methods just as you can with + Container#register and friends.)> - operator(-) keyoperator(:) string(>-) - 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 the corresponding severity.) + operator(-) keyoperator(:) string-)content( + You can obtain a new logger instance from the @:logs@ and @:log_for@ + services. Once you have a logger instance, you can invoke the #debug, + #info, #warn, #error, and #fatal methods on the instance to log messages + of the corresponding severity. - string(
    )
-        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 = registry.log_for( "another logger name" \))
-        string(...)
-      string(
    ) + 
    +        logger = registry.logs.get( "a name for my logger" \)
+        logger.debug "This is a debug message"
+        logger.info "This is an informational message"
+        ...
+        logger2 = registry.log_for( "another logger name" \)
+        ...
+
    - string(The two approaches shown above are identical--the second approach (using) - string(the @log_for@ service\) is just a convenience for @logs.get@.) + The two approaches shown above are identical--the second approach (using + the @log_for@ service\) is just a convenience for @logs.get@. - string(Log messages are written, by default, to a file called "needle.log", in) - string(the same directory that the application was invoked from.) + Log messages are written, by default, to a file called "needle.log", in + the same directory that the application was invoked from. - 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.) + You can also use a logging interceptor to automatically log all external + method invocations on a service. This includes method entry and exit, as + well as any exceptions that are raised inside the method. - string(
    )
-        string(registry.register( :foo \) { ... })
-        string(registry.intercept( :foo \).with { |r| r.logging_interceptor })
+      
    +        registry.register( :foo \) { ... }
+        registry.intercept( :foo \).with { |r| r.logging_interceptor }
 
-        string(foo.something)
-        string(foo.another_method( 1, 2, 3 \))
-      string(
    )
+        foo.something
+        foo.another_method( 1, 2, 3 \)
+
    - 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.) + See the chapter in the "User's Manual":http://needle.rubyforge.org about + logging for more information on how to use and configure loggers.)> - operator(-) keyoperator(:) string(>-) - 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.\)) + operator(-) keyoperator(:) string-)content( + Only interceptors that explicitly support exclusion of methods can help + you here. Fortunately, the LoggingInterceptor is one of them. (If you + write your own interceptor and would like similar functionality, see the + IncludeExclude module.\) - 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(:) + In the case of the LoggingInterceptor, just pass an array of patterns + (matching method names and/or arities\) as the "exclude" option, when + declaring the interceptor: - string(
    )
-        string(registry.register( :foo \) { ... })
-        string(registry.intercept( :foo \).)
-          string(with { |r| r.logging_interceptor }.)
-          string(with_options :exclude => [ 'foo', 'bar(>4\)', '*(<2\)' ])
-      string(
    ) + 
    +        registry.register( :foo \) { ... }
+        registry.intercept( :foo \).
+          with { |r| r.logging_interceptor }.
+          with_options :exclude => [ 'foo', 'bar(>4\)', '*(<2\)' ]
+
    - 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.) + The above will exclude from interception any method named 'foo', or any + invocation of 'bar' with more than 4 arguments, or any method invocation + with fewer than two arguments. - 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(:) + You can also give an array of patterns to _include_. These cause methods + to be explicitly intercepted even if they match an exclude pattern: - string(
    )
-        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' ])
+      
    +        registry.register( :foo \) { ... }
+        registry.intercept( :foo \).
+          with { |r| r.logging_interceptor }.
+          with_options :exclude => [ 'foo', 'bar(>4\)', '*(<2\)' ],
+                       :include => [ 'baz' ]
 
-        string(foo = registry.foo)
-        string(foo.baz)
-      string(
    )
+        foo = registry.foo
+        foo.baz
+
    - string(This would result in the call to #baz being intercepted, even though it) - string(matches an exclude pattern (@*(<2\)@\).) + This would result in the call to #baz being intercepted, even though it + matches an exclude pattern (@*(<2\)@\).)> - operator(-) keyoperator(:) string(>-) - 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(:) + operator(-) keyoperator(:) string-)content( + This requires that the other library be implemented in such a way that it + expects to be "included" by other libraries/applications. For example, + Needle encourages the use of a method called @register_services@, which + accepts a container as a parameter: - string(
    )
-        string(module A)
-          string(module B)
-            string(def register_services( container \))
-              string(...)
-            string(end)
-            string(module_function :register_services)
-          string(end)
-        string(end)
-      string(
    ) + 
    +        module A
+          module B
+            def register_services( container \)
+              ...
+            end
+            module_function :register_services
+          end
+        end
+
    - 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.) + If the library has been implemented in this way, you can simply do a + require of the library and then invoke the @register_services@ method. - 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@.) + There is a convenience method in Container for doing this. Just call + Container#require, passing the file to require and a string (or symbol\) + identifying the name of the module that contains the registration method. + You can also pass a symbol as the third parameter naming the registration + method, but it defaults to @:register_services@. - string(
    )
-        string(require 'a/b')
-        string(A::B.register_services( container \))
+      
    +        require 'a/b'
+        A::B.register_services( container \)
 
-        comment(# or)
+        # or
 
-        string(container.require( 'a/b', "A::B" \))
-      string(
    )
+        container.require( 'a/b', "A::B" \)
+
    - string(The definition context (i.e., the "builder" object\) also supports the) - string(require method, so you can do:) + The definition context (i.e., the "builder" object\) also supports the + require method, so you can do: - string(
    )
-        string(container.define do |b|)
-          string(b.require "a/b", "A::B")
-          string(b.foo { ... })
-          string(...)
-        string(end)
-      string(
    ) + 
    +        container.define do |b|
+          b.require "a/b", "A::B"
+          b.foo { ... }
+          ...
+        end
+
    )> operator(-) keyoperator(:) operator(-) keyoperator(:) - operator(-) keyoperator(:) string(>-) - key(The prototype service model is appropriate when the service)operator(:) + operator(-) keyoperator(:) string-)content( + The prototype service model is appropriate when the service: - string(* has internal state) + * has internal state - string(* will be used multiple times for different situations) + * will be used multiple times for different situations - 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.) + For example, if you have a GUI library, a "button" service could be a + prototype, because you will likely have many buttons in an application, + with each button being an independent instance.)> - operator(-) keyoperator(:) string(>-) - 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(* guard some specific functionality) - - string(* represent state that is global across an application) - - operator(-) keyoperator(:) string(>-) - 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 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 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 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 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.) + operator(-) keyoperator(:) string-)content( + The singleton service model is the default, so you should rarely need + to explicitly specify it as a model. It is appropriate for services + that: + + + * guard some specific functionality + + * represent state that is global across an application)> + + operator(-) keyoperator(:) string-)content( + Threaded is similar to singleton, but it allows one unique instance of + the service _per thread_. Thus, it is appropriate to the same + situations as singleton, but specific to a thread, instead of an + application. This is useful for web applications that are run in a + single virtual machine, and which share a single registry.)> + + operator(-) keyoperator(:) string-)content( + Deferred models use a proxy to enforce lazy initialization of the + service. A service using a deferred service model (ie, + @:prototype_deferred@, @:multiton_deferred@, @:singleton_deferred@, or + @:threaded_deferred@\) will not be instantiated until the first time a + method is invoked on the service. + + + This makes a deferred model appropriate when a service is expensive to + instantiate, since you can wait to do the expensive initialization + until it is really needed. Applications will start up faster when their + dependences use deferred instantiation.)> + + operator(-) keyoperator(:) string-)content( + This is useful when you have a method that you want to be invoked + automatically after a service has been instantiated. Consider the case + where a service is initialized primarily using setters, but requires + some logic to be executed to complete the initialization phase. In this + case, you could always explicitly invoke the initialization method(s\) + in the constructor block, but if many services use the same + initialization method, it can be more convenient to use an "initialize" + service model.)> + + operator(-) keyoperator(:) string-)content( + Multitons are useful for factories, where you have a class that + differentiates its instances based on some construction parameters that + need to be determined at runtime. Thus, multitons are always used with + parameterized services.)> diff --git a/test/scanners/yaml/multiline.expected.raydebug b/test/scanners/yaml/multiline.expected.raydebug new file mode 100644 index 0000000..cf5a987 --- /dev/null +++ b/test/scanners/yaml/multiline.expected.raydebug @@ -0,0 +1,21 @@ +head +key(What It Is)operator(:) string(YAML is a human friendly data serialization)string( + standard for all programming languages.) +head +key(What It Is)operator(:) string(YAML is a human friendly data serialization)string( + standard for all programming languages.) +head +key(What It Is)operator(:) string(YAML is a human friendly data serialization) +error(standard for all programming languages.) +head +operator(-) string(What It Is: YAML is a human friendly data serialization)string( + standard for all programming languages.) +head +operator(-) string(What It Is: YAML is a human friendly data serialization)string( + standard for all programming languages.) +head +operator(-) string(What It Is: YAML is a human friendly data serialization) + error(standard for all programming languages.) +head +operator(-) string(What It Is: YAML is a human friendly data serialization) +error(standard for all programming languages.) diff --git a/test/scanners/yaml/multiline.in.yml b/test/scanners/yaml/multiline.in.yml new file mode 100644 index 0000000..83c0867 --- /dev/null +++ b/test/scanners/yaml/multiline.in.yml @@ -0,0 +1,21 @@ +--- +What It Is: YAML is a human friendly data serialization + standard for all programming languages. +--- +What It Is: YAML is a human friendly data serialization + standard for all programming languages. +--- +What It Is: YAML is a human friendly data serialization +standard for all programming languages. +--- +- What It Is: YAML is a human friendly data serialization + standard for all programming languages. +--- +- What It Is: YAML is a human friendly data serialization + standard for all programming languages. +--- +- What It Is: YAML is a human friendly data serialization + standard for all programming languages. +--- +- What It Is: YAML is a human friendly data serialization +standard for all programming languages. diff --git a/test/scanners/yaml/threshold.expected.raydebug b/test/scanners/yaml/threshold.expected.raydebug index 55a33e4..7ad0e65 100644 --- a/test/scanners/yaml/threshold.expected.raydebug +++ b/test/scanners/yaml/threshold.expected.raydebug @@ -1,22 +1,22 @@ 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 paragraph.) +key(in)operator(:) stringA paragraph.

    ) - string(

    Another paragraph.

    ) + Another paragraph.)> +key(html)operator(:) stringA paragraph.

    +

    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 paragraph with) - string(a line break.) -key(html)operator(:) string(|-) - string(

    A paragraph with
    ) - string(a line break.

    ) +key(in)operator(:) string +key(html)operator(:) stringA paragraph with
    + a line break.

    )> head key(name)operator(:) string(xhtml tags) key(desc)operator(:) string(Simple XHTML tags may be included in a paragraph.) @@ -40,16 +40,16 @@ key(html)operator(:) string‘Proceed!’ said h 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 swear, captain,' replied I.") -key(html)operator(:) string(|-) - string(

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

    ) +key(in)operator(:) string +key(html)operator(:) string“‘I swear, captain,’ replied I.”

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

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

    ) +key(in)operator(:) string +key(html)operator(:) 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.) @@ -168,14 +168,14 @@ key(html)operator(:) string(

    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 "a link":tstate, and) - string("another link":tstate to the same site.) +key(in)operator(:) stringHere’s a link, and
    ) - string(another link to the same site.

    ) + [tstate]http://thresholdstate.com/)> +key(html)operator(:) stringHere’s a link, and
    + another link to the same site.

    )> head key(name)operator(:) string(image) key(desc)operator(:) string(Use ! exclamation marks to insert an image tag.) @@ -211,47 +211,47 @@ key(html)operator(:) string(
    Heading 6
    ) head key(name)operator(:) string(paragraph text) key(desc)operator(:) string -key(in)operator(:) string(|-) - string(p. A paragraph.) - string(Continued.) +key(in)operator(:) stringA paragraph.
    ) - string(Continued.

    ) - string(

    Also a paragraph.

    ) + Also a paragraph.)> +key(html)operator(:) stringA paragraph.
    + Continued.

    +

    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. A quotation.) - string(Continued.) +key(in)operator(:) string) - string(

    A quotation.
    ) - string(Continued.

    ) - string() - string(

    Regular paragraph.

    ) + Regular paragraph.)> +key(html)operator(:) string +

    A quotation.
    + Continued.

    + +

    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 cited quotation.

    ) - string(
    ) +key(html)operator(:) string +

    A cited quotation.

    + )> 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 footnote reference[1].) +key(in)operator(:) stringA footnote reference1.

    ) - string(

    1 The footnote.

    ) + fn1. The footnote.)> +key(html)operator(:) stringA footnote reference1.

    +

    1 The footnote.

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

    A footnote reference1.

    ) comment(#

    1 The footnote.

    ) @@ -259,39 +259,39 @@ 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. ) -key(html)operator(:) string(|-) - string(
    <script>)
-  string(// a Javascript example)
-  string(alert("Hello World"\);)
-  variable(</script>
    ) +key(in)operator(:) string + // a Javascript example + alert("Hello World"\); + )> +key(html)operator(:) string<script> + // a Javascript example + alert("Hello World"\); + </script>)> 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. Pre-formatted)
-  string(text)
-key(html)operator(:) string(|-)
-  string(
    Pre-formatted)
-  string(text
    )
+key(in)operator(:) string
+key(html)operator(:) stringPre-formatted
+  text
    )> 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() -key(html)operator(:) string(|-) - string() - string() +key(in)operator(:) string + document.write("Hello World!"\); + + )> +key(html)operator(:) string + document.write("Hello World!"\); + + )> key(valid_html)operator(:) string(false) head key(name)operator(:) string(class attribute) @@ -338,81 +338,81 @@ key(html)operator(:) string(

    A 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.. A quote.) +key(in)operator(:) string) - string(

    A quote.

    ) - string(

    The quote continued.

    ) - string() - string(

    Back to paragraph text.

    ) + p. Back to paragraph text.)> +key(html)operator(:) string +

    A quote.

    +

    The quote continued.

    + +

    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 PHP code example.) +key(in)operator(:) string) + print "Hello, World"; + } + ?> - string(p. Following paragraph.) -key(html)operator(:) string(|-) - string(

    A PHP code example.

    ) - string(
    <?php)
-  string(function hello(\) {)
-  string(// display a hello message)
+  p. Following paragraph.)>
+key(html)operator(:) stringA PHP code example.
    
+  
    <?php
+  function hello(\) {
+  // display a hello message
 
-  string(print "Hello, World";)
-  operator(})
-  string(?>)
+  print "Hello, World";
+  }
+  ?>
 
-  string(
    )
-  string(
    Following paragraph.
    )
+
    +

    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\).. A classy paragraph.) +key(in)operator(:) stringA classy paragraph.

    ) - string(

    Another classy paragraph.

    ) - string(

    Not so classy.

    ) + p. Not so classy.)> +key(html)operator(:) stringA classy paragraph.

    +

    Another classy paragraph.

    +

    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\).. Quote paragraph 1.) +key(in)operator(:) string) - string(

    Quote paragraph 1.

    ) - string(

    Paragraph 2.

    ) - string() + Paragraph 2.)> +key(html)operator(:) string +

    Quote paragraph 1.

    +

    Paragraph 2.

    + )> 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\).. Code block 1.) +key(in)operator(:) stringCode block 1.) + Code block 2.)> +key(html)operator(:) stringCode block 1. - string(Code block 2.) + 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.) @@ -446,18 +446,18 @@ key(html)operator(:) string\\nMy div\\n key(name)operator(:) string(complex xhtml blocks 2) key(desc)operator(:) string(...or a notexile.. extended block.) -key(in)operator(:) string(|-) - string(notextile..
    ) +key(in)operator(:) string - string(My div) + My div - string(
    ) -key(html)operator(:) string(|-) - string(
    ) +
    )> +key(html)operator(:) string - string(My div) + My div - string() + )> 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) @@ -466,36 +466,36 @@ key(html)operator(:) string\\nMy div 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 HTML example)
-  string(
    ) -key(html)operator(:) string(|-) - string(
    )
-  string(A HTML <b>example</b>)
-  string(
    ) +key(in)operator(:) string + A HTML example + )> +key(html)operator(:) string + A HTML <b>example</b> + )> 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.) 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 HTML example) - string() -key(html)operator(:) string(|-) - string(

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

    ) +key(in)operator(:) string + Another HTML example + )> +key(html)operator(:) string + Another HTML <b>example</b> +

    )> 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.) 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. Leave me alone) - string() -key(html)operator(:) string(|-) - string(p. Leave me alone) +key(in)operator(:) string + p. Leave me alone + )> +key(html)operator(:) string comment(# html: |-) comment(#

    ) comment(# p. Leave me alone) @@ -538,204 +538,204 @@ key(html)operator(:) string(

    Left head key(name)operator(:) string(numeric lists) 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 one
      2. ) - string(
    2. Item two
      3. ) - string(
    3. Item three
      4. ) - string(
    ) +key(in)operator(:) string +key(html)operator(:) string +
  • Item one
    • +
  • Item two
    • +
  • Item three
    • + )> head key(name)operator(:) string(bulleted lists) key(desc)operator(:) string(Bulleted lists are represented by lines beginning with *.) -key(in)operator(:) string(|-) - string(* Item A) - string(* Item B) - string(* Item C) -key(html)operator(:) string(|-) - string(
      ) - string(
    • Item A
      • ) - string(
    • Item B
      • ) - string(
    • Item C
      • ) - string(
    ) +key(in)operator(:) string +key(html)operator(:) string +
  • Item A
    • +
  • Item B
    • +
  • Item C
    • + )> 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:red} Item one) - string(* Item two) - string(* Item three) -key(html)operator(:) string(|-) - string(
      ) - string(
    • Item one
      • ) - string(
    • Item two
      • ) - string(
    • Item three
      • ) - string(
    ) +key(in)operator(:) string +key(html)operator(:) string +
  • Item one
    • +
  • Item two
    • +
  • Item three
    • + )> head key(name)operator(:) string(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) - comment(## Item one-B) - comment(### Item one-B-a) - comment(# Item two) -key(html)operator(:) string(|-) - string(
      ) - string(
    1. Item one) - string(
        ) - string(
      1. Item one-A
        2. ) - string(
      2. Item one-B) - string(
          ) - string(
        1. Item one-B-a
          2. ) - string(
        3. ) - string(
      2. ) - string(
    2. Item two
      3. ) - string(
    ) +key(in)operator(:) string +key(html)operator(:) string +
  • Item one +
      +
    1. Item one-A
      2. +
    2. Item one-B +
        +
      1. Item one-B-a
        2. +
      3. +
    • +
  • Item two
    • + )> 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|) -key(html)operator(:) string(|-) - string() - string() - string() - string() - string() - string() - string(
    asimpletable
    ) +key(in)operator(:) stringstring(a|simple|table|) +key(html)operator(:) string + + a + simple + table + + )> head key(name)operator(:) string(table heading cells) key(desc)operator(:) string(Use _. to indicate table heading cells.) -key(in)operator(:) string(|-) - string(|_. a|_. table|_. heading|) - string(|a|table|row|) -key(html)operator(:) string(|-) - string() - string() - string() - string() - string() - string() - string() - string() - string() - string() - string() - string(
    atableheading
    atablerow
    ) +key(in)operator(:) string +key(html)operator(:) string + + a + table + heading + + + a + table + row + + )> 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|) -key(html)operator(:) string(|-) - string() - string() - string() - string() - string() - string() - string(
    astyledcell
    ) +key(in)operator(:) stringstring(a|{color:red}. styled|cell|) +key(html)operator(:) string + + a + styled + cell + + )> 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(
    aclassyrow
    ) +key(html)operator(:) string + + a + classy + row + + )> 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(|-) - string(table(tableclass\).) - string(|a|classy|table|) - string(|a|classy|table|) -key(html)operator(:) string(|-) - string() - string() - string() - string() - string() - string() - string() - string() - string() - string() - string() - string(
    aclassytable
    aclassytable
    ) +key(in)operator(:) string +key(html)operator(:) string + + a + classy + table + + + a + classy + table + + )> 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() - string() - string(
    top alignment
    ) +key(in)operator(:) stringstring(^. top alignment|) +key(html)operator(:) string + + top alignment + + )> head key(name)operator(:) string(vertical alignment 2) -key(in)operator(:) string(|-) - string(|-. middle alignment|) -key(html)operator(:) string(|-) - string() - string() - string() - string() - string(
    middle alignment
    ) +key(in)operator(:) string +key(html)operator(:) string + + middle alignment + + )> head key(name)operator(:) string(vertical alignment 3) -key(in)operator(:) string(|-) - string(|~. bottom alignment|) -key(html)operator(:) string(|-) - string() - string() - string() - string() - string(
    bottom alignment
    ) +key(in)operator(:) string +key(html)operator(:) string + + bottom alignment + + )> 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. spans two cols |) - string(| col 1 | col 2 |) -key(html)operator(:) string(|-) - string() - string() - string() - string() - string() - string() - string() - string() - string(
    spans two cols
    col 1 col 2
    ) +key(in)operator(:) string +key(html)operator(:) string + + spans two cols + + + col 1 + col 2 + + )> 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. spans 3 rows | row a |) - string(| row b |) - string(| row c |) -key(html)operator(:) string(|-) - string() - string() - string() - string() - string() - string() - string() - string() - string() - string() - string() - string(
    spans 3 rows row a
    row b
    row c
    ) +key(in)operator(:) string +key(html)operator(:) string + + spans 3 rows + row a + + + row b + + + row c + + )> head key(name)operator(:) string(whitespace required) key(desc)operator(:) string(Links, images and phrase modifiers normally require surrounding whitespace.) @@ -758,14 +758,14 @@ key(html)operator(:) string(

    2 logn

    ) 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 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 closeimage.
    ) - string(A tighttextlink.
    ) - string(A footnoted link1.

    ) +key(in)operator(:) string +key(html)operator(:) stringA closeimage.
    + A tighttextlink.
    + 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 index 171afa3..45b2498 100644 --- a/test/scanners/yaml/website.expected.raydebug +++ b/test/scanners/yaml/website.expected.raydebug @@ -1,9 +1,9 @@ -string(%YAML 1.2) +doctype(%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(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/) @@ -52,18 +52,18 @@ key(News)operator(:) 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(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(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. + 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.) -- cgit v1.2.1