rweb 0.1.0 → 0.2.0

data/Changes.rdoc

@@ -1,4 +1,13 @@
 = Release History
+Version 0.2.0 (2007-08-18)::
+- complete library for tangling and weaving both plaintext and XHTML
+- XHTML weaving will make use of the +syntax+ gem if available but does not
+  require it
+- RDOC documentation updated and expanded
+- test suite expanded and hardened
+- internal representation of parsed RWEB document completely rewritten
+- plug-in architecture provided in bare-bones format (no external interace yet)
+
 Version 0.1.0 (2007-08-04)::
 - complete library for tangling as well as for weaving to plaintext
 - RDOC documentation completed

data/README.rdoc

@@ -6,11 +6,16 @@ Welcome to the _RWEB_ package.  _RWEB_ is several things:
   Ruby programs in the more traditional form you see based on Knuth's WEB;
 - it is a framework for customizing the weaving process to enable any back-end
   the user desires to use for generating documentation.
+  
+The _RWEB_ package can be retrieved from its {Rubyforge project
+page}[http://rubyforge.org/projects/rubylit/].
 
 == This release
-This release of _RWEB_ only handles plain text for weaving and has the basic
-framework for handling XHTML in the planning pipeline. It is very much a bare-
-bones system, albeit a usable one. The files of note are:
+
+This release of _RWEB_ handles both plain text and XHTML for weaving and has the
+beginnings of a framework for user-supplied plug-ins in the planning pipeline.
+It is very much a usable system, however, with the XHTML output in particular
+being well-suited to blogging. The files of note are:
 
 lib/rweb.rb:: 
   This is the library file that does the heavy lifting for the package. It needs
@@ -19,9 +24,9 @@ lib/rweb.rb::
   module is private utility functions.
 
 bin/rtangle and bin/rweave::
-  These scripts are self-tangling _RWEB_ documents in plain text format which
-  tangle and weave respectively _RWEB_ documents and generate appropriate
-  output.
+  These scripts are self-tangling _RWEB_ documents in plain text format
+  (rtangle) and XHTML format (rweave) which tangle and weave respectively _RWEB_
+  documents and generate appropriate output.
 
 COPYING::
   The license under which this program is released. Read it. Know your rights
@@ -68,9 +73,14 @@ Currently only two keys are supported:
 
 The +style+ key reflects the documentation style used in the underlying _RWEB_
 document. As of this version the style can only accept the values +Plain+ and
-+XHTML+ and, further, the style +XHTML+ is not yet implemented. Future releases
-will implement XHTML style and will provide tools for user-extended styles to be
-included in the mix.
++XHTML+. Future releases will implement other styles (most notably
+Bluecloth/Markdown) and will provide tools for user-extended styles to be
+included in the mix.  (The beginnings of this framework is already in place.)
+
+XHTML processing provides optional syntax highlighting automatically. If the
+{syntax library}[http://rubyforge.org/projects/syntax/] is available the weaving
+functionality uses it seamlessly behind the scenes. If it is not available for
+use, the Ruby code blocks are passed through unaltered.
 
 The title key is simply text used while generating the documentation and code
 which provides a title to the work. If left unset, it defaults to +Untitled+.

data/TODO.rdoc

@@ -1,4 +1,17 @@
 = TODO
-1. Supply formal unit tests.
-2. Provide XHTML weaving support.
-3. Design generic weaving framework.
+==Supply more formal unit tests.
+
+==Design generic weaving plug-in framework.
+This is partially started in that both plaintext and XHTML are supported through
+externally plugged-in classes.  There are no mechanisms yet, however, for
+registering user classes so this still requires some more thinking.
+
+==Rethink the "plain text" format.
+It may be desirable, in fact, to have Markdown be the default "plain text"
+format. When weaving it can be left up to directives (or command line options,
+for that matter) to decide whether we really want "plain text" or Markdown's
+HTML output. Since both formats have their uses -- Markdown is easily-readable
+as-is while HTML output is useful for things like blogging, etc. -- we could
+probably get away with using Markdown as the default format. Further we could
+even make the choice of output automatic: if the Bluecloth library is available,
+we process it. If it isn't, we don't.

data/bin/rweave

@@ -24,14 +24,18 @@ eval RWEB.tangle(DATA)
 
 __END__
 {title => RWEAVE}
+{style => XHTML}
 
-This is a simple utility that acts as a wrapper around RWEB's weave and, instead
-of executing the resulting code, either prints it to stdout or saves it to a
-given file. Note that RWeave is itself written in RWEB's executable format with
-the boilerplate before the __END__ statement and the actual program document
-afterwards.
+<h2>Introduction</h2>
 
-The mainline code is quite simple:
+<p>This is a simple utility that acts as a wrapper around RWEB's weave and,
+instead of executing the resulting code, either prints it to stdout or saves it
+to a given file. Note that RWeave is itself written in RWEB's executable format
+with the boilerplate before the __END__ statement and the actual program
+document afterwards.</p>
+
+<h3>Mainline</h3>
+<p>The mainline code is quite simple:</p>
 
 << {
 {<<global requires>>}
@@ -43,21 +47,23 @@ The mainline code is quite simple:
 {<<main>>}
 }>>
 
-The only require we need to introduce is to require RWEB itself. This is not, of
-course, necessary if we execute the RWEB document directly. Since, however, it
-is highly likely that we may at some point wish to weave the RWeave utility
+<h3>Requires</h3>
+<p>The only require we need to introduce is to require RWEB itself. This is not,
+of course, necessary if we execute the RWEB document directly. Since, however,
+it is highly likely that we may at some point wish to weave the RWeave utility
 itself into a Ruby source file, we should, pro forma, require the library
-anyway.
+anyway.</p>
 
 << global requires {
 require 'rweb'
 }>>
 
-The weaving stage itself is a very simple function which takes any kind of IO
+<h3>Weaving</h3>
+<p>The weaving stage itself is a very simple function which takes any kind of IO
 object for input, weaves it, then places the resulting string into the output,
 itself an IO object of any kind. It also doesn't care in the slightest exactly
 what kind of IO object is being used, thus suited to application as a filter in
-a potentially longer chain of tools.
+a potentially longer chain of tools.</p>
 
 << weaving {
 def rweave(io_in, io_out)
@@ -65,17 +71,18 @@ def rweave(io_in, io_out)
 end
 }>>
 
-As can be seen, the true heavy lifting is done inside of the RWEB module. This
-utility is a hyper-simple shell around it by comparison.
+<p>As can be seen, the true heavy lifting is done inside of the RWEB module.
+This utility is a hyper-simple shell around it by comparison.</p>
 
-The mainline function is pretty simple as well. It just takes the arguments from
-the command line and passes them to the command line processor blindly,
+<h3>Mainline code</h3>
+<p>The mainline function is pretty simple as well. It just takes the arguments
+from the command line and passes them to the command line processor blindly,
 accepting in return a pair of IO objects -- one for input, the other for output.
 It then calls weave with these objects, wrapping in a begin/ensure clause to
 make sure the IO objects are closed before exiting. The only additional step it
 takes is a call to the function find_block_begin which shadows the IO object
 used for input and silently sweeps away the stuff before __END__ in a document
-if it exists in the first 20 lines.
+if it exists in the first 20 lines.</p>
 
 << main {
 io_in, io_out = process_argv ARGV
@@ -87,7 +94,8 @@ ensure
 end
 }>>
 
-All that's left is the command line processor.
+<h3>Command line processing</h3>
+<p>All that's left is the command line processor.</p>
 
 << command line processing {
 def process_argv args
@@ -104,7 +112,8 @@ def process_argv args
 end
 }>>
 
-The usage message is straightforward and broken out only to reduce code clutter.
+<p>The usage message is straightforward and broken out only to reduce code
+clutter.</p>
 
 << display usage {
 puts "Incorrect command line."

data/lib/rweb.rb

@@ -30,7 +30,18 @@ class Object
   def deep_copy
     Marshal.load(Marshal.dump(self))
   end
-  
+end
+
+=begin rdoc
+Code chunks need to be expanded a bit to associate a name with them. This serves
+partially to assist in creating titles and partially to find the code chunks
+when expanding them.  Documentation chunks need no enhancement.
+=end
+class CodeChunk < Array
+  def initialize(name = "")
+    @name = name
+  end
+  attr_reader :name
 end
 
 # The default values for directives.  The default style for weaving is plain
@@ -52,11 +63,13 @@ end
 # Strip the boilerplate from self-tangling scripts before processing the rest of
 # the document.
 def strip_boilerplate(lines)
+  
   # if we find the __END__ directive in the lines, we return all the lines after
   # that point
   h = 0
   if lines.find { |l| h += 1 ; l == "__END__\n" }
     return lines[h..-1]
+  
   # otherwise this is not a self-tangling script so all the lines count
   else
     return lines
@@ -69,13 +82,16 @@ end
 # beginning of the documentation block and reinserted into the stream.
 def find_directives(lines, directives)
   while line = lines.shift
+  
     # skip blank lines
     if %r{^[:blank:]*$}.match line
       next
+  
     # process directive lines
     elsif %r{^\{([[:print:]]+)[[:blank:]]+=>[[:blank:]]+([[:print:]]+)\}\n$}.match line
       set_directive $1, $2, directives if directives
       next
+  
     # restore the first line of documentation, return the directives
     else
       return directives, lines.unshift(line)
@@ -84,8 +100,10 @@ def find_directives(lines, directives)
 end
 
 # Take a given directive key/value pair and set if if valid.  Valid keys are, at
-# this point, "style" and "title".  "style" may have the values "Plain" or\
-# "XHTML" (not currently implemented).
+# this point, "style" and "title".  "style" may have the values "Plain" or
+# "XHTML" (not currently implemented).  This function needs to be replaced with
+# a more powerful registration scheme when the user-supplied plugins are
+# released.
 def set_directive(key, value, directives)
   case key
     when "style"
@@ -102,132 +120,417 @@ def set_directive(key, value, directives)
 end
 
 # Break the main body of an RWEB document into the documentation intermediate
-# form and a collection of unexpanded chunks.
+# form and a collection of assembled, but unexpanded chunks.
 def get_docs_and_chunks(lines)
-  docs = [] ; chunks = {}
+  docs = []
+  chunks = Hash.new {|h,k| h[k]=CodeChunk.new(k)}
+  current_doc = []
+  
   # directives are already gone, so we start in documentation
   while line = lines.shift
-    # if a chunk starts, push the name of the chunk into the docs and then
-    # extract the chunk
+    
+    # if a code chunk starts, close off the current documentation chunk, append
+    # it to the docs array, extract the code chunk, append that to the docs
+    # array and start a new documentation chunk
     if %r{^\<\<([[:print:]]*)\{[[:blank:]]*$}.match line
+      docs << current_doc
       name = $1.strip
-      docs.push "{<<#{name}>>}\n"
-      get_chunk lines, name, chunks, docs
-    # otherwise just push the line into the accumulated documentation
+      docs << get_chunk(lines, name, chunks)
+      current_doc = []
+    
+    # otherwise just push the line into the current documentation chunk
     else
-      docs.push line
+      current_doc << line
     end
   end
+  docs << current_doc
   return docs, chunks
 end
 
 # Extract a detected chunk of code.
-def get_chunk(lines, name, chunks, docs)
-  chunks[name] = [] unless chunks.has_key?(name)
+# This function does these things:
+# 1. It extracts a chunk fragment from the RWEB document.
+# 2. It appends the chunk fragment to any code from previous chunk fragments
+#    with the same name.
+# 3. It returns the chunk fragment for inclusion into the RWEB document stream.
+def get_chunk(lines, name, chunks)
+  current_chunk = CodeChunk.new(name)   # this is for the docs array
+
   while line = lines.shift
-    # if we find the closing tag of a chunk, drop it and return
+    
+    # if we find the closing tag of a chunk, drop it and return total current
+    # chunk
     if %r{^\}\>\>[[:blank:]]*$}.match line
-      return
+      return current_chunk  # return the partial chunk for the docs array
+    
     # otherwise add the current line to the named chunk and add the code,
     # marked, to the documentation array for weaving
     else
-      chunks[name].push line
-      docs.push "}}} #{line}" # flag the code in the document stream
+      chunks[name] << line    # accumulated chunk for tangling
+      current_chunk << line   # partial chunk for documentation only
     end
   end
   raise RuntimeError, "chunk '#{name}' not closed by end of input"
 end
 
-# Take a raw chunk and expand all internal references.
+# Take a raw chunk and expand all internal references; used only for tangling.
 def expand_chunk(chunk, chunks, prefix = "", chain = [])
   out = []
   while line = chunk.shift
+    
     # if we spot a chunk reference, validate it and expand its contents into the
     # current chunk
     if %r{^([[:print:][:blank:]]*)\{\<\<([[:print:]]+)\>\>\}([[:print:][:blank:]]*)$}.match line
       name = $2.strip
+      
       # Illegal conditions are:
       # 1. A chunk referenced which has not been defined.
       raise RuntimeError, "chunk '#{name}' referenced without definition" unless chunks.has_key?(name)
+      
       # 2. A chunk reference with anything but whitespace in front or behind.
-      raise RuntimeError, "invalid prefix '#{$1.strip}' when referencing chunk '#{name}'" unless $1.strip == ""
-      raise RuntimeError, "invalid suffix '#{$3.strip}' when referencing chunk '#{name}'" unless $3.strip == ""
+      raise RuntimeError, "bad prefix '#{$1.strip}' using chunk '#{name}'"\
+        unless $1.strip == ""
+      raise RuntimeError, "bad suffix '#{$3.strip}' using chunk '#{name}'"\
+        unless $3.strip == ""
+      
       # 3. A circular expansion of a chunk.
-      raise RuntimeError, "circular expansion of chunk '#{name}'\nexpansion chain is:\n=> #{chain.join("\n=> ")}\n" if chain.include?(name)
+      raise RuntimeError, "circular expansion of chunk '#{name}'\n"\
+            "expansion chain is:\n=> #{chain.join("\n=> ")}\n"\
+        if chain.include?(name)
+      
+      # Anything else is a legal condition.
       chain.push name
-      out.push "#{prefix + $1}# #{name}\n"
-      out.push "#{prefix + $1}# #{"-" * name.length}\n"
+      out << "#{prefix + $1}# #{name}\n"
+      out << "#{prefix + $1}# #{"-" * name.length}\n"
       out += expand_chunk(chunks[name], chunks, prefix + $1, chain)
       chain.pop
     else
-      out.push prefix + line
+      out << prefix + line
     end
   end
   out
 end
 
-# Generate plaintext documentation from the documentation intermediate form.
-# The following actions are taken:
-# 1. The title is placed at the top and double-underlined.
-# 2. Documentation lines are passed through unaltered.
-# 3. Chunk names are emitted without the tags and with single-underlining.
-# 4. Chunk contents are emitted with "> " prepended.
-def generate_plain_document(docs, directives)
-  raise RuntimeError, "style directive not set to Plain" unless directives[:style] == "Plain"
-  out = []
-  title = directives[:title]
-  
-  out << ["#{title}\n","#{"="*title.length}\n"]
-  docs.each do |line|
-    # if we find a chunk reference, extract the name and underline it, the
-    # mainline chunk being given the title "RWEB Mainline"
-    if %r{^\{\<\<([[:print:]]*)\>\>\}\n$}.match line
-      line = $1
-      line = "RWEB Mainline" if line == ""
-      out << ["#{line}\n","#{"-"*line.length}\n"]
-    # if we find a line of code, emit it with added "chicken feet" to the front.
-    elsif %r{^\}\}\} (.*)\n$}.match line
-      out << ["> #{$1}\n"]
-    # otherwise just emit the line
-    else
-      out << line
+=begin rdoc
+This class uses a dynamically-assigned generator class to walk the documentation
+array and build the final output document.
+=end
+class Document
+
+public
+
+  # Initializes the document system with an appropriate generator, checks for
+  # sanity in the setup and then builds the document internally.
+  def initialize(generator)
+    @output = []
+    @generator=generator
+    @style = generator.style
+    @docs = generator.docs
+    @directives = generator.directives
+    check_sanity
+    build_document
+  end
+
+  # Converts the built document into a string.
+  def to_s
+    @output.to_s
+  end
+
+private
+
+  # The workhorse of the weaving system.  Builds up output form by:
+  # 1. Using the generator to build a header based on the title of the RWEB
+  #    document.
+  # 2. Walking over the documentation array and passing each code or document
+  #    chunk as appropriate to the generator.
+  # 3. Using the generator to append a footer to the output.
+  def build_document
+    @output << @generator.header(@directives[:title])
+    @docs.each do |chunk|
+      if chunk.instance_of? CodeChunk
+        @output << @generator.code(chunk)
+      else
+        @output << @generator.doc(chunk)
+      end
     end
