panmind-rtf 0.3.1 → 0.4.0

data/{README → README.rdoc}

@@ -1,3 +1,14 @@
+== Purpose of this fork
+
+ * Add support for ordered and unordered lists [done]
+ * Write comprehensive tests for OL and UL [TODO]
+ * Clean up the API [TODO]
+ * DRY the code [TODO]
+
+Please, please, please: if you come along this library and would lend me an
+hand to complete tests, please help. Thank you!
+
+
 == Ruby Rich Text Format (RTF) Library
 The RTF library provides a pure Ruby set of functionality that can be used to
 programmatically create RTF documents. The main aim in developing this library
@@ -58,8 +69,6 @@ you are already familiar with the Ruby language. So, for a start, consider...
    require 'rubygems'
    require 'rtf'
 
-   include RTF
-
 The first thing to look at here at the are the first two lines. The RTF library
 is provided as a Ruby gem and these two lines load the libraries functionality
 into the script. The third line of code includes the RTF module into the current
@@ -67,7 +76,7 @@ name space. This is a convenience mechanism that saves on specifically having
 to refer to the module when accessing the RTF library. Next we want to create
 an RTF document and that is done like this...
 
-   document = Document.new(Font.new(Font::ROMAN, 'Times New Roman'))
+   document = RTF::Document.new(RTF::Font.new(RTF::Font::ROMAN, 'Times New Roman'))
 
 This line of code creates a new Document object, specifying that the default
 font for the document will the the Times New Roman font. So we have a document,
@@ -93,74 +102,69 @@ some code into the document. We want the code to appear in the document slightly
 indented on the left hand side, in a non-proportionately space font and we want
 it in bold text. Heres the code that shows how to do that...
 
-   01 styles = {}
-   02 styles['PS_CODE'] = ParagraphStyle.new
-   03 styles['CS_CODE'] = CharacterStyle.new
-   04
-   05 styles['PS_CODE'].left_indent = 200
-   06 styles['CS_CODE'].font        = Font.new(Font::MODERN, 'Courier')
-   07 styles['CS_CODE'].bold        = true
-   08
-   09 document.paragraph(styles['PS_CODE']) do |n1|
-   10    n1.apply(styles['CS_CODE']) do |n2|
-   11       n2 << "count = 0"
-   12       n2.line_break
-   13       n2 << "File.open('file.txt', 'r') do |file|"
-   14       n2.line_break
-   15       n2 << "   file.each_line {|line| count += 1}"
-   16       n2.line_break
-   17       n2 << "end"
-   18       n2.line_break
-   19       n2 << "puts \"File contains \#{count} lines.\""
-   20    end
-   21 end
+   01 code_para = ParagraphStyle.new
+   02 code_para.left_indent = 200
+   03
+   04 code_char = CharacterStyle.new
+   05 code_char.font = RTF::Font::MODERN
+   06 code_char.bold = true
+   07
+   08 document.paragraph(code_para) do |p|
+   09   p.apply(code_char) do |c|
+   10     c << "count = 0"
+   11     c.line_break
+   12     c << "File.open('file.txt', 'r') do |file|"
+   13     c.line_break
+   14     c << "   file.each_line {|line| count += 1}"
+   15     c.line_break
+   16     c << "end"
+   17     c.line_break
+   18     c << "puts \"File contains \#{count} lines.\""
+   19   end
+   20 end
 
 This is a much larger piece of code and covers a number of topics that need to
 be addressed. I have included line numbers with code so that individual elements
-can be referenced. Lines 1 to 3 are the first new elements. Here we create a
-Hash and assign it to a variable called styles. On the next two lines we create
+can be referenced. Lines 1 to 6 are the first new elements. Here we create
 two style objects, one that can be applied to paragraphs and one that applies
 to characters.
 
-On lines 5 to 7 we update settings on the style objects we've created. We set
-the left indentation value of the paragraph style to 200. The 200 in this case
-refers to a measurement of twips. A twip is a type setting measurement that
-equates to one twentieth of a point (about a fifty seventh of a millimetre or
-one seventy second of an inch). This is the measurement scale used by RTF
-documents so it is also employed in the library.
+On line 2 we set the left indentation value of the paragraph style to 200 *twips*.
+A twip is a type setting measurement that equates to one twentieth of a point
+(about a fifty seventh of a millimetre or one seventy second of an inch). This is
+the measurement scale used by RTF documents.
+
+On lines 5 and 6 we update the character style to use a courier font and to
+apply bold styling to the text.
 
