Remarkably can be used as template enginge generating HTML pages by
 calling "pure" ruby methods, e.g.:
 html do
   header do
   title "my header"
   end
   body do
     h1 "big header"
     ul do
       (1..2).each do |n|
         li "line #{n}"
       end
     end
   end
 end

 This beautiful approach allows ruby control statements while generating
 the desired page without the hassle other template engines have when
 mixing HTML tags and ruby control.

 A remarkably fact about Remarkably is, that is does not know anything
 about HTML tags. It handles the generating of the desired page source by
 using the ruby mechanism of the "method_missing" message: every(!) unkown
 method will be recovered by generating appropriate HTML statements.

 One of the consequences of approach is, that the parameters of such a "tag"
 must follow some rules: it have to look like
 sym(args, hash, &block)
 that means, eventual arguments must be set before an eventual hash, which
 sets the tag attributes, followed by an eventual block, which contains included
 other tags.

 Sounds terrible complicated, but it is not, e.g.: the ruby statement
 a('Home', :href => "#{rs(:index)}")
 will generate after the ruby interpolation
 <a href="/index">Home</a>

 To generate an anchor with a graphic icon like
 <a href="/help" title="Help">
   <img src="icons/help.png" border="0" alt="Help"/>
 </a>
 can be produced e.g. by
 def gen_link(txt, href, icon)
   a(:href => href, :title => txt) do
     img(:src => icon, :border => 0, :alt => txt)
   end # a
 end # genlink
 gen_link('Help', "#{rs(:help)}", 'icons/help.png')
 You see, it is also possible to call methods when generating the page.

 This shows another challenge: you can not generate a tag, which name
 conflicts with a well known ruby method, e.g.:
 p "this is some text"
 will use the kernel method p to print the message to the console. To
 generate a paragraph, you can use an upcase P like
 P "this is another paragraph"
 Dont worry, Remarkably uses .downcase when generating the code:
 <p>this is another paragraph</p>
 which keeps it XHTML conform.

 The missing_method approach also has the consequence, that Reamrkably
 can not check for valid HTML tags, e.g.:
 xyz(:abc => "nonsens")
 generates a syntatic correct, but semantic wrong output
 <xyz abc="nonsens">
 So check careful the page source offered from your browser.

 There are at least two differences to Markaby: the "syntactic" sugar
 for .class and .id! is not supported, e.g.:
 div.myclass
 must be edited to
 div(:class => 'myclass')
 and
 div.myid!
 must be edited to
 div(:id => 'myid')

 To insert some (eventual ruby interpolated) text in the page use text(), e.g.:
 text("#{@content}")

 To use Remarkably within Ramaze just set in your controller:
 class Controller < Ramaze::Controller
   helper :remarkably
   engine :Remarkably
 end # controller
 and put your Remarkably files named *.rem into the view/ directory

 To keep Ramaze happy, you should terminate your .rem files with the line:
   remarkably_engine