+    @output << @generator.footer
   end
-  out.to_s
-end
 
-# Generate XHTML documentation from the documentation intermediate form.
-# NOT YET IMPLEMENTED!
-def generate_xhtml_document(docs, directives)
-  raise RuntimeError, "style directive not set to XHTML" unless directives[:style] == "XHTML"
-  raise NotImplementedError, "document style not implemented"
+  # Check to ensure the sanity of the system before trying to build documents.
+  def check_sanity
+
+    # make sure the actual document style matches the generator's expected style
+    raise RuntimeError, "style mismatch: #{@style} to be processed, " \
+          "#{@directives[:style]} passed" \
+      unless @style == @directives[:style]
+  end
 end
 
 =begin rdoc
-The RWEB module is the public interface to the RWEB library and contains only
-three publicly-accessible symbols.  First, the version of the library is
-provided (for build purposes).  Second, the RWEB.tangle function is exposed
-which takes an IO object and returns a string containing the tangled code ready
-for execution.  Third, the RWEB.weave function is exposed which takes an IO
-object and returns a string containing the documentation in the appropriate
-format.
+The RWEB module is the public interface to the RWEB library and contains the
+following publicly-accessible symbols:
+1. The version of the library (VERSION).
+2. The RWEB.tangle function which takes an IO object and returns a string
+   containing the tangled code ready for execution.
+3. The RWEB.weave function which takes an IO object and returns a string
+   containing the documentation in the appropriate format.
+4. The Generator class, an "abstract class" which forces any document generation
+   to conform to the correct footprint.  Any generator for weaving back-ends
+   must inherit from this generic class and must call super in its
+   initialization. 
 =end
 module RWEB
 