-On lines 6 and 7 we update the character style to use a courier font and to
-apply bold styling to the text. On line 9 we start a new paragraph in our
-document. This differs from our previous use of this method in that we specify
-a style that will be applied to the paragraph created, the paragraph style we
-had prepared earlier.
+On line 8 we start a new paragraph in our document. This differs from our previous
+use of this method in that we specify a style that will be applied to the paragraph
+using the one we prepared earlier.
 
 The block accompanying the paragraph method takes the single parameter that we
 have seen previously. At this point its probably a good idea to point out that
 the elements that make up an RTF document created with the library are all
-stored as nodes in a tree. We've named the one passed to the paragraph method as
-n1 to reflect this.
+stored as nodes in a tree.
+
+Within the block, the +apply+ method applies a character style, and we're using
+the one we prepared earlier.
 
-Within the block we've called a method on the paragraph node called apply. This
-method applies a character style and we're using the one we prepared earlier.
 Like the call to the paragraph method, the apply method is passed a block. All
-text added to the blocks node (n2 in this case) will have the styling we've
-defined (bold courier font) applied to it.
+text added to the blocks node will have the styling we've defined (bold courier
+font) applied to it.
 
-Note, that within the apply block we could still use the n1 node. Any text we
-added to this would appear in the paragraph but wouldn't be styled and, it
-should be noted, will appear before any text added to n2 (as the n2 node only
-becomes part of the document when the apply block completes).
+Note, that within the apply block we could still use the previous (p) node. Any
+text we added to this would appear in the paragraph but wouldn't be styled and,
+it should be noted, will appear before any text added to c, as the c node only
+becomes part of the document when the apply block completes.
 
-Within the apply method block we add some lines of text to the n2 node. Note
+Within the apply method block we add some lines of text to the c node. Note
 that, as this is all encompassed within the parapgraph block, all the text is
 part of a single paragraph. To get each of the lines of code to appear on a
 line of their own we have used the line_break method which inserts a carriage
 return into the document. Note you should use this method to insert line breaks
 rather than trying to add a string containing "\n". RTF is a text based standard
-and won't treat "\n" as you're expecting. You should note also that we've had to
-escape the '#' in one of the code lines to stop Ruby considering it as an
-interpolated value.
+and won't treat "\n" as you're expecting.
 
 Okay, so we've seen have the basics of creating a document and adding elements
 to that document. How do we get what we've created to a file. Well thats
@@ -183,4 +187,4 @@ Chris O'Sullivan
 COPYRIGHT
 =========
 
-Copyright (c) 2009-2010 Peter Wood. See LICENSE for details.
+Copyright (c) 2009-2010 Peter Wood. See LICENSE for details.

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
 :major: 0
-:minor: 3
-:patch: 1
+:minor: 4
+:patch: 0
 :build: 

data/lib/rtf.rb

@@ -7,6 +7,7 @@ require 'rtf/style'
 require 'rtf/information'
 require 'rtf/paper'
 require 'rtf/node'
+require 'rtf/list'
 
 # This module encapsulates all the classes and definitions relating to the RTF
 # library.
@@ -31,4 +32,4 @@ module RTF
          raise RTFError.new(message)
       end
    end # End of the RTFError class.
-end # End of the RTF module.
+end # End of the RTF module.

data/lib/rtf/list.rb

@@ -0,0 +1,219 @@
+module RTF
+  class ListTable
+    def initialize
+      @templates = []
+    end
+
+    def new_template
+      @templates.push ListTemplate.new(next_template_id)
+      @templates.last
+    end
+
+    def to_rtf(indent=0)
+      return '' if @templates.empty?
+
+      prefix = indent > 0 ? ' ' * indent : ''
+
+      # List table
+      text = "#{prefix}{\\*\\listtable"
+      @templates.each {|tpl| text << tpl.to_rtf}
+      text << "}"
+
+      # List override table, a Cargo Cult.
+      text << "#{prefix}{\\*\\listoverridetable"
+      @templates.each do |tpl|
+        text << "{\\listoverride\\listid#{tpl.id}\\listoverridecount0\\ls#{tpl.id}}"
+      end
+      text << "}\n"
+    end
+
+    protected
+      def next_template_id
+        @templates.size + 1
+      end
+
+  end
+
+  class ListMarker
+    def initialize(name, codepoint=nil)
+      @name      = name
+      @codepoint = codepoint
+    end
+
+    def bullet?
+      !@codepoint.nil?
+    end
+
+    def type
+      bullet? ? :bullet : :decimal
+    end
+
+    def number_type
+      # 23: bullet, 0: arabic
+      # applies to the \levelnfcN macro
+      #
+      bullet? ? 23 : 0
+    end
+
+    def name
+      name  = "\\{#@name\\}"
+      name << '.' unless bullet?
+      name
+    end
+
+    def template_format
+      # The first char is the string size, the next ones are
+      # either placeholders (\'0X) or actual characters to
+      # include in the format. In the bullet case, \uc0 is
+      # used to get rid of the multibyte translation: we want
+      # an Unicode character.
+      #
+      # In the decimal case, we have a fixed format, with a
+      # dot following the actual number.
+      #
+      if bullet?
+        "\\'01\\uc0\\u#@codepoint"
+      else
+        "\\'02\\'00. "
+      end
+    end
+
+    def text_format(n=nil)
+      text = 
+        if bullet?
+          "\\uc0\\u#@codepoint"
+        else
+          "#{n}."
+        end
+
+      "\t#{text}\t"
+    end
+  end
+
+  class ListTemplate
+    attr_reader :id
+
+    Markers = {
+      :disc    => ListMarker.new('disc',    0x2022),
+      :hyphen  => ListMarker.new('hyphen',  0x2043),
+      :decimal => ListMarker.new('decimal'        )
+    }
+
+    def initialize(id)
+      @levels = []
+      @id     = id
+    end
+
+    def level_for(level, kind = :bullets)
+      @levels[level-1] ||= begin
+        # Only disc for now: we'll add support
+        # for more customization options later
+        marker = Markers[kind == :bullets ? :disc : :decimal]
+        ListLevel.new(self, marker, level)
+      end
+    end
+
+    def to_rtf(indent=0)
+      prefix = indent > 0 ? ' ' * indent : ''
+
+      text = "#{prefix}{\\list\\listtemplate#{id}\\listhybrid"
+      @levels.each {|lvl| text << lvl.to_rtf}
+      text << "{\\listname;}\\listid#{id}}\n"
+
+      text
+    end
+  end
+
+  class ListLevel
+    ValidLevels = (1..9)
+
+    LevelTabs = [
+      220,  720,  1133, 1700, 2267,
+      2834, 3401, 3968, 4535, 5102,
+      5669, 6236, 6803
+    ].freeze
+
+    ResetTabs = [560].concat(LevelTabs[2..-1]).freeze
+
+    attr_reader :level, :marker
+
+    def initialize(template, marker, level)
+      unless marker.kind_of? ListMarker
+        RTFError.fire("Invalid marker #{marker.inspect}")
+      end
+
+      unless ValidLevels.include? level
+        RTFError.fire("Invalid list level: #{level}")
+      end
+
+      @template = template 
+      @level    = level
+      @marker   = marker
+    end
+
+    def type
+      @marker.type
+    end
+
+    def reset_tabs
+      ResetTabs
+    end
+
+    def tabs
+      @tabs ||= begin
+        tabs = LevelTabs.dup # Kernel#tap would be prettier here
+
+        (@level - 1).times do
+          # Reverse-engineered while looking at Textedit.app
+          # generated output: they already made sure that it
+          # would look good on every RTF editor :-p
+          #
+          a,  = tabs.shift(3)
+          a,b = a + 720, a + 1220 
+          tabs.shift while tabs.first < b
+          tabs.unshift a, b
+        end
+
+        tabs
+      end
+    end
+
+    def id
+      @id ||= @template.id * 10 + level
+    end
+
+    def indent
+      @indent ||= level * 720
+    end
+
+    def to_rtf(indent=0)
+      prefix = indent > 0 ? ' ' * indent : ''
+
+      text  = "#{prefix}{\\listlevel\\levelstartat1"
+      
+      # Marker type. The first declaration is for Backward Compatibility (BC).
+      nfc  = @marker.number_type
+      text << "\\levelnfc#{nfc}\\levelnfcn#{nfc}"
+
+      # Justification, currently only left justified (0). First decl for BC.
+      text << '\leveljc0\leveljcn0'
+
+      # Character that follows the level text, currently only TAB.
+      text << '\levelfollow0'
+
+      # BC: Minimum distance from the left & right edges.
+      text << '\levelindent0\levelspace360'
+
+      # Marker name
+      text << "{\\*\\levelmarker #{@marker.name}}"
+
+      # Marker text format
+      text << "{\\leveltext\\leveltemplateid#{id}#{@marker.template_format};}"
+      text << '{\levelnumbers;}'
+
+      # The actual spacing
+      text << "\\fi-360\\li#{self.indent}\\lin#{self.indent}}\n"
+    end
+
+  end
+end