-  VERSION = "0.1.0"
+VERSION = "0.2.0"
+
+# Tangle an RWEB document and return the code as a string.
+def RWEB.tangle(io)
+  directives, docs, chunks = disassemble(io.readlines)
+  raise RuntimeError, "no mainline chunk found in file"\
+    unless chunks.has_key?("")
+
+  "# #{directives[:title]}\n"\
+  "# #{"=" * directives[:title].length}\n\n"\
+  + expand_chunk(chunks[""], chunks).to_s
+end
+
+# Weave the RWEB document into another format according to directives and
+# return as a string.
+def RWEB.weave(io)
+  directives, docs, chunks = disassemble(io.readlines)
+  eval "Document.new(#{directives[:style]}Generator.new(docs, directives)).to_s"
+end
+
+=begin rdoc
+The core of document generation is this Generator class, an abstract class that
+sets the footprint and makes sure that any implementing class has all required
+methods covered. Generators must provide all of the methods with proper
+semantics outlined in each method's documentation.
+
+Any state changes in the documentation (like the transition from code block to
+document block) must be handled by identifying the state changes through
+methods.
+=end
+class Generator
+
+  # This method gets the array of documentation/code chunks and the block of
+  # detected directives.  Any derived class *must* ensure that docs and
+  # directives are appropriately passed up the chain to this implementation.
+  # Too, any derived class *must* ensure that an @style member is set to the
+  # appropriate documentation style (as per the "style" keyword in directives).
+  def initialize(docs, directives)
+    @docs = docs
+    @directives = directives
+  end
+  attr_reader :style, :docs, :directives
   