data/lib/rtf/node.rb

@@ -212,6 +212,9 @@ module RTF
       # be written to separate lines whether the node is converted
       # to RTF. Defaults to true
       attr_accessor :split
+      # A boolean to indicate whether the prefix and suffix should
+      # be wrapped in curly braces. Defaults to true.
+      attr_accessor :wrap
 
       # This is the constructor for the CommandNode class.
       #
@@ -223,11 +226,14 @@ module RTF
       # split::   A boolean to indicate whether the prefix and suffix should
       #           be written to separate lines whether the node is converted
       #           to RTF. Defaults to true.
-      def initialize(parent, prefix, suffix=nil, split=true)
+      # wrap::    A boolean to indicate whether the prefix and suffix should
+      #           be wrapped in curly braces. Defaults to true.
+      def initialize(parent, prefix, suffix=nil, split=true, wrap=true)
          super(parent)
          @prefix = prefix
          @suffix = suffix
          @split  = split
+         @wrap   = wrap
       end
 
       # This method adds text to a command node. If the last child node of the
@@ -246,19 +252,20 @@ module RTF
 
       # This method generates the RTF text for a CommandNode object.
       def to_rtf
-         text      = StringIO.new
-         separator = split? ? "\n" : " "
-         line      = (separator == " ")
+         text = StringIO.new
+
+         text << '{'       if wrap?
+         text << @prefix   if @prefix
 
-         text << "{#{@prefix}"
-         text << separator if self.size > 0
          self.each do |entry|
-            text << "\n" if line
-            line = true
-            text << "#{entry.to_rtf}"
+            text << "\n" if split?
+            text << entry.to_rtf
          end
-         text << "\n" if split?
-         text << "#{@suffix}}"
+
+         text << "\n"    if split?
+         text << @suffix if @suffix
+         text << '}'     if wrap?
+
          text.string
       end
 
@@ -273,16 +280,43 @@ module RTF
       #          for the new paragraph. Defaults to nil to indicate that the
       #          currently applied paragraph styling should be used.
       def paragraph(style=nil)
-         # Create the node prefix.
-         text = StringIO.new
-         text << '\pard'
-         text << style.prefix(nil, nil) if style != nil
-
-         node = CommandNode.new(self, text.string, '\par')
+         node = ParagraphNode.new(self, style)
          yield node if block_given?
          self.store(node)
       end
 
+      # This method provides a short cut means of creating a new ordered or
+      # unordered list. The method requires a block that will be passed a
+      # single parameter that'll be a reference to the first level of the
+      # list. See the +ListLevelNode+ doc for more information.
+      #
+      # Example usage:
+      #
+      #   rtf.list do |level1|
+      #     level1.item do |li|
+      #       li << 'some text'
+      #       li.apply(some_style) {|x| x << 'some styled text'}
+      #     end
+      #
+      #     level1.list(:decimal) do |level2|
+      #       level2.item {|li| li << 'some other text in a decimal list'}
+      #       level2.item {|li| li << 'and here we go'}
+      #     end
+      #   end
+      #
+      def list(kind=:bullets)
+        node = ListNode.new(self)
+        yield node.list(kind)
+        self.store(node)
+      end
+
+      def link(url, text=nil)
+        node = LinkNode.new(self, url)
+        node << text if text
+        yield node   if block_given?
+        self.store(node)
+      end
+
       # This method provides a short cut means of creating a line break command
       # node. This command node does not take a block and may possess no other
       # content.
@@ -424,6 +458,21 @@ module RTF
          end
       end
 
+      # This method provides a short cut means of creating a strike command
+      # node. The method accepts a block that will be passed a single parameter
+      # which will be a reference to the strike node created. After the
+      # block is complete the strike node is appended to the end of the
+      # child nodes on the object that the method is call against.
+      def strike
+         style        = CharacterStyle.new
+         style.strike = true
+         if block_given?
+            apply(style) {|node| yield node}
+         else
+            apply(style)
+         end
+      end
+
       # This method provides a short cut means of creating a font command node.
       # The method accepts a block that will be passed a single parameter which
       # will be a reference to the font node created. After the block is
@@ -526,11 +575,123 @@ module RTF
          node
       end
 
-      alias :write :<<
-      alias :color :colour
+      alias :write  :<<
+      alias :color  :colour
       alias :split? :split