-  # Tangle an RWEB document and return the code as a string.
-  def RWEB.tangle(io)
-    directives, docs, chunks = disassemble(io.readlines)
-    raise RuntimeError, "no mainline chunk found in file" unless chunks.has_key?("")
-    "# #{directives[:title]}\n# #{"=" * directives[:title].length}\n\n" + expand_chunk(chunks[""], chunks).to_s
+  # This method gets called at the beginning of the document for initialization
+  # of the document format: e.g. XHTML's <html>, <head> and <body> tags.
+  def header(title)
+    raise NotImplementedError, "#{self.class.name}#header is an abstract method."
+  end
+  
+  # This method gets called to perform any transformations on documentation 
+  # chunks.  For example Markdown-formatted plaintext might get run through
+  # BlueCloth to get turned into proper HTML here.
+  def doc(chunk)
+    raise NotImplementedError, "#{self.class.name}#doc is an abstract method."
+  end
+  
+  # This method gets called to perform any transformations on code chunks.  For
+  # example code can be syntax-highlighted.
+  def code(chunk)
+    raise NotImplementedError, "#{self.class.name}#code is an abstract method."
   end
 
-  # Weave the RWEB document into another format according to directives and
-  # return as a string.
-  def RWEB.weave(io)
-    directives, docs, chunks = disassemble(io.readlines)
-    eval "generate_#{directives[:style].downcase}_document(docs, directives)"
+  # This method gets called at the end of the document for closing document
+  # sequences: e.g. XHTML's </html> and </body> tags.
+  def footer
+    raise NotImplementedError, "#{self.class.name}#footer is an abstract method."
+  end
+end
+
+end   # module RWEB
+
+=begin rdoc
+PlainGenerator is a simple object that does very little processing on code
+and/or document lines. Its implementation is similarly simple.
+=end
+class PlainGenerator < RWEB::Generator
+
+  # The initialize function just sets the style and does no other preparation.
+  def initialize(*args)
+    @style = "Plain"
+    super
   end
   
+  # The header function prints out the title and then "double-underlines" it.
+  def header(title)
+    "#{title}\n" "#{"="*title.length}\n"
+  end
+  
+  # The chunk function prints out the name and "single-underlines" it, then
+  # follows through with printing each code line with pre-pended "chicken feet".
+  def code(chunk)
+    "#{chunk.name}\n" "#{"-"*chunk.name.length}\n" +
+      chunk.map { |line| "> " + line}.to_s
+  end
+  
+  # The doc function passes the documentation chunk through unchanged.
+  def doc(chunk)
+    chunk.to_s
+  end
+  
+  # The footer function does nothing.
+  def footer
+    ""
+  end
+end
+
+=begin rdoc
+XHTMLGenerator is a more-involved object that does some simple, but verbose and
+tedious, alteration of the incoming document.
+=end
+class XHTMLGenerator < RWEB::Generator
+
+  class DoNothingConverter
+    def convert(code)
+      code
+    end
+  end
+  
+  # A more involved initialization block.  It tries to bring in the syntax gem
+  # and, if successful, sets up syntax conversion.  If unsuccessful it puts in
+  # a dummy function for "converting" which does nothing.
+  def initialize(*args)
+    # First we check for the presence of RubyGems.
+    begin
+      begin
+        require 'rubygems'
+      rescue LoadError
+        # we don't have rubygems, but that's OK -- syntax may be installed anyway
+      end
+      require 'syntax/convertors/html'
+      @html_converter = Syntax::Convertors::HTML.for_syntax "ruby"
+    rescue LoadError
+      @html_converter = DoNothingConverter.new
+    end
+    
+    @style = "XHTML"
+    super
+  end
+
+  # This is tedious, but not complicated. It writes the boilerplate that is the
+  # curse of HTML documentation and any CSS that has been set up out-of-band.
+  # (Of course the documentation portion of the RWEB document can just as easily
+  # contain CSS as it can anything else.)  The syntax-highlighting CSS is
+  # taken from the syntax gem verbatim as a default.
+  def header(title)
+    <<-HEADER
+      <?xml version="1.0" encoding="UTF-8"?>
+      <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+      <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+        <head>
+          <meta content="text/html; charset=utf-8" http-equiv="Content-Type"/>
+          <title>#{title}</title>
+          <style type="text/css">
+            .chunk-title {
+              border-bottom: thin solid;
+              font-style: italic;
+              font-weight: bold;
+              width: 80%;
+            }
+            .chunk-contents {
+              border-bottom: thin dotted; 
+              font-family: monospace;
+              overflow: auto;
+              width: 80%;
+            }
+            a.chunk-reference {
+              border: thin dotted red;
+              font-style: italic;
+              padding: 1px;
+            }
+            .normal {}
+            .comment { color: #005; font-style: italic; }
+            .keyword { color: #A00; font-weight: bold; }
+            .method { color: #077; }
+            .class { color: #074; }
+            .module { color: #050; }
+            .punct { color: #447; font-weight: bold; }
+            .symbol { color: #099; }
+            .string { color: #944; background: #FFE; }
+            .char { color: #F07; }
+            .ident { color: #004; }
+            .constant { color: #07F; }
+            .regex { color: #B66; background: #FEF; }
+            .number { color: #F99; }
+            .attribute { color: #7BB; }
+            .global { color: #7FB; }
+            .expr { color: #227; }
+            .escape { color: #277; }
+          </style>
+        </head>
+        <body>
+        <h1>#{title}</h1>
+    HEADER
+  end
+
+  # A chunk is now written with the title in its own special division and given
+  # a hypertext name.  A code block, too, is opened with appropriate tags.  
+  def code(chunk)
+    header = <<-CHUNK_HEADER
+      <blockquote>
+        <div class="chunk-title">
+          <a name="#{chunk.name}" id="#{chunk.name}">#{chunk.name}</a>
+        </div>
+        <div class="chunk-contents"><pre><code>
+    CHUNK_HEADER
+    header = header[0..-2]
+    
+    body = ""
+    subchunk = ""
+    chunk.each do |line|
+      # if we have a chunk reference, syntax-highlight the subchunk we're
+      # building, add it to the body, make an href of the chunk reference, add
+      # it to the body, then restart the subchunking.
+      if %r{^([[:print:][:blank:]]*)\{\<\<([[:print:]]+)\>\>\}([[:print:][:blank:]]*)$}.match line
+        prefix = $1
+        name = $2.strip
+        suffix = $3
+
+        body += @html_converter.convert(subchunk)
+        body += prefix + "<a class=\"chunk-reference\" href=\"##{name}\">" + name + "</a>" + suffix + "\n"
+        subchunk = ""
+        
+      # add the line to the subchunk
+      else
+        subchunk += line
+      end
+    end
+    body += @html_converter.convert(subchunk)[0..-2]
+    body.strip!
+
+    footer = <<-CHUNK_FOOTER
+        </code></pre></div>
+      </blockquote>
+    CHUNK_FOOTER
+    
+    header + body + footer   
+  end
+  
+  # The documentation requires no processing -- it's XHTML and already
+  # "processed".  Copy it through.
+  def doc(chunk)
+    chunk.to_s  
+  end
+
+  # This closes off all tags left open from code blocks or paragraphs as well as
+  # from the header.
+  def footer
+    <<-FOOTER
+        </body>
+      </html>    
+    FOOTER
+  end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: rweb
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2007-08-04 00:00:00 +08:00
+  version: 0.2.0
+date: 2007-08-18 00:00:00 +08:00
 summary: Self-executing WEB-like literate programming for Ruby.
 require_paths: 
 - lib