+      alias :wrap?  :wrap
    end # End of the CommandNode class.
 
+   # This class represents a paragraph within an RTF document.
+   class ParagraphNode < CommandNode
+     def initialize(parent, style=nil)
+       prefix = '\pard'
+       prefix << style.prefix(nil, nil) if style
+
+       super(parent, prefix, '\par')
+     end
+   end
+
+   # This class represents an ordered/unordered list within an RTF document.
+   #
+   # Currently list nodes can contain any type of node, but this behaviour
+   # will change in future releases. The class overrides the +list+ method
+   # to return a +ListLevelNode+.
+   #
+   class ListNode < CommandNode
+     def initialize(parent)
+       prefix  = "\\"
+
+       suffix  = '\pard'
+       suffix << ListLevel::ResetTabs.map {|tw| "\\tx#{tw}"}.join
+       suffix << '\ql\qlnatural\pardirnatural\cf0 \\'
+
+       super(parent, prefix, suffix, true, false)
+
+       @template = root.lists.new_template
+     end
+
+     # This method creates a new +ListLevelNode+ of the given kind and
+     # stores it in the document tree.
+     #
+     # ==== Parameters
+     # kind::  The kind of this list level, may be either :bullets or :decimal
+     def list(kind)
+       self.store ListLevelNode.new(self, @template, kind)
+     end
+   end
+
+   # This class represents a list level, and carries out indenting information
+   # and the bullet or number that is prepended to each +ListTextNode+.
+   #
+   # The class overrides the +list+ method to implement nesting, and provides
+   # the +item+ method to add a new list item, the +ListTextNode+.
+   class ListLevelNode < CommandNode
+     def initialize(parent, template, kind, level=1)
+       @template = template
+       @kind     = kind
+       @level    = template.level_for(level, kind)
+
+       prefix  = '\pard'
+       prefix << @level.tabs.map {|tw| "\\tx#{tw}"}.join
+       prefix << "\\li#{@level.indent}\\fi-#{@level.indent}"
+       prefix << "\\ql\\qlnatural\\pardirnatural\n"
+       prefix << "\\ls#{@template.id}\\ilvl#{@level.level-1}\\cf0"
+
+       super(parent, prefix, nil, true, false)
+     end
+
+     # Returns the kind of this level, either :bullets or :decimal
+     attr_reader :kind
+
+     # Returns the indenting level of this list, from 1 to 9
+     def level
+       @level.level
+     end
+
+     # Creates a new +ListTextNode+ and yields it to the calling block
+     def item
+       node = ListTextNode.new(self, @level)
+       yield node
+       self.store(node)
+     end
+
+     # Creates a new +ListLevelNode+ to implement nested lists
+     def list(kind=@kind)
+       node = ListLevelNode.new(self, @template, kind, @level.level+1)
+       yield node
+       self.store(node)
+     end
+   end
+
+   # This class represents a list item, that can contain text or
+   # other nodes. Currently any type of node is accepted, but after
+   # more extensive testing this behaviour may change.
+   class ListTextNode < CommandNode
+     def initialize(parent, level)
+       @level  = level
+       @parent = parent
+
+       number = siblings_count + 1 if parent.kind == :decimal
+       prefix = "{\\listtext#{@level.marker.text_format(number)}}"
+       suffix = '\\'
+
+       super(parent, prefix, suffix, false, false)
+     end
+
+     private
+       def siblings_count
+         parent.children.select {|n| n.kind_of?(self.class)}.size
+       end
+   end
+
+   class LinkNode < CommandNode
+     def initialize(parent, url)
+       prefix = "\\field{\\*\\fldinst HYPERLINK \"#{url}\"}{\\fldrslt "
+       suffix = "}"
+
+       super(parent, prefix, suffix, false)
+     end
+   end
 
    # This class represents a table node within an RTF document. Table nodes are
    # specialised container nodes that contain only TableRowNodes and have their
@@ -936,19 +1097,8 @@ module RTF
       # ComamndNode class to forbid the creation of paragraphs.
       #
       # ==== Parameters
-      # justification::  The justification to be applied to the paragraph.
-      # before::         The amount of space, in twips, to be inserted before
-      #                  the paragraph. Defaults to nil.
-      # after::          The amount of space, in twips, to be inserted after
-      #                  the paragraph. Defaults to nil.
-      # left::           The amount of indentation to place on the left of the
-      #                  paragraph. Defaults to nil.
-      # right::          The amount of indentation to place on the right of the
-      #                  paragraph. Defaults to nil.
-      # first::          The amount of indentation to place on the left of the
-      #                  first line in the paragraph. Defaults to nil.
-      def paragraph(justification=CommandNode::LEFT_JUSTIFY, before=nil,
-                    after=nil, left=nil, right=nil, first=nil)
+      # style::  The paragraph style, ignored
+      def paragraph(style=nil)
          RTFError.fire("TableCellNode#paragraph() called. Table cells cannot "\
                        "contain paragraphs.")
       end
@@ -1481,8 +1631,8 @@ module RTF
       LC_VIETNAMESE                    = 1066
 
       # Attribute accessor.
-      attr_reader :fonts, :colours, :information, :character_set, :language,
-                  :style
+      attr_reader :fonts, :lists, :colours, :information, :character_set,
+                  :language, :style
 
       # Attribute mutator.
       attr_writer :character_set, :language
@@ -1501,6 +1651,7 @@ module RTF
       def initialize(font, style=nil, character=CS_ANSI, language=LC_ENGLISH_UK)
          super(nil, '\rtf1')
          @fonts         = FontTable.new(font)
+         @lists         = ListTable.new
          @default_font  = 0
          @colours       = ColourTable.new
          @information   = Information.new
@@ -1654,6 +1805,7 @@ module RTF
          text << "\n#{@fonts.to_rtf}"
          text << "\n#{@colours.to_rtf}" if @colours.size > 0
          text << "\n#{@information.to_rtf}"
+         text << "\n#{@lists.to_rtf}"
          if @headers.compact != []
             text << "\n#{@headers[3].to_rtf}" if @headers[3] != nil
             text << "\n#{@headers[2].to_rtf}" if @headers[2] != nil

data/lib/rtf/style.rb

@@ -302,4 +302,4 @@ module RTF
          end
       end
    end # End of the DocumentStyle class.
-end # End of the RTF module.
+end # End of the RTF module.

data/test/command_node_test.rb

@@ -40,7 +40,7 @@ class CommandNodeTest < Test::Unit::TestCase
 
       assert(root.paragraph(style) != nil)
       assert(root.size == 1)
-      assert(root[0].class == CommandNode)
+      assert(root[0].class == ParagraphNode)
       assert(root[0].prefix == '\pard\ql')
       assert(root[0].suffix == '\par')
       assert(root.split == true)
@@ -161,6 +161,11 @@ class CommandNodeTest < Test::Unit::TestCase
       assert(node.prefix == '\sub')
       assert(node.suffix == nil)
       assert(node == root[-1])
+
+      node = root.strike
+      assert(node.prefix == '\strike')
+      assert(node.suffix == nil)
+      assert(node == root[-1])
    end
 
    # Test text node addition.
@@ -202,6 +207,32 @@ class CommandNodeTest < Test::Unit::TestCase
       assert(table[0][2].width == 200)
    end
 
+   # List object model test
+   def test_list
+      root = Document.new(Font.new(Font::ROMAN, 'Arial'))
+      root.list do |l1|
+        assert l1.class == ListLevelNode
+        assert l1.level == 1
+
+        l1.item do |li|
+          assert li.class == ListTextNode
+          text = li << 'text'
+          assert text.class == TextNode
+          assert text.text == 'text'
+        end
+
+        l1.list do |l2|
+          assert l2.class == ListLevelNode
+          assert l2.level == 2
+          l2.item do |li|
+            text = li << 'text'
+            assert text.class == TextNode
+            assert text.text == 'text'
+          end
+        end
+      end
+   end
+
    # This test checks the previous_node and next_node methods that could not be
    # fully and properly checked in the NodeTest.rb file.
    def test_peers

data/test/information_test.rb

@@ -124,4 +124,4 @@ class InformationTest < Test::Unit::TestCase
       text << "\\hr#{time.hour}\\min#{time.min}}"
       text.string
    end
-end
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 1
-  version: 0.3.1
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Peter Wood
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-14 00:00:00 +02:00
+date: 2010-09-15 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -26,11 +26,11 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
-- README
+- README.rdoc
 files: 
 - CHANGES
 - LICENSE
-- README
+- README.rdoc
 - Rakefile
 - VERSION.yml
 - examples/example01.rb
@@ -45,6 +45,7 @@ files:
 - lib/rtf/colour.rb
 - lib/rtf/font.rb
 - lib/rtf/information.rb
+- lib/rtf/list.rb
 - lib/rtf/node.rb
 - lib/rtf/paper.rb
 - lib/rtf/style.rb